Qué es arduino

1
Introducción
En el siguiente trabajo se redactara y explicara los componentes de un
arduino (microcontralodor), pues en la unidad cursada es lo que se
trabajara. Arduino es una plataforma libre de computación de bajo costo
basada en una placa de entrada y salida en un entorno de desarrollo IDE
que implementa el lenguaje processing/wiringhardware. Arduino se
puede para desarrollar objetos interactivos automáticos o conectarse a
software en el ordenador.
Arduino está basado en dos sistemas totalmente abiertos (Wiring y
Processing), por lo que nos da la total libertad de entender el Hardware y
Software, abriéndonos las posibilidades de desarrollo de sistemas
electrónicos.
Su entorno y modo de programación permite que muchas personas que
son novatas escojan Arduino como herramienta de aprendizaje.
Posee todo su circuito base ya ensamblado así que solo es de armar el
nuestro y programar, ahorrándonos espacio en el protoboard para un IC
el cual simplemente lo conectamos con Jumpers o cables.

2
Contenido
¿Qué es Arduino?................................................................................................................5
Origen de Arduino ..............................................................................................................7
Características del Arduino..............................................................................................8
¿Qué es un microcontrolador?.......................................................................................11
Tipos de microcontrolador:...................................................................................................13
Historia.............................................................................................................................17
Características ..................................................................................................................18
Registros ..........................................................................................................................22
Unidad de control .............................................................................................................23
Buses................................................................................................................................24
Software de Arduino.........................................................................................................26
¿Qué es un IDE?...................................................................................................................26
Instalación del IDE Arduino ...................................................................................................27
Ubuntu.............................................................................................................................27
Fedora..............................................................................................................................27
Sistema Linux....................................................................................................................28
Windows..........................................................................................................................28
Mac OS X ..........................................................................................................................29
Configuración y comprobación del buen funcionamiento del IDE .........................29
Estructura general de un Skecht....................................................................................31
Fuente de alimentación...................................................................................................34
Características de las pilas/baterías. ......................................................................................35
Conexiones de varias pilas/baterías. ......................................................................................35
Compra de pilas/baterías......................................................................................................36
Compra de cargadores.......................................................................................................37
Botón de reset:...................................................................................................................41
Tipos de memoria:............................................................................................................42
Entradas y Salidas.............................................................................................................44
Entradas digitales .................................................................................................................45
Uso de lasentradasy de las salidas digitales ..........................................................................46

3
Entradas analógicas..............................................................................................................48
Uso de lasentradasy salidas analógicas.................................................................................49
Sensores para Arduino....................................................................................................52
Sensores de luz visible ..........................................................................................................52
Fotorresistores..................................................................................................................52
El sensor digital TSL2561....................................................................................................54
El sensor analógico TEMT6000...........................................................................................54
Sensores de luz infrarroja...............................................................................................56
Fotodiodos y fototransistores................................................................................................56
Sensores de temperatura ................................................................................................57
Termistores..........................................................................................................................57
El chip analógico TMP36 .......................................................................................................58
El chip digital DS18B20 y el protocolo 1-Wire .........................................................................60
Sensores de humedad......................................................................................................61
El sensor DHT22/RHT03 ........................................................................................................61
Sensores SHT15 y SHT21 .......................................................................................................62
Sensores de distancia.......................................................................................................63
El sensor Ping)))....................................................................................................................63
Sensor SRF05........................................................................................................................64
El sensor HC-SR04.................................................................................................................65
El sensor LV-EZ0 ...................................................................................................................65
El sensor IS471F....................................................................................................................66
Sensores QRD1114 y QRE1113 ..............................................................................................66
Sensores de inclinación...................................................................................................67
Sensores de movimiento .................................................................................................68
Sensor IR..............................................................................................................................69
El sensor ePIR.......................................................................................................................70
Sensores de contacto........................................................................................................71
Sensores de fuerza................................................................................................................71
Sensores de flexión...............................................................................................................72
Sensores de golpes...............................................................................................................73

4
Sensor de sonido...............................................................................................................74
Ejemplo de programación...............................................................................................75
Conclusión..........................................................................................................................78
Bibliografías.......................................................................................................................79

5
¿Qué es Arduino?
Una placa hardware libre que incorpora un microcontrolador reprogramable y una
serie de pines-hembra (los cuales están unidos internamente a las patillas de E/S del
microcontrolador) que permiten conectar allí de forma muy sencilla y cómoda
diferentes sensores y actuadores.
Cuando hablamos de “placa hardware” nos estamos refiriendo en concreto a una PCB
(del inglés “printed circuit board”, o sea, placa de circuito impreso). Las PCBs son
superficies fabricadas de un material no conductor (normalmente resinas de fibra de
vidrio reforzada, cerámica o plástico) sobre las cuales aparecen laminadas (“pegadas”)
pistas de material conductor (normalmente cobre). Las PCBs se utilizan para conectar
eléctricamente, a través de los caminos conductores, diferentes componentes
electrónicos soldados a ella. Una PCB es la forma más compacta y estable de construir
un circuito electrónico (en contraposición a una breadboard, perfboard o similar)
pero, al contrario que estas, una vez fabricada, su diseño es bastante difícil de
modificar. Así pues, la placa Arduino no es más que una PCB que implementa un
determinado diseño de circuitería interna.
No obstante, cuando hablamos de “placa Arduino”, deberíamos especificar el modelo
concreto, ya que existen varias placas Arduino oficiales, cada una con diferentes
características (como el tamaño físico, el número de pines-hembra ofrecidos, el
modelo de microcontrolador incorporado –y como consecuencia, entre otras cosas, la
cantidad de memoria utilizable–, etc.). Conviene conocer estas características para
identificar qué placa Arduino es la que nos convendrá más en cada proyecto.
De todas formas, aunque puedan ser modelos específicos diferentes (tal como
acabamos de comentar), los microcontroladores incorporados en las diferentes placas
Arduino pertenecen todos a la misma “familia tecnológica”, por lo que su
funcionamiento en realidad es bastante parecido entre sí. En concreto, todos los
microcontroladores son de tipo AVR, una arquitectura de microcontroladores
desarrollada y fabricada por la marca Atmel (http://www.atmel.com). Es por eso que,
en este libro seguiremos nombrando “placa Arduino” a cualquiera de ellas mientras
no sea imprescindible hacer algún tipo de distinción.
El diseño hardware de la placa Arduino está inspirado originalmente en el de otra
placa de hardware libre preexistente, la placa Wiring (http://www.wiring.co).
Esta placa surgió en 2003 como proyecto personal de Hernando Barragán, estudiante
por aquel entonces del Instituto de Diseño de Ivrea (lugar donde surgió en 2005
precisamente la placa Arduino).

6
Un software (más en concreto, un “entorno de desarrollo”) gratis, libre y
multiplataforma (ya que funciona en Linux, MacOS y Windows) que debemos instalar
en nuestro ordenador y que nos permite escribir, verificar y guardar (“cargar”) en la
memoria del microcontrolador de la placa Arduino el conjunto de instrucciones que
deseamos que este empiece a ejecutar.
Es decir: nos permite programarlo. La manera estándar de conectar nuestro
computador con la placa Arduino para poder enviarle y grabarle dichas instrucciones
es mediante un simple cable USB, gracias a que la mayoría de placas Arduino
incorporan un conector de este tipo. Los proyectos Arduino pueden ser autónomos o
no. En el primer caso, una vez programado su microcontrolador, la placa no necesita
estar conectada a ningún computador y puede funcionar autónomamente si dispone
de alguna fuente de alimentación. En el segundo caso, la placa debe estar conectada de
alguna forma permanente (por cable USB, por cable de red Ethernet, etc.) a un
computador ejecutando algún software específico que permita la comunicación entre
este y la placa y el intercambio de datos entre ambos dispositivos. Este software
específico lo deberemos programar generalmente nosotros mismos mediante algún
lenguaje de programación estándar como Python, C, Java, Php, etc., y será
independiente completamente del entorno de desarrollo Arduino, el cual no se
necesitará más, una vez que la placa ya haya sido programada y esté en
funcionamiento.

7
Origende Arduino
Arduino nació en el año 2005 en el Instituto de Diseño Interactivo de Ivrea (Italia),
centro académico donde los estudiantes se dedicaban a experimentar con la
interacción entre humanos y diferentes dispositivos (muchos de ellos basados en
microcontroladores) para conseguir generar espacios únicos, especialmente
artísticos. Arduino apareció por la necesidad de contar con un dispositivo para utilizar
en las aulas que fuera de bajo coste, que funcionase bajo cualquier sistema operativo y
que contase con documentación adaptada a gente que quisiera empezar de cero.
La idea original fue, pues, fabricar la placa para uso interno de la escuela. No obstante,
el Instituto se vio obligado a cerrar sus puertas precisamente en 2005. Ante la
perspectiva de perder en el olvido todo el desarrollo del proyecto Arduino que se
había ido llevando a cabo durante aquel tiempo, se decidió liberarlo y abrirlo a “la
comunidad” para que todo el mundo tuviera la posibilidad de participar en la
evolución del proyecto, proponer mejoras y sugerencias y mantenerlo “vivo”. Y así ha
sido: la colaboración de muchísima gente ha hecho que Arduino poco a poco haya
llegado a ser lo que es actualmente: un proyecto de hardware y software libre de
ámbito mundial.
El principal responsable de la idea y diseño de Arduino, y la cabeza visible del
proyecto es el llamado “Arduino Team”, formado por Massimo Banzi (profesor en
aquella época del Instituto Ivrea), David Cuartielles (profesor de la Escuela de Artes y
Comunicación de la Universidad de Mälmo, Suecia), David Mellis (por aquel entonces
estudiante en Ivrea y actualmente miembro del grupo de investigación High-Low Tech
del MIT Media Lab), Tom Igoe (profesor de la Escuela de Arte Tisch de Nueva York), y
Gianluca Martino )

8
Características del Arduino
 Cuando compres un arduino, las principales características a tener en cuenta
en cuanto al hardware son:
• Tamaño, por ejemplo para diseño de dispositivos de uso cotidiano
en ocasiones es mucho mejor utilizar los arduinos mini o nano que
son de poco tamaño.
• Número de entradas/ salidas, es necesario saber cuántas entradas y
cuantas salidas serán necesarias para el proyecto.
• Capacidad de memoria del microcontrolador, por si realizas
programas muy ... muy grandes.
• Voltaje de operación.

9
1. Conector USB, que puede ser tipo B o mini, este provee la comunicación para la
programación y la toma de datos, también provee una fuente de 5VDC para
alimentar al arduino, pero de baja corriente por lo que no sirve para alimentar
motores grandes por ejemplo. Siempre que adquieran una placa de arduino no
olviden pedir el cable de conexión USB pues este representa unos $7000
adicionales.
2. Regulador de voltaje de 5V, se encarga de convertir el voltaje ingresado por el
plug 3, en un voltaje de 5V regulado. necesario para el funcionamiento de la
placa y para alimentar circuitos externos.
3. Plug de conexión para fuente de alimentación externa, el voltaje que se
suministra por aquí debe ser directo y estar entre 6V y 18V, incluso 20V,
generalmente se usa un adaptador, pero debe tener cuidado de que el terminal
del centro del plug quede conectado a positivo ya que algunos adaptadores
traen la opción de intercambiar la polaridad de los cables.
4. Puerto de conexiones; constituido por 6 pines de conexión con las siguientes
funciones: RESET, permite resetear el microcontrolador al enviarle un cero
lógico. Pin 3.3V, este pin provee una fuente de 3.3VDC para conectar
dispositivos externos como en la protoboard por ejemplo. Pin 5V, es una fuente
de 5VDC para conectar dispositivos externos. Dos pines GND, que proveen la
salida de cero voltios para dispositivos externos. Pin Vin, este pin está
conectado con el positivo del plug 3 por lo que se usa para conectar la
alimentación de la placa con una fuente externa de entre 6 y 12VDC en lugar
del plug 3 o la alimentación por el puerto USB. Este puerto esta modificado en
la versión R3 de Arduino Uno.
5. Puerto de entradas análogas, aquí se conectan las salidas de los sensores
análogos. Estos pines solo funcionan como entradas recibiendo voltajes entre
cero y cinco voltios directos.
6. Microcontrolador Atmega 328, es el microcontrolador implementado en los
Arduino uno y sobre el cual vamos a programar, en la versión SMD del arduino
uno R2, se usa el mismo microcontrolador pero en montaje superficial, en este
caso las únicas ventajas son la reducción del peso y ganar un poco de espacio.
7. Botón de RESET, este botón así como el pin mencionado anteriormente
permiten resetear el microcontrolador haciendo que reinicie el programa. En la
versión R3 este pulsador se ubica arriba del conector USB, esto es un acierto
pues al colocarle las Shield encima del arduino, se perdía la opción de resetear
dado que este pulsador quedaba tapado.
8. Pines de programación ICSP, son usados para programar microcontroladores
en protoboard o sobre circuitos impresos sin tener que retirarlos de su sitio.
9. LED ON, enciende cuando el Arduino está encendido.

10
10. LEDs de recepción y transmisión, estos se encienden cuando la tarjeta se
comunica con el PC. El Tx indica transmisión de datos y el Rx recepción.
11. Puerto de conexiones, está constituido por los pines de entradas o salidas
digitales desde la cero hasta la 7. La configuración como entrada o salida debe
ser incluida en el programa. Cuando se usa la terminal serial es conveniente no
utilizar los pines cero (Rx) y uno (Tx). Los pines 3, 5 y 6 están precedidos por
el símbolo ~ , lo que indica que permiten su uso como salidas controladas por
ancho de pulso PWM.
12. Puerto de conexiones, incluye 5 entradas o salidas adicionales (de la 8 a la 12),
las salidas 9, 10 y 11 permiten control por ancho de pulso; la salida 13 es un
poco diferente pues tiene conectada una resistencia en serie, lo que permite
conectar un led directamente entre ella y tierra. Finalmente hay una salida a
tierra GND y un pin AREF que permite ser empleado como referencia para las
entradas análogas.
13. Este led indica el estado del pin 13.
14. No sé exactamente la función de estos pines.
15. Chip de comunicación que permite la conversión de serial a USB.

11
¿Qué es un microcontrolador?
Un microcontrolador es un circuito integrado o “chip” (es decir, un dispositivo
electrónico que integra en un solo encapsulado un gran número de componentes) que
tiene la característica de ser programable. Es decir, que es capaz de ejecutar de forma
autónoma una serie de instrucciones previamente definidas por nosotros.
Por definición, un microcontrolador (también llamado comúnmente “micro”) ha de
incluir en su interior tres elementos básicos:
CPU (Unidad Central de Proceso): es la parte encargada de ejecutar cada instrucción
y de controlar que dicha ejecución se realice correctamente. Normalmente, estas
instrucciones hacen uso de datos disponibles previamente (los “datos de entrada”), y
generan como resultado otros datos diferentes (los “datos de salida”), que podrán ser
utilizados (o no) por la siguiente instrucción.
Diferentes tipos de memorias: son en general las encargadas de alojar tantolas
instrucciones como los diferentes datos que estas necesitan. De esta manera
posibilitan que toda esta información (instrucciones y datos) esté siempre disponible
para que la CPU pueda acceder y trabajar con ella en cualquier momento.
Generalmente encontraremos dos tipos de memorias: las que su contenido se
almacena de forma permanente incluso tras cortes de alimentación eléctrica (llamadas
“persistentes”), y las que su contenido se pierde al dejar de recibir alimentación
(llamadas “volátiles”). Según las características de la información a guardar, esta se
grabará en un tipo u otro de memoria de forma automática, habitualmente.
Diferentes patillas de E/S (entrada/salida): son las encargadas de comunicar el
microcontrolador con el exterior. En las patillas de entrada del microcontrolador
podremos conectar sensores para que este pueda recibir datos provenientes de su
entorno, y en sus patillas de salida podremos conectar actuadores para que el
microcontrolador pueda enviarles órdenes e así interactuar con el medio físico. De
todas formas, muchas patillas de la mayoría de microcontroladores no son
exclusivamente de entrada o de salida, sino que pueden ser utilizados indistintamente
para ambos propósitos (de ahí el nombre de E/S).
Es decir, un microcontrolador es un computador completo (aunque con prestaciones
limitadas) en un solo chip, el cual está especializado en ejecutar constantemente un
conjunto de instrucciones predefinidas. Estas instrucciones irán teniendo en cuenta

12
en cada momento la información obtenida y enviada por las patillas de E/S y
reaccionarán en consecuencia. Lógicamente, las instrucciones serán diferentes según
el uso que se le quiera dar al microcontrolador, y deberemos de decidir nosotros
cuáles son.
Cada vez existen más productos domésticos que incorporan algún tipo de
microcontrolador con el fin de aumentar sustancialmente sus prestaciones, reducir su
tamaño y coste, mejorar su fiabilidad y disminuir el consumo. Así, podemos encontrar
microcontroladores dentro de multitud de dispositivos electrónicos que usamos en
nuestra vida diaria, como pueden ser desde un simple timbre hasta un completo robot
pasando por juguetes, frigoríficos, televisores, lavadoras, microondas, impresoras, el
sistema de arranque de nuestro coche, etc.

13
Tipos de microcontrolador:
Existen muchas familias fabricantes de microcontroladores, entre las más comunes
están:
Atmel (AVR ), Hitachi (H8), Intel de 8 bits (8XC42, MCS51, 8xC251) o Intel de 16 bits
(MCS96, MXS296), National Semiconductor (COP8), Microchip, Motorola de 8 bits
(68HC05, 68HC08, 68HC11) o de 16 bits (68HC12, 68HC16) o de 32 bits (683xx ), NEC
(78K), Texas Instruments (TMS370) y Zilog (Z8, Z86E02).
Sin embargo en nuestro medio se destacan sólo dos de ellas: la empresa Motorola y la
empresa Microchip.
La familia motorola Freescale Esta familia, desarrollada por la casa Motorola, se divide
en las siguientes subfamilias:
• Familia HC05:
Esta familia es una de las más utilizadas en la gran mayoría de aplicaciones por su
versatilidad de recursos y fácil programación. Sin embargo, presenta una propiedad
con mayor importancia y es su compatibilidad con familias más avanzadas, por
ejemplo con la familia HC08, lo que permite hacer migración de diseños hacia
dispositivos de más alto rendimiento de una manera muy fácil y rápida. Sus
principales ventajas son:
 Un timer robusto
 Memoria EEprom de 256
 Memoria de programa desde 4k hasta 32 k
 Memoria RAM desde 176 hasta 528 bytes.
 Ocho canales A/D
 Comunicación serial síncrona y asíncrona

14
• Familia HC08
Son microcontroladores de propósito general. Cada miembro de esta familia cuenta
con diferentes periféricos internos, pero con una CPU común que permite migrar
aplicaciones entre ellos, facilitando con ello el diseño.
El 68HC08 es un microcontrolador de 8 bits y arquitectura Von Neumann, con un solo
bloque de memoria. Es conocido también simplemente por HC08.
Entre los periféricos internos con los que cuentan estos microcontroladores, están:
conversores analógicos-digitales, módulo de control de tiempos y sistemas de
comunicación como SPI, I²C, USB o SSCI entre otros.
• Familia 68HC11 (abreviado HC11 o 6811)
Es una familia de microcontroladores de Motorola, derivada del microprocesador
Motorola 6800. Los microcontroladores 68HC11 son más potentes y costosos que los
de la familia 68HC08 y se utilizan en múltiples dispositivos empotrados.
Siguen la arquitectura Von Newman. Internamente, el conjunto de instrucciones de la
familia 68HC11 es compatible con la de la mayoría de sus predecesores.
La familia 68HC11 emplea instrucciones de longitud variable y se considera que
emplea una arquitectura CISC. Tienen dos acumuladores de ocho bits (A y B), dos
registros índice de 16 bits (X e Y), un registro de banderas, un puntero de pila y un
contador de programa.
Los 68HC11 tienen cinco puertos externos (A, B, C, D y E), cada uno de ocho bits
excepto el E, que es generalmente de seis bits. El puerto A se emplea en captura de
eventos, salida comparada, acumulador de pulsos y otras funciones de reloj. El puerto
D para E/S serie y el puerto E como conversor analógico-digital.
La familia 68HC11 puede funcionar tanto con memoria interna o externa. En caso de
emplear memoria externa, los puertos B y C funcionan como bus de datos y
direcciones respectivamente. Últimos Microcontroladores de la Familia Freescale.
La familia PIC
Esta familia, desarrollada por la casa Microchip, se divide en varias gamas: enana,
baja, media y alta.

15
Las principales diferencias entre estas gamas radica en el número de instrucciones y
su longitud, el número de puertos y funciones, lo cual se refleja en el encapsulado, la
complejidad interna y de programación, y en el número de aplicaciones.
• Gama enana
Su principal característica es su reducido tamaño, al disponer todos sus componentes
de 8 pines. Se alimentan con un voltaje de corriente continua comprendido entre 2,5 V
y 5,5 V, y consumen menos de 2 mA cuando trabajan a 5 V y 4 MHz. El formato de sus
instrucciones puede ser de 12 o de 14 bits y su repertorio es de 33 o 35 instrucciones,
respectivamente. En la Figura se muestra el diagrama de pines de uno de estos PIC.

16
Microcontrolador Motorola 68HC11y chips de soporte.
Die del microcontrolador de 8 bitsIntel 8742, con CPU a 12 MHz, 128 bytes de
memoria RAM, 2048 bytes de EPROM, y E/S en un chip.
Microcontrolador PIC 18F8720 en encapsulado TQFP de 80 pines.
Un microcontrolador (abreviado μC, UC o MCU) es un circuito integrado programable,
capaz de ejecutar las órdenes grabadas en su memoria. Está compuesto de varios
bloques funcionales, los cuales cumplen una tarea específica. Un microcontrolador
incluye en su interior las tres principales unidades funcionales de una computadora:
unidad central de procesamiento, memoria y periféricos de entrada/salida.
Algunos microcontroladores pueden utilizar palabras de cuatro bits y funcionan a
velocidad de reloj con frecuencias tan bajas como 4 kHz, con un consumo de baja
potencia (mW o microvatios). Por lo general, tendrá la capacidad de mantenerse a la
espera de un evento como pulsar un botón o de otra interrupción; así, el consumo de
energía durante el estado de reposo (reloj de la CPU y los periféricos de la mayoría)
puede ser sólo de nanovatios, lo que hace que muchos de ellos sean muy adecuados
para aplicaciones con batería de larga duración. Otros microcontroladores pueden
servir para roles de rendimiento crítico, donde sea necesario actuar más como un
procesador digital de señal (DSP), con velocidades de reloj y consumo de energía más
altos.
Cuando es fabricado el microcontrolador, no contiene datos en la memoria ROM. Para
que pueda controlar algún proceso es necesario generar o crear y luego grabar en la
EEPROM o equivalente del microcontrolador algún programa, el cual puede ser
escrito en lenguaje ensamblador u otro lenguaje para microcontroladores; sin
embargo, para que el programa pueda ser grabado en la memoria del
microcontrolador, debe ser codificado en sistema numérico hexadecimal que es
finalmente el sistema que hace trabajar al microcontrolador cuando éste es
alimentado con el voltaje adecuado y asociado a dispositivos analógicos y discretos
para su funcionamiento.

17
Historia
El primer microprocesador fue el Intel 4004 de 4 bits, lanzado en 1971, seguido por el
Intel 8008 y otros más capaces. Sin embargo, ambos procesadores requieren circuitos
adicionales para implementar un sistema de trabajo, elevando el costo del sistema
total.
El Instituto Smithsoniano dice que los ingenieros de Texas Instruments Gary Boone y
Michael Cochran lograron crear el primer microcontrolador, TMS 1000, en 1971; fue
comercializado en 1974. Combina memoria ROM, memoria RAM, microprocesador y
reloj en un chip y estaba destinada a los sistemas embebidos.2
Debido en parte a la existencia del TMS 1000,3 Intel desarrolló un sistema de
ordenador en un chip optimizado para aplicaciones de control, el Intel 8048, que
comenzó a comercializarse en 1977.3 Combina memoria RAM y ROM en el mismo chip
y puede encontrarse en más de mil millones de teclados de compatible IBM PC, y otras
numerosas aplicaciones. El en ese momento presidente de Intel, Luke J. Valenter,
declaró que el microcontrolador es uno de los productos más exitosos en la historia de
la compañía, y amplió el presupuesto de la división en más del 25%.
La mayoría de los microcontroladores en aquel momento tenían dos variantes. Unos
tenían una memoria EPROM reprogramable, significativamente más caros que la
variante PROM que era sólo una vez programable. Para borrar la EPROM necesita
exponer a la luz ultravioleta la tapa de cuarzo transparente. Los chips con todo opaco
representaban un coste menor.
En 1993, el lanzamiento de la EEPROM en los microcontroladores (comenzando con el
Microchip PIC16x84)4 permite borrarla eléctrica y rápidamente sin necesidad de un
paquete costoso como se requiere en EPROM, lo que permite tanto la creación rápida
de prototipos y la programación en el sistema. El mismo año, Atmel lanza el primer
microcontrolador que utiliza memoria flash.5 Otras compañías rápidamente siguieron
el ejemplo, con los dos tipos de memoria.
El costo se ha desplomado en el tiempo, con el más barato microcontrolador de 8 bits
disponible por menos de 0,25 dólares para miles de unidades en 2009, y algunos
microcontroladores de 32 bits a 1 dólar por cantidades similares. En la actualidad los
microcontroladores son baratos y fácilmente disponibles para los aficionados, con
grandes comunidades en línea para ciertos procesadores.
En el futuro, la MRAM podría ser utilizada en microcontroladores, ya que tiene
resistencia infinita y el coste de su oblea semiconductora es relativamente bajo.

18
Características
Esquema de un microcontrolador. En esta figura, vemos al microcontrolador metido
dentro de un encapsulado de circuito integrado, con su procesador (CPU), buses,
memoria, periféricos y puertos de entrada/salida. Fuera del encapsulado se ubican
otros circuitos para completar periféricos internos y dispositivos que pueden
conectarse a los pines de entrada/salida. También se conectarán a los pines del
encapsulado la alimentación, masa, circuito de completamiento del oscilador y otros
circuitos necesarios para que el microcontrolador pueda trabajar.
Los microcontroladores están diseñados para reducir el costo económico y el
consumo de energía de un sistema en particular. Por eso el tamaño de la unidad
central de procesamiento, la cantidad de memoria y los periféricos incluidos
dependerán de la aplicación. El control de un electrodoméstico sencillo como una
batidora utilizará un procesador muy pequeño (4 u 8 bits) porque sustituirá a un
autómata finito. En cambio, un reproductor de música y/o vídeo digital (MP3 o MP4)
requerirá de un procesador de 32 bits o de 64 bits y de uno o más códecs de señal
digital (audio y/o vídeo). El control de un sistema de frenos ABS (Antilock Brake
System) se basa normalmente en un microcontrolador de 16 bits, al igual que el
sistema de control electrónico del motor en un automóvil.
Los microcontroladores representan la inmensa mayoría de los chips de
computadoras vendidos, sobre un 50% son controladores "simples" y el restante
corresponde a DSP más especializados. Mientras se pueden tener uno o dos
microprocesadores de propósito general en casa (Ud. está usando uno para esto),
usted tiene distribuidos seguramente entre los electrodomésticos de su hogar una o
dos docenas de microcontroladores. Pueden encontrarse en casi cualquier dispositivo
electrónico como automóviles, lavadoras, hornos microondas, teléfonos, etc.
Un microcontrolador difiere de una unidad central de procesamiento normal, debido a
que es más fácil convertirla en una computadora en funcionamiento, con un mínimo
de circuitos integrados externos de apoyo. La idea es que el circuito integrado se
coloque en el dispositivo, enganchado a la fuente de energía y de información que
necesite, y eso es todo. Un microprocesador tradicional no le permitirá hacer esto, ya
que espera que todas estas tareas sean manejadas por otros chips. Hay que agregarle
los módulos de entrada y salida (puertos) y la memoria para almacenamiento de
información.
Un microcontrolador típico tendrá un generador de reloj integrado y una pequeña
cantidad de memoria de acceso aleatorio y/o ROM/EPROM/EEPROM/flash, con lo que
para hacerlo funcionar todo lo que se necesita son unos pocos programas de control y
un cristal de sincronización. Los microcontroladores disponen generalmente también

19
de una gran variedad de dispositivos de entrada/salida, como convertidor analógico
digital, temporizadores, UARTs y buses de interfaz serie especializados, como I2C y
CAN. Frecuentemente, estos dispositivos integrados pueden ser controlados por
instrucciones de procesadores especializados. Los modernos microcontroladores
frecuentemente incluyen un lenguaje de programación integrado, como el lenguaje de
programación BASIC que se utiliza bastante con este propósito.
Los microcontroladores negocian la velocidad y la flexibilidad para facilitar su uso.
Debido a que se utiliza bastante sitio en el chip para incluir funcionalidad, como los
dispositivos de entrada/salida o la memoria que incluye el microcontrolador, se ha de
prescindir de cualquier otra circuitería.
Arquitecturas de computadora
Básicamente existen dos arquitecturas de computadoras, y por supuesto, están
presentes en el mundo de los microcontroladores: Von Neumann y Harvard. Ambas se
diferencian en la forma de conexión de la memoria al procesador y en los buses que
cada una necesita.
Arquitectura Von Neumann
La arquitectura Von Neumann utiliza el mismo dispositivo de almacenamiento tanto
para las instrucciones como para los datos, siendo la que se utiliza en un ordenador
personal porque permite ahorrar una buena cantidad de líneas de E/S, que son
bastante costosas, sobre todo para aquellos sistemas donde el procesador se monta en
algún tipo de zócalo alojado en una placa madre. También esta organización les ahorra
a los diseñadores de placas madre una buena cantidad de problemas y reduce el costo
de este tipo de sistemas.
En un ordenador personal, cuando se carga un programa en memoria, a éste se le
asigna un espacio de direcciones de la memoria que se divide en segmentos, de los
cuales típicamente tenderemos los siguientes: código (programa), datos y pila. Es por
ello que podemos hablar de la memoria como un todo, aunque existan distintos
dispositivos físicos en el sistema (disco duro, memoria RAM, memoria flash, unidad de
disco óptico...).
En el caso de los microcontroladores, existen dos tipos de memoria bien definidas:
memoria de datos (típicamente algún tipo de SRAM) y memoria de programas (ROM,
PROM, EEPROM, flash u de otro tipo no volátil). En este caso la organización es

20
distinta a las del ordenador personal, porque hay circuitos distintos para cada
memoria y normalmente no se utilizan los registros de segmentos, sino que la
memoria está segregada y el acceso a cada tipo de memoria depende de las
instrucciones del procesador.
A pesar de que en los sistemas integrados con arquitectura Von Neumann la memoria
esté segregada, y existan diferencias con respecto a la definición tradicional de esta
arquitectura; los buses para acceder a ambos tipos de memoria son los mismos, del
procesador solamente salen el bus de datos, el de direcciones, y el de control. Como
conclusión, la arquitectura no ha sido alterada, porque la forma en que se conecta la
memoria al procesador sigue el mismo principio definido en la arquitectura básica.
Algunas familias de microcontroladores como la Intel 8051 y la Z80 implementan este
tipo de arquitectura, fundamentalmente porque era la utilizada cuando aparecieron
los primeros microcontroladores.
Arquitectura Harvard
La otra variante es la arquitectura Harvard, y por excelencia la utilizada en
supercomputadoras, en los microcontroladores, y sistemas integrados en general. En
este caso, además de la memoria, el procesador tiene los buses segregados, de modo
que cada tipo de memoria tiene un bus de datos, uno de direcciones y uno de control.
La ventaja fundamental de esta arquitectura es que permite adecuar el tamaño de los
buses a las características de cada tipo de memoria; además, el procesador puede
acceder a cada una de ellas de forma simultánea, lo que se traduce en un aumento
significativo de la velocidad de procesamiento. Típicamente los sistemas con esta
arquitectura pueden ser dos veces más rápidos que sistemas similares con
arquitectura Von Neumann.
La desventaja está en que consume muchas líneas de E/S del procesador; por lo que
en sistemas donde el procesador está ubicado en su propio encapsulado, solo se
utiliza en supercomputadoras. Sin embargo, en los microcontroladores y otros
sistemas integrados, donde usualmente la memoria de datos y programas comparten
el mismo encapsulado que el procesador, este inconveniente deja de ser un problema
serio y es por ello que encontramos la arquitectura Harvard en la mayoría de los
microcontroladores.
Por eso es importante recordar que un microcontrolador se puede configurar de
diferentes maneras, siempre y cuando se respete el tamaño de memoria que este
requiera para su correcto funcionamiento.

21
Procesador en detalle
En los años 1970, la electrónica digital no estaba suficientemente desarrollada, pero
dentro de la electrónica ya era una especialidad consagrada. En aquel entonces las
computadoras se diseñaban para que realizaran algunas operaciones muy simples, y
si se quería que estas máquinas pudiesen hacer cosas diferentes, era necesario
realizar cambios bastante significativos al hardware.
A principios de la década de 1970, una empresa japonesa le encargó a una joven
compañía norteamericana que desarrollara un conjunto de circuitos para producir
una calculadora de bajo costo. Intel se dedicó de lleno a la tarea y entre los circuitos
encargados desarrolló uno muy especial, algo no creado hasta la fecha: el primer
microprocesador integrado.
El Intel 4004 salió al mercado en 1971, es una máquina digital sincrónica compleja,
como cualquier otro circuito lógico secuencial sincrónico. Sin embargo, la ventaja de
este componente está en que aloja internamente un conjunto de circuitos digitales que
pueden hacer operaciones corrientes para el cálculo y procesamiento de datos, pero
desde una óptica diferente: sus entradas son una serie de códigos bien definido s, que
permiten hacer operaciones de carácter específico cuyo resultado está determinado
por el tipo de operación y los operandos involucrados.
Visto así, no hay nada de especial en un microprocesador; la maravilla está en que la
combinación adecuada de los códigos de entrada, su ejecución secuencial, el poder
saltar hacia atrás o adelante en la secuencia de códigos sobre la base de decisiones
lógicas u órdenes específicas, permite que la máquina realice un montón de
operaciones complejas, no contempladas en los simples códigos básicos.
Hoy estamos acostumbrados a los sistemas con microprocesadores, pero en el lejano
1971 esta era una forma de pensar un poco diferente y hasta escandalosa, a tal punto
que Busicom, la empresa que encargó los chips a Intel, no se mostró interesada en el
invento, por lo que Intel lo comercializó para otros que mostraron interés; el resto es
historia: una revolución sin precedentes en el avance tecnológico de la humanidad.
Es lógico pensar que el invento del microprocesador integrado no fue una revelación
divina para sus creadores, sino que se sustentó en los avances, existentes hasta el
momento, en el campo de la electrónica digital y las teorías sobre computación. Pero
sin lugar a dudas fue la gota que colmó la copa de la revolución científico-técnica,
porque permitió desarrollar aplicaciones impensadas o acelerar algunas ya
encaminadas.

22
Ahora comenzaremos a ver cómo es que está hecho un procesador, no será una
explicación demasiado detallada porque desde su invención éste ha tenido
importantes revoluciones propias, pero hay aspectos básicos que no han cambiado y
que constituyen la base de cualquier microprocesador. En la Figura 'Esquema de un
microcontrolador' podemos ver la estructura típica de un microprocesador, con sus
componentes fundamentales, claro está que ningún procesador real se ajusta
exactamente a esta estructura, pero aun así nos permite conocer cada uno de sus
elementos básicos y sus interrelaciones.
Registros
Son un espacio de memoria muy reducido pero necesario para cualquier
microprocesador, de aquí se toman los datos para varias operaciones que debe
realizar el resto de los circuitos del procesador. Los registros sirven para almacenar
los resultados de la ejecución de instrucciones, cargar datos desde la memoria externa
o almacenarlos en ella.
Aunque la importancia de los registros parezca trivial, no lo es en absoluto. De hecho
una parte de los registros, la destinada a los datos, es la que determina uno de los
parámetros más importantes de cualquier microprocesador. Cuando escuchamos que
un procesador es de 4, 8, 16, 32 o 64 bits, nos estamos refiriendo a procesadores que
realizan sus operaciones con registros de datos de ese tamaño, y por supuesto, esto
determina muchas de las potencialidades de estas máquinas.

23
Mientras mayor sea el número de bits de los registros de datos del procesador,
mayores serán sus prestaciones, en cuanto a poder de cómputo y velocidad de
ejecución, ya que este parámetro determina la potencia que se puede incorporar al
resto de los componentes del sistema, por ejemplo, no tiene sentido tener una ALU de
16 bits en un procesador de 8 bits.
Por otro lado un procesador de 16 bits, puede que haga una suma de 16 bits en un
solo ciclo de máquina, mientras que uno de 8 bits deberá ejecutar varias instrucciones
antes de tener el resultado, aun cuando ambos procesadores tengan la misma
velocidad de ejecución para sus instrucciones. El procesador de 16 bits será más
rápido porque puede hacer el mismo tipo de tareas que uno de 8 bits, en menos
tiempo.
Unidad de control
Esta unidad es de las más importantes en el procesador, en ella recae la lógica
necesaria para la decodificación y ejecución de las instrucciones, el control de los
registros, la ALU, los buses y cuanta cosa más se quiera meter en el procesador.
La unidad de control es uno de los elementos fundamentales que determinan las
prestaciones del procesador, ya que su tipo y estructura determina parámetros tales
como el tipo de conjunto de instrucciones, velocidad de ejecución, tiempo del ciclo de
máquina, tipo de buses que puede tener el sistema, manejo de interrupciones y un
buen número de cosas más que en cualquier procesador van a parar a este bloque.
Por supuesto, las unidades de control son el elemento más complejo de un procesador
y normalmente están divididas en unidades más
pequeñas trabajando de conjunto. La unidad de control
agrupa componentes tales como la unidad de
decodificación, unidad de ejecución, controladores de
memoria caché, controladores de buses, controlador de
interrupciones, pipelines, entre otros elementos,
dependiendo siempre del tipo de procesador.
Unidad aritmético-lógica (ALU)
Como los procesadores son circuitos que hacen básicamente operaciones lógicas y
matemáticas, se le dedica a este proceso una unidad completa, con cierta
independencia. Aquí es donde se realizan las sumas, restas, y operaciones lógicas
típicas del álgebra de Boole.

24
Actualmente este tipo de unidades ha evolucionado mucho y los procesadores más
modernos tienen varias ALU, especializadas en la realización de operaciones
complejas como las operaciones en coma flotante. De hecho en muchos casos le han
cambiado su nombre por el de “coprocesador matemático”, aunque este es un término
que surgió para dar nombre a un tipo especial de procesador que se conecta
directamente al procesador más tradicional.
Su impacto en las prestaciones del procesador es también importante porque,
dependiendo de su potencia, tareas más o menos complejas, pueden hacerse en
tiempos muy cortos, como por ejemplo, los cálculos en coma flotante.
Buses
Son el medio de comunicación que utilizan los diferentes componentes del procesador
para intercambiar información entre sí, eventualmente los buses o una parte de ellos
estarán reflejados en los pines del encapsulado del procesador.
En el caso de los microcontroladores, no es común que los buses estén reflejados en el
encapsulado del circuito, ya que estos se destinan básicamente a las E/S de propósito
general y periféricos del sistema.
Existen tres tipos de buses:
Dirección: Se utiliza para seleccionar al dispositivo con el cual se quiere trabajar o en
el caso de las memorias, seleccionar el dato que se desea leer o escribir.
Datos: Se utiliza para mover los datos entre los dispositivos de hardware (entrada y
salida).
Control: Se utiliza para gestionar los distintos procesos de escritura lectura y
controlar la operación de los dispositivos del sistema.
Conjunto de instrucciones
Aunque no aparezca en el esquema, no podíamos dejar al conjunto o repertorio de
instrucciones fuera de la explicación, porque este elemento determina lo que puede
hacer el procesador.
Define las operaciones básicas que puede realizar el procesador, que conjugadas y
organizadas forman lo que conocemos como software. El conjunto de instrucciones
vienen siendo como las letras del alfabeto, el elemento básico del lenguaje, que

25
organizadas adecuadamente permiten escribir palabras, oraciones y cuanto programa
se le ocurra.
Existen dos tipos básicos de repertorios de instrucciones, que determinan la
arquitectura del procesador: CISC y RISC.
CISC, del inglés Complex instruction set computing, Computadora de Conjunto de
Instrucciones Complejo. Los microprocesadores CISC tienen un conjunto de
instrucciones que se caracteriza por ser muy amplio y que permiten realizar
operaciones complejas entre operandos situados en la memoria o en los registros
internos. Este tipo de repertorio dificulta el paralelismo entre instrucciones, por lo
que en la actualidad, la mayoría de los sistemas CISC de alto rendimiento convierten
las instrucciones complejas en varias instrucciones simples del tipo RISC, llamadas
generalmente microinstrucciones.

26
Software de Arduino
¿Qué es un IDE?
Un programa es un conjunto concreto de instrucciones, ordenadas y agrupadas de
forma adecuada y sin ambigüedades que pretende obtener un resultado determinado.
Cuando decimos que un microcontrolador es “programable”, estamos diciendo que
permite grabar en su memoria de forma permanente (hasta que regrabemos de nuevo
si es necesario) el programa que deseemos que dicho microcontrolador ejecute. Si no
introducimos ningún programa en la memoria del microcontrolador, este no sabrá
qué hacer.
Las siglas IDE vienen de Integrated Development Environment, lo que traducido a
nuestro idioma significa Entorno de Desarrollo Integrado. Esto es simplemente una
forma de llamar al conjunto de herramientas software que permite a los
programadores poder desarrollar (es decir, básicamente escribir y probar) sus
propios programas con comodidad. En el caso de Arduino, necesitamos un IDE que
nos permita escribir y editar nuestro programa (también llamado “sketch” en el
mundo de Arduino), que nos permita comprobar que no hayamos cometido ningún
error y que además nos permita, cuando ya estemos seguros de que el sketch es
correcto, grabarlo en la memoria del microcontrolador de la placa Arduino para que
este se convierta a partir de entonces en el ejecutor autónomo de dicho programa.

27
Instalación del IDE Arduino
Ubuntu
La manera más fácil de instalar el IDE de Arduino en Ubuntu es mediante el uso de su
“Centro de Software” (o cualquier otro gestor de paquetes equivalente, tal como
Synaptic o apt-get/aptitude). El paquete que necesitamos se llama “arduino” y estará
disponible si tenemos activado el repositorio “universe”. Si queremos usar el terminal
de comandos para instalar el IDE de Arduino, podríamos escribir por tanto: sudo apt-
get -y install Arduino Es interesante notar que Ubuntu divide el entorno de
programación Arduino en dos paquetes diferentes: el llamado “arduino”, que incluye
los ficheros que conforman la interfaz gráfica del IDE y el llamado “arduino-core”, que
incluye las herramientas fundamentales de compilación, programación y grabación de
sketches. Estas últimas son las que realizan todo el trabajo importante y son
invocadas mediante la interfaz gráfica del IDE (el cual en este sentido hace de mero
intermediario entre ellas y el usuario), aunque también pueden ser ejecutadas
directamente mediante el intérprete de comandos. Instalando el paquete “arduino”, se
instalará de forma automática el paquete “arduino-core” sin necesidad de
especificarlo (es de hecho lo que hacemos con el comando anterior), pero a la inversa
no es así: si quisiéramos trabajar mediante un terminal sin usar el IDE propiamente
dicho podríamos instalar el paquete “arduino-core” autónomamente sin necesidad de
instalar el paquete “arduino”.
Fedora
La manera más fácil de instalar el IDE de Arduino en Fedora es mediante el uso de
cualquiera de sus gestores de paquetes disponibles (PackageKit, Yum, etc). El paquete
que necesitamos se llama “arduino” y está disponible en el repositorio oficial de
Fedora. Si usamos el terminal de comandos, para instalar el IDE de Arduino debemos
escribir: sudo yum -y install arduino. Al igual que ocurría con Ubuntu, Fedora divide el
entorno de programación Arduino en dos paquetes: “arduino” y “arduino-core”.
Además, ofrece un tercer paquete llamado “arduino-doc” (instalado automáticamente
mediante el comando anterior), que contiene toda la documentación y ejemplos de
programación oficial de Arduino. En Ubuntu esta información se encuentra incluida
dentro del paquete “arduino-core”.

28
Sistema Linux
Para instalar el IDE de Arduino en una distribución cualquiera de Linux, debemos ir a
http://arduino.cc/en/Main/Software, la página de descargas oficial de Arduino. Allí,
bajo el apartado “Downloads”, aparecen dos enlaces diferentes para descargar la
versión del IDE Arduino para Linux. Ambos enlaces apuntan a un archivo comprimido
en formato “tgz” alojado en el almacén de software oficial de Arduino (ubicado en
http://code.google.com/p/arduino), pero un enlace corresponde a la versión del IDE
de 32 bits y el otro a la de 64 bits. Es necesario, por tanto, conocer primero qué tipo de
sistema operativo tenemos instalado (32 bits o 64 bits) y descargarnos entonces el
paquete “tgz” correspondiente. Para saber de manera rápida si nuestro sistema Linux
es de 32 bits o de 64 bits podemos abrir un terminal y escribir el siguiente comando:
getconf LONG_BIT La salida que obtengamos como resultado de ejecutar el comando
anterior será “32” si nuestro sistema es de 32 bits y “64” si nuestro sistema es de 64
bits. Una vez sabido esto, ya podemos elegir el paquete “tgz” adecuado y, una vez
descargado, lo descomprimiremos. Cuando entremos dentro de la carpeta
descomprimida que obtengamos, no encontraremos ningún instalador ni nada
parecido (solo una estructura de archivos y subcarpetas que no deberemos modificar
para nada) porque de hecho, nuestro IDE ya está listo para ser usado desde este
mismo momento: tan solo deberemos clicar sobre el archivo ejecutable (en realidad,
un shell script con permisos de ejecución) llamado “arduino” y, después de confirmar
la opción “Ejecutar” que aparecerá en el cuadro emergente, veremos el IDE finalmente
ante nosotros. También podemos ejecutar el IDE a través del intérprete de comandos;
para ello deberemos situarnos mediante el comando cd dentro de la carpeta donde se
encuentra el shell script y escribir ./arduino (importante no olvidarse del punto y la
barra).
Windows
Para instalar el IDE de Arduino en Windows 8, deberemos ir a su página web oficial de
descargas: http://arduino.cc/en/Main/Software. Allí aparecerá, bajo el apartado
“Downloads”, un enlace para descargar la versión del IDE para Windows, que no es
más que un archivo comprimido en formato zip. Por lo tanto, lo primero que
tendremos que hacer una vez descargado es descomprimirlo.
Cuando entremos dentro de la carpeta descomprimida que obtengamos, no
encontraremos ningún instalador ni nada parecido (solo una estructura de archivos y
subcarpetas que no deberemos modificar para nada) porque nuestro IDE ya está listo
para ser usado desde este mismo momento: tan solo deberemos clicar sobre el
archivo ejecutable “arduino.exe” y aparecerá ante nosotros. Evidentemente, podremos
mover y guardar en el lugar que deseemos de nuestro disco duro la carpeta

29
contenedora de los ficheros que forman el IDE, siempre y cuando no alteremos nada
de su interior. Seguramente también deseemos crear un acceso directo del ejecutable
allí donde lo consideremos oportuno.
No obstante, no hemos acabado aún el proceso de instalación del IDE debido a que
Windows 8 no incorpora de serie los “drivers” necesarios para poder reconocer la
placa Arduino en el momento que esta se conecte mediante USB a nuestro
computador. Así que para poder empezar a trabajar con nuestra placa debemos
instalar previamente dichos drivers en nuestro sistema.
Mac OS X
Para instalar el IDE de Arduino en Mac OS X deberemos ir a su página web oficial de
descargas: http://arduino.cc/en/Main/Software. Allí aparecerá, bajo el apartado
“Downloads”, un enlace para descargar la versión del IDE para Mac OS X, que no es
más que un archivo comprimido en formato zip. Por lo tanto, lo primero que
tendremos que hacer una vez descargado es descomprimirlo. Obtendremos entonces
un archivo “dmg” ; haciendo doble clic sobre él comenzará el proceso de instalación
estándar de cualquier aplicación nativa en sistemas Macintosh. El proceso es casi
totalmente automático: lo único que deberemos hacer es, en la ventana que nos
aparecerá al principio de la instalación, arrastrar el icono de Arduino sobre la carpeta
Applications para que el IDE se instale allí (aunque de hecho podríamos elegir
instalarlo en cualquier otro lugar). Y ya está: si todo va bien, en la barra de lanzadores
aparecerá el icono correspondiente del recién instalado IDE de Arduino.
Configuracióny comprobacióndel buen funcionamiento del IDE
Una vez hemos conectado mediante el cable USB nuestra placa recién adquirida a
nuestro computador, lo primero que deberíamos ver es que el LED etiquetado como
“ON” se enciende y se mantiene encendido de manera continua siempre. Una vez
comprobado esto, podemos poner en marcha el entorno de programación Arduino.
Una vez abierto, no obstante, antes de poder empezar a escribir una sola línea
debemos asegurarnos de que el IDE “sepa” dos cosas básicas:
1. El tipo de placa Arduino conectada en este momento al computador (UNO,
Leonardo, Mega, etc.)
2. El puerto serie de nuestro computador que ha de que utilizar paracomunicarse vía
USB con ella.

30
Para lo primero, simplemente debemos ir al menú “Tools”->”Boards” y seleccionar de
la lista que aparece la placa con la que trabajaremos. Fijarse que hay modelos de placa
que aparecen varias veces según si pueden venir con diferentes modelos de
microcontrolador. Para lo segundo, debemos ir al menú “Tools”->”Serialport” y elegir
el puerto serie (puede ser real o virtual) adecuado. Dependiendo del sistema
operativo utilizado, en ese menú aparecerán opciones diferentes. Las más comunes
son:
Sistemas Linux: aparecen los ficheros de dispositivo (generalmente/dev/ttyACM#).
Sistemas Windows: aparece una lista de puertos COM#, donde “#” es un número.
Normalmente este número será 3 o superior, ya que los puertosCOM1 y COM2 se
suelen reservar habitualmente para puertos seriehardware reales (no simulados a
través de USB). Si aparecen varios puertos COM y no se sabe cuál es el
correspondiente a la placa Arduino, lo más sencillo es desconectarla y reabrir el menú:
la entrada que haya desaparecido será la que buscamos; conectando otra vez la placa
podremos seleccionarla sin problemas.
Sistemas MacOS X: aparecen los ficheros de dispositivo (normalmente
/dev/tty.usbmodem###). Es posible que en el momento de conectar una placa UNO o
Mega se muestre una ventana emergente informando de que se ha detectado un nuevo
dispositivo de red. Si ocurre esto, basta con clicar en “Network preferences...” y
cuando aparezca la nueva ventana, simplemente clicar en “Apply”. La placa se
mostrará como “Not configured”, pero funcionará correctamente por lo que ya se
puede salir de las preferencias delsistema.
Ambas configuraciones (placa y puerto) solamente serán necesarias especificarlas una
sola vez mientras no las modifiquemos (es decir, mientras no usemos otro tipo de
placa, por ejemplo). Ahora solo nos falta comprobar que todo funcione correctamente,
ejecutando algún sketch de prueba. Como todavía no sabemos escribir ninguno por
nuestra cuenta, utilizaremos un sketch de los que vienen como ejemplo.
Concretamente, el sketch llamado “Blink”. Para abrirlo, debemos ir al menú “File”-
>”Examples”->”01.Basics”->”Blink”. Ahora no nos interesa estudiar el código que
aparece: simplemente hemos de pulsar en el botón “Verify” y seguidamente en el
botón “Upload”. Siempre deberemos seguir esta pauta con todos los sketches: una vez
queramos probar cómo funcionan, debemos pulsar primero en “Verify” (para
compilar y verificar el código) y seguidamente en “Upload” (para cargarlo en el
microcontrolador)

31
Estructurageneral de un Skecht
Un programa diseñado para ejecutarse sobre un Arduino (un “sketch”) siempre se
compone de tres secciones:
La sección de declaraciones de variables globales: ubicada directamente al
principio del sketch.
La sección llamada “void setup()”: delimitada por llaves de apertura y cierre.
La sección llamada “void loop()”: delimitada por llaves de apertura y cierre.
La primera sección del sketch (que no tiene ningún tipo de símbolo delimitador de
inicio o de final) está reservada para escribir, tal como su nombre indica, las
diferentes declaraciones de variables que necesitemos. En un apartado posterior
explicaremos ampliamente qué significa todo esto.
En el interior de las otras dos secciones (es decir, dentro de sus llaves) deberemos
escribir las instrucciones que deseemos ejecutar en nuestra placa, teniendo en cuenta
lo siguiente: Las instrucciones escritas dentro de la sección “void setup()” se ejecutan
una única vez, en el momento de encender (o resetear) la placa Arduino.
Las instrucciones escritas dentro de la sección “void loop()” se ejecutan justo después
de las de la sección “void setup()” infinitas veces hasta que la placa se apague (o se
resetee). Es decir, el contenido de “void loop()” se ejecuta desde la 1ª instrucción
hasta la última, para seguidamente volver a ejecutarse desde la 1ª instrucción hasta la
última, para seguidamente ejecutarse desde la 1ª instrucción hasta la última, y así una
y otra vez. Por tanto, las instrucciones escritas en la sección “void setup()”
normalmente sirven para realizar ciertas preconfiguraciones iniciales y las
instrucciones del interior de “void loop()” son, de hecho, el programa en sí que está
funcionando continuamente.

32
En el caso concreto del ejemplo, vemos que en la zona de declaraciones de variables
globales hay una sola línea (int mivariable=555;) que dentro de “void setup()” se
ejecuta una sola instrucción (Serial.begin(9600);) y que dentro de “void loop()” se
realiza la ejecución continua y repetida (hasta que la alimentación de la placa se
interrumpa) de dos instrucciones una tras otra: Serial.println(mivariable); y
mivariable=mivariable+1;. Sobre el significado y sintaxis de todas estas líneas
hablaremos a continuación.
Sobre las mayúsculas, tabulaciones y puntos y comas
Conviene aclarar ya pequeños detalles que deberemos tener en cuenta a la hora de
escribir nuestros sketches para evitarnos muchos dolores de cabeza. Por ejemplo, es
necesario saber que el lenguaje Arduino es “case-sensitive”. Esto quiere decir que es
totalmente diferente escribir una letra en mayúscula que en minúscula.
Dicho de otra forma: para el lenguaje Arduino “HolA” y “hOLa” son dos palabras
distintas. Esto tiene una implicación muy importante: no es lo mismo escribir por
ejemplo “Serial.begin(9600);” que “serial.begin(9600);”. En el primer caso la
instrucción estaría correctamente escrita, pero en el segundo, en el momento de
compilar el código el IDE se quejaría porque para él “serial” (con “s” minúscula) no
tiene ningún sentido. Así que hay que vigilar mucho con respetar esta distinción en los
códigos que escribamos.
Otro detalle: las tabulaciones de las instrucciones contenidas dentro de las secciones
“void setup()” y “void loop()” del sketch del ejemplo no son en absoluto necesarias

33
para que la compilación del sketch se produzca con éxito. Simplemente son una
manera de escribir el código de forma ordenada, clara y cómoda para el programador,
facilitándole la tarea de leer código ya escrito y mantener una cierta estructura a la
hora de escribirlo. En los próximos ejemplos de este libro se irá viendo mejor su
utilidad.
Otro detalle: todas las instrucciones (incluyendo también las declaraciones de
variables) acaban con un punto y coma. Es indispensable añadir siempre este signo
para no tener errores de compilación, ya que el compilador necesita localizarlo para
poder detectar el final de cada instrucción escrita en el sketch. Si se olvida, se
mostrará un texto de error que puede ser obvio (“falta un punto y coma”) o no. Si el
texto del error es muy oscuro o sin lógica, es buena idea comprobar que la causa no
sea la falta de un punto y coma en las líneas justamente anteriores a la marcada por el
compilador como causante del problema.

34
Fuente de alimentación
En electrónica, la fuente de alimentación o fuente de poder es el dispositivo que
convierte la corriente alterna (CA), en una o varias corrientes continuas (CC), que
alimentan los distintos circuitos del aparato electrónico al que se conecta
(computadora, televisor, impresora, router, etc.).
Las fuentes de alimentación para dispositivos electrónicos, pueden clasificarse
básicamente como fuentes de alimentación lineales y conmutadas. Las lineales tienen
un diseño relativamente simple, que puede llegar a ser más complejo cuanto mayor es
la corriente que deben suministrar, sin embargo su regulación de tensión es poco
eficiente. Una fuente conmutada, de la misma potencia que una lineal, será más
pequeña y normalmente más eficiente pero será más compleja y por tanto más
susceptible a averías.
Llamamos fuente de alimentación eléctrica al elemento responsable de generar la
diferencia de potencial necesaria para que fluya la corriente eléctrica por un circuito y
así puedan funcionar los dispositivos conectados a este.
Tipos de pilas-baterías.
El término “pila” sirve para denominar a los generadores de electricidad basados en
procesos químicos normalmente no reversibles y, por tanto, son generadores no
recargables; mientras que el término “batería” se aplica generalmente a dispositivos
electroquímicos semi reversibles que permiten ser recargados, aunque estos términos
no son una definición formal estricta. El término “acumulador” se aplica
indistintamente a uno u otro tipo (así como a otros tipos de generadores de tensión,
como los condensadores eléctricos) siendo pues un término neutro capaz de englobar
y describir a todos ellos.

35
Características de las pilas/baterías.
Hay que tener en cuenta que el voltaje que aportan las distintas pilas es un valor
“nominal”: es decir, por ejemplo, una pila AA de 1,5 V en realidad al principio de su
vida útil genera unos 1,6 V, rápidamente desciende a 1,5 V y entonces poco a poco va
descendiendo hasta 1 V, momento en el cual la pila la podemos considerar “gastada”.
Lo mismo pasa con los otros tipos de batería; por ejemplo, una batería LiPo marcada
como “3,7 V/ (4,2 V)” indica que inicialmente es capaz de aportar un voltaje máximo
de 4,2 V, pero rápidamente desciende a 3,7 V, el cual será su voltaje medio durante la
mayor parte de su vida útil, hasta que finalmente baje rápidamente hasta los 3 V y
automáticamente deje de funcionar.
Conexiones de varias pilas/baterías.
Ya hemos visto en diagramas anteriores que el símbolo que se suele utilizar en el
diseño de circuitos electrónicos para representar una pila o batería es:
donde la parte más larga (y a veces pintada más gruesa) del dibujo representa el polo
positivo de la fuente. A menudo se omite el símbolo “+”. Cuando hablamos de conectar
pilas “en serie” queremos decir que conectamos el polo negativo de una con el polo
positivo de otra, y así, de tal forma que finalmente tengamos un polo positivo global
por un lado y un polo negativo global por otro. En esta figura se puede entender
mejor: Componentes eléctrico.

36
La conexión en serie de baterías es útil cuando necesitamos tener una batería que
genere un determinado voltaje relativamente elevado (por ejemplo, 12 V) y solo
disponemos de pilas de menor voltaje (por ejemplo, de 1,5 V). En ese caso, podemos
conectar dichas unidades de 1,5 V en serie para obtener “a mano” la batería que
aporte el voltaje deseado, ya que el voltaje total aportado por baterías conectadas en
serie es la suma de sus voltajes individuales.
En nuestro ejemplo, para obtener 12 V a partir de pilas de
1,5 V, necesitaríamos 8 unidades, porque 1,5 V · 8 = 12 V. De
hecho, las pilas comerciales de 4,5 V y 9 V (y de 6 V y 12 V,
que también las hay) suelen fabricarse conectando
internamente en serie pilas de 1,5 V. Por eso, muchas veces
veremos el siguiente símbolo (en vez del anteriormente
mostrado) representando una pila:
No obstante, también hay que tener en cuenta que la capacidad total (es decir, los mAh
del conjunto de pilas en serie) no aumenta: seguirá siendo exactamente la misma que
la que tenga una batería de ese conjunto de forma individual e independiente. Este
hecho es importante porque generalmente los circuitos que necesitan ser alimentados
con grandes voltajes tiene un mayor consumo eléctrico, por lo que (en virtud de la
fórmula del apartado anterior) el tiempo de funcionamiento de una fuente formada
por pilas en serie será bastante reducido.
Compra de pilas/baterías.
Cualquier tipo de pila/batería que necesitemos en nuestros proyectos (de diferente
voltaje, capacidad, composición química...) lo podremos adquirir a través de
cualquiera de los distribuidores listados en el apéndice A del libro: solo hay que
utilizar el buscador que ofrecen en sus tiendas online para encontrar el tipo de
pila/batería deseado. Por ejemplo, si buscamos baterías LiPo, el distribuidor de
componentes electrónicos Sparkfun ofrece, entre otras, el producto nº 341 (a 3,7
V/850 mAh) o el nº 339 (a 3,7V/1Ah), ambas con conector JST de 2 pines. Si buscamos
pilas alcalinas o recargables de tipo NiMH, es incluso más sencillo: los modelos más
habituales están disponibles en cualquier comercio local. Si precisamente se van a
emplear este tipo de pilas (alcalinas o recargables NiMH), lo más habitual es utilizar
en nuestros proyectos algún tipo de portapilas que permita utilizar varias unidades
conectadas en serie. Existen muchos modelos; como muestra, tan solo en la página
web del distribuidor de componentes electrónicos Adafruit podemos encontrar
(escribiendo su número de producto en el buscador integrado del portal), los
siguientes productos:

37
Nº 248: portapilas de 6 unidades AA con clavija de 5,5/2,1 mm.
Nº 875: “de 8 unidades AA con clavija de 5,5/2,1 mm e interruptor.
Nº 727: “de 3 unidades AAA con conector tipo JST de 2 pines e interruptor.
Nº 67: “de 1 unidad PP3 con clavija de 5,5/2,1mm e interruptor.
Nº 80: clip para conectar una 1 unidad PP3 con clavija de 5,5/2,1 mm
Nº 449: portapilas de 8 unidades AA con los cables directos (sin conector).
Si se desea, los cables se pueden acoplar fácilmente a una clavija de 2,1 mm adquirida
aparte (producto nº 369). La clavija de 2,1 mm nos puede venir bien para alimentar
nuestra placa Arduino ya que esta tiene un conector hembra de ese tipo. Por otro lado,
el producto nº 727 está pensado para alimentar con pilas AAA circuitos originalmente
diseñados para ser alimentados con baterías LiPo, ya que estas suelen incorporar
precisamente un conector de tipo JST de 2 pines.
Compra de cargadores.
Otro complemento que nos puede venir bien es un cargador de baterías. Por ejemplo,
para las de tipo NiMH nos será suficiente con el ofrecido por ejemplo por Sparkfun con
código de producto nº 10052. Este cargador se conecta directamente a un enchufe de
pared y puede ser utilizado con baterías AA, AAA o PP3. En cambio, si queremos
recargar baterías LiPo, no vale cualquier cargador, hay que tener la precaución de
usar siempre uno que cumpla dos condiciones: que aporte un voltaje igual (lo
preferible) o menor que el voltaje máximo proporcionado por esa batería concreta, y
que además aporte una intensidad igual o menor (lo preferible) que la capabilidad de
esa batería concreta.
Si no se cumplen las dos condiciones anteriores, el cargador podría dañar la batería
irreversiblemente (e incluso hacerla explotar). Las baterías LiPo son muy delicadas:
también se corre el riesgo de explosión cuando se descargan por debajo de un voltaje

38
mínimo (normalmente 3 V), o cuando son obligadas a aportar más corriente de la que
pueden ofrecer (normalmente 2C), o cuando son utilizadas en ambientes de
temperaturas extremas (normalmente fuera del rango 0 º-50 ºC), entre otras causas.
Por eso muchas de estas baterías (aunque no todas) incorporan un circuito protector
que detecta estas situaciones y desconecta la batería de forma segura.
De todas formas, para conocer las características específicas de cada batería (como las
tensiones, intensidades y temperaturas seguras) es obligatorio consultar la
información que ofrece el fabricante para esa batería en concreto (su datasheet).
Los cargadores LiPo (y Li-ion) los podemos encontrar en multitud de establecimientos
y en múltiples formas. Como ejemplos, tan solo en la página web de Sparkfun
podemos encontrar los productos nº 10217, 10401, 11231 o 10161 (entre otros).
Todos ellos son básicamente pequeñas plaquitas que disponen por un lado de un
zócalo de tipo USB (mini-B o micro-B, según el caso) donde se conecta la alimentación
externa y por otro lado de un zócalo JST de 2 pines, donde se conecta la batería LiPo a
cargar. Todos ellos están preparados para ser alimentados con una fuente externa de
5 V; este voltaje lo puede ofrecer un cargador USB de pared de cualquier móvil actual
o incluso un zócalo USB de nuestro propio computador.
Breve nota sobre los conectores USB.
Cuando estamos hablando de “conector USB”, tenemos que tener claro de qué tipo de
conector estamos hablando, porque existen varios modelos. En la imagen siguiente se
muestran algunos de los más extendidos; de izquierda a derecha: conector micro-B
macho, conector mini-B macho, conector A hembra, conector A macho y conector B
macho.

39
Características de los adaptadores AC/DC.
El otro tipo de fuente de alimentación externa, diferente de las pilas/baterías, que más
utilizaremos para nuestros circuitos es el adaptador AC/DC. Su función típica es
conectarse a una toma de la red eléctrica general para transformar el elevado voltaje
alterno ofrecido por ella en un voltaje continuo, constante y mucho menor, para
ofrecer entonces este a los aparatos que se le conecten y así ponerlos en
funcionamiento de una forma estable y segura.
Los adaptadores AC/DC básicamente están formados por un circuito transformador,
el cual convierte el voltaje AC de entrada en otro voltaje AC mucho menor, y un
circuito rectificador, el cual convierte ese voltaje AC ya transformado en un voltaje DC,
que será el voltaje final de salida. Todos los adaptadores incorporan una etiqueta
impresa que informa tanto del rango de valores en el voltaje AC de entrada con el que
son capaces de trabajar (además de la frecuencia de la señal AC admitida) como del
valor del voltaje DC y de la intensidad máxima que ofrecen como salida. Por ejemplo,
la imagen siguiente corresponde a un adaptador AC/DC que admite voltajes AC de
entrada entre 100 V y 240 V a una frecuencia de 50 o 60Hz (por tanto, compatible con
la red eléctrica española) y aporta un voltaje DC de salida de 9 V (y una intensidad
máxima de 1 A).
Podemos clasificar los adaptadores según si son “regulados” (es decir, si incorporan
un regulador de voltaje en su interior) o no. Un regulador de voltaje es un dispositivo
(o un conjunto de ellos) que, estando sometido a un determinado voltaje de entrada
relativamente fluctuante, es capaz de generar un voltaje de salida normalmente
menor, mucho más estable, constante y controlado.
Por tanto, los adaptadores regulados proporcionan un voltaje de salida muy concreto
y constante, que es igual al mostrado en su etiqueta. Lo que sí puede variar (hasta un
máximo mostrado también en la etiqueta) es la intensidad de corriente ofrecida, ya
que esta depende en cada momento de las necesidades del circuito alimentado.
Los adaptadores no regulados, en cambio, no poseen ningún mecanismo de
estabilización y proporcionan un voltaje de salida cuyo valor puede llegar a ser
diferente en varios voltios al mostrado en la etiqueta. Este tipo de adaptadores
ciertamente reducen el voltaje de entrada a un valor de salida menor, pero el valor
concreto de este voltaje de salida depende en buena parte del consumo eléctrico
(medido en amperios o miliamperios) realizado en ese momento particular por el
circuito alimentado.

40
Expliquemos esto: a medida que el circuito consume más intensidad de corriente, el
voltaje de salida (inicialmente bastante más elevado que el valor nominal marcado en
la etiqueta del adaptador) se va reduciendo cada vez más hasta llegar a su valor
nominal solo cuando el circuito consume la máxima intensidad que el adaptador es
capaz de ofrecer, (cuyo valor está indicado también en la etiqueta impresa, como ya
sabemos). Si el circuito sigue aumentando su consumo y supera esa intensidad
máxima, el voltaje ofrecido por el adaptador seguirá disminuyendo y llegará a ser
menor que el nominal, circunstancia en la que se corre el riesgo de dañar el adaptador
(y de rebote, el circuito alimentado). Este comportamiento es fácil comprobarlo con
un multímetro, tal como veremos en un apartado posterior de este mismo capítulo.

41
Botón de reset:
La placa Arduino UNO dispone de un botón de reinicio (“reset”) que permite, una vez
pulsado, enviar una señal LOW al pin “RESET” de la placa para parar y volver a
arrancar el microcontrolador. Como en el momento del arranque del
microcontrolador siempre se activa la ejecución del bootloader, el botón de reinicio se
suele utilizar para permitir la carga de un nuevo programa en la memoria Flash del
microcontrolador –eliminando el que estuviera grabado anteriormente– y su
posterior puesta en marcha. No obstante, en la placa UNO no es necesario
prácticamente nunca pulsar “real y físicamente” dicho botón antes de cada carga, ya
que la placa UNO está diseñada de tal manera que permite la activación del bootloader
directamente desde el entorno de desarrollo instalado en nuestro computador
(simplemente pulsando sobre un icono de dicho entorno).
Esta capacidad que tiene la placa de “resetearse” sin pulsar físicamente ningún botón
tiene sus consecuencias: cuando la placa UNO está conectada a un computador
ejecutando un sistema operativo Linux o Mac OS X, cada vez que se realiza una
conexión a la placa mediante USB, esta se reinicia, por lo que durante
aproximadamente medio segundo, el bootloader se pone en marcha. Por tanto,
durante ese medio segundo, el bootloader interceptará los primeros bytes de datos
enviados a la placa justo tras el establecimiento de la conexión USB. El problema de
esto es que, aunque el bootloader no hará nada con estos bytes porque los ignorará,
estos ya no llegarán al destino deseado (es decir, el programa grabado en el
microcontrolador propiamente dicho), porque este se pondrá en marcha con ese
retraso de medio segundo.

42
Tipos de memoria:
Memoria RAM
La memoria de acceso aleatorio (en inglés: random-access memory),se utiliza
como memoria de trabajo para el sistema operativo, los programas y la mayoría
del software. Es allí donde se cargan todas las instrucciones que ejecutan el
procesador y otras unidades de cómputo. Se denominan "de acceso aleatorio"
porque se puede leer o escribir en una posición de memoria con un tiempo de
espera igual para cualquier posición, no siendo necesario seguir un orden para
acceder a la información de la manera más rápida posible.
Hay dos tipos básicos de memoria RAM
· RAM dinámica (DRAM)
· RAM estática (SRAM)
Los dos tipos de memoria RAM se diferencian en la tecnología que utilizan para
guardar los datos, la memoria RAM dinámica es la más común.
La memoria RAM dinámica necesita actualizarse miles de veces por segundo,
mientras que la memoria RAM estática no necesita actualizarse, por lo que es más
rápida, aunque también más cara. Ambos tipos de memoria RAM son volátiles, es
decir, que pierden su contenido cuando se apaga el equipo.
Antecedentes históricos de la memoria RAM
Uno de los primeros tipos de memoria RAM fue la memoria de núcleo magnético,
desarrollada entre 1949 y 1952 y usada en muchos computadores hasta el
desarrollo de circuitos integrados a finales de los años 60 y principios de los 70.
Esa memoria requería que cada bit estuviera almacenado en un toroide de
material ferromágnetico de algunos milímetros de diámetro, lo que resultaba en
dispositivos con una capacidad de memoria muy pequeña. Antes que eso, las
computadoras usaban relés y líneas de retardo de varios tipos construidas para
implementar las funciones de memoria principal con o sin acceso aleatorio.
En 1969 fueron lanzadas una de las primeras memorias RAM basadas en
semiconductores de silicio por parte de Intel con el integrado 3101 de 64 bits de

43
memoria y para el siguiente año se presentó una memoria DRAM de 1 Kilobyte,
referencia 1103 que se constituyó en un hito, ya que fue la primera en ser
comercializada con éxito, lo que significó el principio del fin para las memorias de
núcleo magnético. En comparación con los integrados de memoria DRAM
actuales, la 1103 es primitiva en varios aspectos, pero tenía un desempeño mayor
que la memoria de núcleos.
Memoria SRAM
Static Random Access Memory (SRAM), o Memoria Estática de Acceso Aleatorio
es un tipo de memoria basada en semiconductores que a diferencia de la memoria
DRAM, es capaz de mantener los datos, mientras esté alimentada, sin necesidad
de circuito de refresco. Sin embargo, sí son memorias volátiles, es decir que
pierden la información si se les interrumpe la alimentación eléctrica.
Características
La memoria SRAM es más cara, pero más rápida y con un menor consumo
(especialmente en reposo) que la memoria DRAM. Es utilizada, por tanto, cuando
es necesario disponer de un menor tiempo de acceso, o un consumo reducido, o
ambos. Debido a su compleja estructura interna, es menos densa que DRAM, y
por lo tanto no es utilizada cuando es necesaria una alta capacidad de datos,
como por ejemplo en la memoria principal de los computadores personales.
Memoria DRAM
DRAM (Dynamic Random Access Memory) es un tipo de memoria dinámica de
acceso aleatorio que se usa principalmente en los módulos de memoria RAM y en
otros dispositivos, como memoria principal del sistema. Se denomina dinámica, ya
que para mantener almacenado un dato, se requiere revisar el mismo y recargarlo,
cada cierto período, en un ciclo de refresco. Su principal ventaja es la posibilidad
de construir memorias con una gran densidad de posiciones y que todavía
funcionen a una velocidad alta: en la actualidad se fabrican integrados con

44
millones de posiciones y velocidades de acceso medidos en millones de bit por
segundo. Es una memoria volátil, es decir cuando no hay alimentación eléctrica, la
memoria no guarda la información. Inventada a finales de los sesenta, es una de
las memorias más usadas en la actualidad.
Entradas y Salidas.
El microcontrolador recibe información de las entradas (read), la procesa y
escribe un 1 o un 0 (5v ó 0v) en las salidas (Write), actuando sobre el dispositivo
que tenemos conectado. Al microcontrolador por lo tanto conectamos unos
sensores a la entrada y unos actuadores a la salida, para que en función del
programa y de la lectura de los sensores se produzcan una serie de actuaciones.
Señales Analógicas y Digitales
Una señal es analógica cuando puede tomar infinitos valores entre su valor
mínimo y máximo. Elementos análogicos: Potenciómetro, ldr, ntc, Zumbador,
motor electrico, Led. Una señal es digital cuando solo puede tomar 2 valores, el
máximo asociado a 1 o a cierto “on” y el mínimo asociado a cero, falso o “off”.
Elementos digitales: pulsador, detector de presencia, led, timbre.

45
Entradas digitales
Una de las funciones más interesantes de Arduino y en general de todos los autómatas
es su capacidad de interacción con el mundo físico. Podemos, por ejemplo, realizar
mediciones de tensión, obtener lecturas de gran variedad de sensores, encender
dispositivos o controlar motores y actuadores. Esta interacción se lleva a cabo en gran
parte mediante el uso de las entradas y salidas tanto digitales como analógicas.
Las entradas digitales son las mismas que las salidas digitales, es decir, los pines que
van del 1 al 13. Se diferencian de las analógicas porque éstas son capaces de
“entender” sólo dos niveles de señal, LOW o valores cercanos a 0 V y HIGH o valores
cercanos a 5 V. Puede parecer una desventaja pero en realidad puede ser todo lo
contrario. Y no sólo porque a veces únicamente necesitemos saber dos estados, sino
porque así es capaz de leer señales de pulsos digitales, es decir, que puede
comunicarse. Sin embargo en el mundo físico las referencias de tensión realmente son
continuas. El proceso de lectura digital es un proceso de discretización de una señal
analógica, el valor de la tensión, en un valor digital que representamos mediante dos
estados, LOW y HIGH.
En realidad una entrada digital realiza una comparación de la medición con un valor
de tensión umbral. Si el valor medido es superior a la tensión umbral se devuelve
HIGH, y si es inferior LOW. El valor de la tensión umbral varía de un autómata a otro, e
incluso no tiene por qué permanecer constante a lo largo del tiempo.
En Arduino las entradas y salidas digitales comparten pin, motivo por el que se
denominan I/O digitales. Esto significa que el mismo pin puede ejecutar funciones
tanto de entrada como de salida aunque, lógicamente, no de forma simultánea. Es
necesario configurar un pin I/O como entrada o salida en el código.

46
Uso de las entradas y de las salidas digitales
Las funciones que nos ofrece el lenguaje Arduino para trabajar con entradas y salidas
digitales son:
pinMode(): configura un pin digital (cuyo número se ha de especificar como primer
parámetro) como entrada o como salida de corriente, según si el valor de su segundo
parámetro es la constante predefinida INPUT o bien OUTPUT, respectivamente. Esta
función es necesaria porque los pines digitales a priori pueden actuar como entrada o
salida, pero en nuestro sketch hay que definir previamente si queremos que actúen de
una forma u de otra. Es por ello que esta función se suele escribir dentro de “setup()”.
No tiene valor de retorno.
digitalWrite(): envía un valor ALTO (HIGH) o BAJO (LOW) a un pin digital; es decir,
tan solo es capaz de enviar dos valores posibles. Por eso, de hecho, hablamos de salida
“digital”. El pin al que se le envía la señal se especifica como primer parámetro
(escribiendo su número) y el valor concreto de esta señal se especifica como segundo
parámetro (escribiendo la constante predefinida HIGH o bien la constante predefinida
LOW, ambas de tipo “int”). Si el pin especificado en digitalWrite() está configurado
como salida, la constante HIGH equivale a una señal de salida de hasta 40 mA y de 5 V
(o bien 3,3 V en las placas que trabajen a ese voltaje) y la constante LOW equivale a
una señal de salida de 0 V. Si el pin está configurado como entrada usando la
constante INPUT, enviar un valor HIGH equivale a activar la resistencia interna “pull-
up” en ese momento (es decir, es idéntico a usar directamente la constante
INPUT_PULLUP), y enviar un valor LOW equivale a desactivarla de nuevo. Esta función
no tiene valor de retorno.
digitalRead(): devuelve el valor leído del pin digital (configurado como entrada
mediante pinMode()) cuyo número se haya especificado como parámetro. Este valor
de retorno es de tipo “int” y puede tener dos únicos valores (por eso, de hecho
hablamos de entrada digital): la constante HIGH (1) o LOW (0). Si la entrada es de tipo
INPUT, el valor HIGH se corresponde con una señal de entrada mayor de 3 V y el valor
LOW con una señal menor de 2 V. Si la entrada es de tipo INPUT_PULLUP, al tener la
entrada conectada una resistencia “pull-up”, las lecturas son al revés: el valor HIGH
indica que no se recibe señal de entrada y el valor LOW que sí.

47
pulseIn(): pausa la ejecución del sketch y se espera a recibir en el pin de entrada
especificado como primer parámetro la próxima señal de tipo HIGH o LOW (según lo
que se haya indicado como segundo parámetro). Una vez recibida esa señal, empieza a
contar los microsegundos que esta dura hasta cambiar su estado otra vez, y devuelve
finalmente un valor –de tipo “long”– correspondiente a la duración en microsegundos
de ese pulso de señal. De forma opcional, se puede especificar un tercer parámetro –
de tipo “unsigned long”– que representa el tiempo máximo de espera en
microsegundos: si la señal esperada no se produce una vez superado este tiempo de
espera, la función devolverá 0 y continuará la ejecución del sketch. Si este tiempo de
espera no se especifica, el valor por defecto es de un segundo. En la documentación
oficial recomiendan usar esta función para rangos de valores de retorno de entre 10
microsegundos y 3 minutos, ya que para pulsos más largos la precisión puede tener
errores.

48
Entradas analógicas
Las entradas analógicas del modelo Uno son las correspondientes a los pines de A0 a
A5. Se caracterizan por leer valores de tensión de 0 a 5 Voltios con una resolución de
1024 (10 bits). Si dividimos 5 entre 1024 tenemos que es capaz de detectar
variaciones en el nivel de la señal de entrada de casi 5 mV.
Una señal analógica es una magnitud que puede tomar cualquier valor dentro de un
intervalo. Por ejemplo, una señal analógica de tensión entre 0V y 5V podría valer
2.72V o cualquier otro valor con cualquier número de decimales. Por el contrario,
recordemos que una señal digital de tensión teórica únicamente podía registrar dos
valores 0V o 5V. En el caso de Arduino uno disponemos de un número variable de
entradas analógicas, que en el caso de Arduino Uno y Mini Pro son 6, y en el Arduino
Mega son 16. Este es un número más que respetable de entradas analógicas, que
rivaliza o supera a autómatas tradicionales de coste muy superior.
Es importante entender que en el mundo real cualquier señal de tensión es siempre
analógica. Un valor digital es un concepto, una abstracción. Sin embargo conviene
señalar que la medición que proporciona una entrada analógica también es un valor
digital, por lo que igualmente es una abstracción. Esto nos lleva al concepto de
precisión de la medición.

49
Uso de las entradas y salidas analógicas
Las funciones que sirven para gestionar entradas y salidas analógicas son las
siguientes:
analogWrite(): envía un valor de tipo “byte” (especificado como segundo parámetro)
que representa una señal PWM, a un pin digital configurado como OUTPUT
(especificado como primer parámetro). No todos los pines digitales pueden generar
señales PWM: en la placa Arduino UNO por ejemplo solo son los pines 3, 5, 6, 9, 10 y
11 (están marcados en la placa). Cada vez que se ejecute esta función se regenerará la
señal. Esta función no tiene valor de retorno.
Recordemos que una señal PWM es una señal digital cuadrada que simula ser una
señal analógica. El valor simulado de la señal analógica dependerá de la duración que
tenga el pulso digital (es decir, el valor HIGH de la señal PWM). Si el segundo
parámetro de esta función vale 0, significa que su pulso no dura nada (es decir, no hay
señal) y por tanto su valor analógico “simulado” será el mínimo (0V). Si vale 255 (que
es el máximo valor posible, ya que las salidas PWM tienen una resolución de 8 bits, y
por tanto, solo pueden ofrecer hasta 28=256 valores diferentes –de 0 a 255, pues–),
significa que su pulso dura todo el período de la señal (es decir, es una señal continua)
y por tanto su valor analógico “simulado” será el máximo ofrecido por la placa (5 V).
Cualquier otro valor entre estos dos extremos (0 y 255) implica un pulso de una
longitud intermedia (por ejemplo, el valor 128 generará una onda cuadrada cuyo
pulso es de la misma longitud que la de su estado bajo) y por tanto, un valor analógico
“simulado” intermedio (en el caso anterior, 2,5 V).
analogRead(): devuelve el valor leído del pin de entrada analógico cuyo número (0, 1,
2...) se ha especificado como parámetro. Este valor se obtiene mapeando
proporcionalmente la entrada analógica obtenida (que debe oscilar entre 0 y un
voltaje llamado voltaje de referencia, el cual por defecto es 5 V) a un valor entero
entre 0 y 1023. Esto implica que la resolución de lectura es de 5V/1024, es decir, de
0,049 V. Como los pines analógicos por defecto solamente funcionan como entradas
de señales analógicas, no es necesario utilizar previamente la función pinMode() con
ellos. No obstante, estos pines también incorporan toda la funcionalidad de un pin de
entrada/salida digital estándar (incluyendo las resistencias “pull-up”), por lo que si se
necesita utilizar más pines de entrada/salida digitales de los que la placa Arduino
ofrece, y los pines analógicos no están en uso, estos pueden ser utilizados como pines
de entrada/salida digitales extra de la forma habitual, simplemente identificándolos

50
con un número correlativo más allá del pin 13, que es el último pin digital. Es decir, el
pin “A0” sería el número 14, el “A1” sería el 15, etc. Por ejemplo, si quisiéramos que el
pin analógico “A3” funcionara como salida digital y además enviara un valor BAJO,
escribiríamos primero pinMode(17,OUTPUT); y luego digitalWrite(17,LOW);
Si un pin analógico no está conectado a nada, el valor devuelto por analogRead()
fluctuará debido a múltiples factores como por ejemplo los valores que puedan tener
las otras entradas analógicas, o lo cerca que esté nuestro cuerpo a la placa, etc. Esto,
que en principio no es deseable, lo podemos utilizar sin embargo para algo útil: para
establecer semillas de números aleatorios diferentes (y por tanto, aumentar así la
aleatoriedad de las diferentes series de números generados). Esto se haría poniendo
como parámetro de randomSeed(); el valor obtenido en la lectura de un pin analógico
cualquiera que esté libre; es decir, por ejemplo así: randomSeed(analogRead(0));
analogWriteResolution(): establece, mediante su único parámetro –de tipo “byte”–,
la resolución en bits que tendrá a partir de entonces la función analogWrite() a lo
largo de nuestro sketch. Este parámetro puede ser un número entre 1 y 32. Por
defecto, esta resolución es de 8 bits (es decir, que con analogWrite() se pueden
escribir valores entre 0 y 255), pero la placa Arduino Due dispone de dos conversores
digital-analógicos que permiten trabajar con una resolución de hasta 12 bits. Esto
significa que, si usamos estas dos salidas analógicas especiales y usamos
analogWriteResolution() para establecer a 12 la resolución deseada, la función
analogWrite() podría llegar a escribir valores de entre 0 y 4095. Esta función no
devuelve nada.
Si en analogWriteResolution() se especifica una resolución mayor de la que las salidas
analógicas de la placa son capaces de admitir, los bits extra serán descartados. Si, en
cambio, se especifica una resolución menor, los bits extra se rellenarán con ceros. Por
ejemplo: si escribimos analogWriteResolution(16);solo los primeros 12 bits de cada
valor (empezando por la derecha) serán utilizados por analogWrite(), y los últimos 4
no se tendrán en cuenta. Si, en cambio, escribimos analogWriteResolution(8);, se
añadirán automáticamente 4 bits (iguales a 0) a la izquierda del valor de 8 bits, para
que así analogWrite() pueda escribir, a través de los dos conversores digital-
analógicos, un valor de 12 bits.

51
analogReadResolution(): establece, mediante su único parámetro –de tipo “byte”–,
el tamaño en bits del valor que devolverá la función analogRead() a partir de entonces
a lo largo de nuestro sketch. Este parámetro puede ser un número entre 1 y 32. Por
defecto, este tamaño es de 10 bits (es decir, que analogRead() devuelve valores entre
0 y 1023). La placa Arduino Due es capaz de manejar tamaños de hasta 12 bits en los
valores devueltos por analogRead(), por lo que podríamos obtener datos dentro de un
rango de entre 0 y 4095. Esta función no devuelve nada.
Si en analogReadResolution() se especifica un tamaño mayor del que las entradas
analógicas de la placa son capaces de devolver, al valor leído se le añadirán por la
izquierda bits extra iguales a 0 hasta llegar al tamaño especificado. Si, en cambio, se
especifica una resolución menor, los bits leídos sobrantes (por la izquierda) no se
tendrán en cuenta y serán descartados.

52
Sensores paraArduino
Un sensor es un dispositivo capaz de detectar magnitudes físicas o químicas, llamadas
variables de instrumentación, y transformarlas en variables eléctricas. Las variables
de instrumentación pueden ser por ejemplo: temperatura, intensidad lumínica,
distancia, aceleración, inclinación, desplazamiento, presión, fuerza, torsión, humedad,
movimiento, pH, etc. Una magnitud eléctrica puede ser una resistencia eléctrica (como
en una RTD), una capacidad eléctrica (como en un sensor de humedad o un sensor
capacitivo), una tensión eléctrica (como en un termopar), una corriente eléctrica
(como en un fototransistor), etc.
Sensores de luz visible
Fotorresistores
Los sensores de luz, tal como su nombre indica, son
sensores que permiten detectar la presencia de luz en el
entorno. A veces se les llama “celdas CdS” (por el material
con el que suelen estar fabricados, sulfuro de cadmio) o
también “fotorresistores” y LDRs (del inglés “Light
Dependent Resistor”), ya que básicamente se componen de
una resistencia que cambia su valor dependiendo de la
cantidad de luz que esté incidiendo sobre su superficie.
Concretamente, reducen su resistencia a medida que
reciben más intensidad de luz.
Suelen ser pequeños, baratos y fáciles de usar; por esto aparecen mucho en juguetes y
dispositivos domésticos en general. Pero son imprecisos: cada fotorresistor reacciona
de forma diferente a otro, aunque hayan sido fabricados en la misma tongada. Es por
eso que no deberían ser usados para determinar niveles exactos de intensidad de luz,
sino más bien para determinar variaciones en ella, las cuales pueden provenir de la
propia luz ambiente (“amanece o anochece”) o bien de la presencia de algún obstáculo
que bloquee la recepción de alguna luz incidente.
También se podría tener un sistema de fotorresistores y comparar así cuál de ellos
recibe más luz en un determinado momento (para construir por ejemplo un robot
seguidor de caminos pintados de blanco en el suelo o de focos de luz, entre otras
muchas aplicaciones).
Otro dato que hay que saber es que su tiempo de respuesta típico está en el orden de
una décima de segundo. Esto quiere decir que la variación de su valor resistivo tiene

53
ese retardo respecto los cambios de luz. Por tanto, en circunstancias donde la señal
luminosa varía con rapidez su uso no es muy indicado (aunque también es verdad que
esta lentitud en algunos casos es una ventaja, porque así se filtran variaciones rápidas
de iluminación).
A la hora de adquirir un fotorresistor hay que tener en cuenta además otra serie de
factores: aparte del tamaño y precio, sobre todo hay que mirar también la resistencia
máxima y mínima que pueden llegar a ofrecer. Estos datos lo podremos obtener del
datasheet que ofrece el fabricante. De hecho, en el datasheet no solo podemos
consultar estos dos datos extremos sino también todos los valores intermedios de
resistencia, gracias a un conjunto de gráficas que nos indican cómo varía de forma
continua (y generalmente logarítmica) el valor resistivo del fotorresistor en función
de la cantidad de luz recibida, medida en unidades lux. Con esta información podemos
conocer, sabiendo la luz que incide sobre el LDR, qué valor de resistencia ofrece este
(y viceversa: sabiendo la resistencia que ofrece, podemos deducir la cantidad de luz
que recibe el sensor).
Aquí se puede apreciar un símbolo para identificar el fotorresistor,

54
El sensor digital TSL2561
Además de los fotorresistores (que son sensores analógicos), también existen
sensores de luz que son digitales, como por ejemplo el chip TSL2561 que Adafruit
distribuye sobre una cómoda plaquita breakout. Los sensores digitales son más
precisos que los fotorresistores (ya que permiten lecturas exactas, medidas en
unidades lux) y su sensibilidad puede ser configurada dependiendo de la intensidad
de luz con la que se trabaje en ese momento (intensidad cuyo rango admitido es
además mucho más amplio que el de los fotorresistores). Además, el TSL2561
concretamente detecta, además de todo el espectro visible, también la luz infrarroja;
pudiéndose configurar para medir separadamente la luz visible, la luz infrarroja o
ambos.
Este chip se alimenta con un voltaje de entre 2,7 V y 3,6 V y funciona como mucho a
0,5 mA, por lo que es ideal para sistemas de bajo consumo. Su sistema de
comunicación con el exterior es el protocolo I2C, por lo que en la plaquita breakout en
la que se comercializa, además de los contactos de alimentación y tierra, aparecen los
contactos “SDA” (a conectar al pin analógico nº 4 de Arduino) y “SCL” (a conectar al
pin analógico nº 5 de Arduino).
El sensor analógico TEMT6000
También existen chips sensores de luz con comportamiento analógico. Un ejemplo es
el TEMT6000, distribuido en forma de plaquita breakout por Sparkfun (producto nº
8688). Este sensor tiene la ventaja de ser mucho más preciso que un fotorresistor
(reacciona mejor a cambios de iluminación en un rango mayor) sin añadir más
complejidad a nuestros circuitos. Está adaptado a la sensibilidad del ojo humano, por
lo que no reacciona ante la luz infrarroja o ultravioleta.
Las conexiones de la plaquita breakout distribuida por Sparkfun son muy simples: el
conector “VCC” puede ir conectado directamente al pin “5V” de la placa Arduino, el
conector “GND” a tierra” y el conector “SIG” a cualquier entrada analógica de Arduino.
Cuanto más voltaje leamos del sensor, más iluminado estará el entorno.

55
Ejemplo: Su programación también es muy simple. He aquí un ejemplo:
int pinsensor = 0; //Entrada analógica donde está conectado el sensor
void setup() {
Serial.begin(9600);
}
void loop() {
int lectura;
lectura = analogRead(pinsensor);
Serial.println(lectura); //0=muy oscuro; 1023=muy iluminado
delay(100);
}
Otra plaquita breakout que incluye el mismo chip TEMT6000 es la distribuida por
Freetronics bajo el nombre de “Light sensor module”. Igualmente, dispone de tres
conectores (VCC, GND y OUT) para comunicarse con nuestra placa Arduino y se
programa exactamente igual.

56
Sensores de luz infrarroja
Fotodiodos y fototransistores
Un fotodiodo es un dispositivo que, cuando es excitado por la luz, produce en el
circuito una circulación de corriente proporcional (y medible). De esta manera,
pueden hacerse servir como sensores de luz, aunque, si bien es cierto que existen
fotodiodos especialmente sensibles a la luz visible, la gran mayoría lo son sobre todo a
la luz infrarroja. Se pueden adquirir en cualquier distribuidor de componentes
básicos, tales como Mouser o Jameco, por poner un par de ellos. Ejemplos de
dispositivos concretos que nos pueden venir bien son (el código es del fabricante) el
TEFD4300F, el BPV22F, el BPV10NF o el SFH235FA.
Hay que tener en cuenta que, a pesar de tener un comportamiento en apariencia
similar a los LDRs, una diferencia muy importante respecto estos (además de la
sensibilidad a otras longitudes de onda) es el tiempo de respuesta a los cambios de
oscuridad a iluminación, y viceversa, que en los fotodiodos es mucho menor. Igual que
los diodos estándar, los fotodiodos poseen un ánodo y un cátodo, pero atención, para
que funcione como deseamos, un fotodiodo siempre se ha de conectar al circuito en
polaridad inversa. Eso sí, igual que ocurre con los diodos comunes, normalmente el
ánodo es más largo que el cátodo (en caso de ser de igual longitud, el cátodo deberá
estar marcado de alguna forma).
Su funcionamiento interno es el siguiente: cuando el fotodiodo está polarizado en
directa, la luz que incide sobre él no tiene un efecto apreciable y por tanto el
dispositivo se comporta como un diodo común. Cuando está polarizado en inversa y
no le llega ninguna radiación luminosa, también se comporta como un diodo normal
ya que los electrones que fluyen por el circuito no tienen energía suficiente para
atravesarlo, con lo que el circuito permanece abierto. Pero en el momento en el que el
fotodiodo recibe una radiación luminosa dentro de un rango de longitud de onda
adecuado, los electrones reciben suficiente energía para poder “saltar” la barrera del
fotodiodo en inversa y continuar su camino.

57
Sensores de temperatura
Termistores
Un termistor es un resistor que cambia su resistencia con la temperatura.
Técnicamente, todos los resistores son termistores ya que su resistencia siempre
cambia ligeramente con la temperatura, pero este cambio es usualmente muy
pequeño y difícil de medir. Los termistores están fabricados de manera que su
resistencia cambia drásticamente, de tal manera que pueden cambiar 100 ohmios o
más por grado centígrado.
Hay dos tipos de termistores, los llamados NTC (del inglés “negative temperature
coefficient”) y los PTC (de “positive temperature coefficient”). En los primeros, a
medida que aumenta la temperatura, decrece su resistencia; en los segundos, a
medida que aumenta la temperatura, aumenta su resistencia. En nuestros proyectos
normalmente usaremos NTCs para medir temperatura; los PTCs se suelen usar más
dentro de fusibles reseteables (donde si la temperatura crece, incrementan su
resistencia para “ahogar” la corriente y proteger así de un posible sobrecalentamiento
a los circuitos).
Los termistores son mucho más baratos que otros tipos de sensores de temperatura;
además, son resistentes al agua (son solo resistores al fin y al cabo) y trabajan a
cualquier voltaje. Son difíciles de estropear debido a su sencillez y son increíblemente
precisos en las medidas. Por ejemplo, un termistor de 10 KΩ (valor nominal, tomado a
25 °C como referencia estándar) puede medir temperatura con un margen de error de
±0,25 °C (suponiendo que el conversor analógico-digital sea lo suficientemente
preciso también). No obstante, no suelen soportar temperaturas más allá de los 100 y
poco grados, y su constante de tiempo (es decir, los segundos que necesita el
termistor para reducir un 63% la diferencia entre su temperatura inicial y la final) es
normalmente de más de diez segundos.
Para medir la resistencia de un termistor se puede usar un
multímetro, como cualquier otra resistencia. El valor que
obtengamos dependerá de la temperatura del lugar donde
estemos.
Si lo que queremos es medir la temperatura propiamente
dicha con una placa Arduino, primero debemos medir con
ella la resistencia del termistor, y a partir de ella deducir la temperatura
correspondiente. Pero nuestra placa Arduino no tiene un medidor de resistencias
incorporado, por lo que, al igual ya hicimos con los fotorresistores, tendremos que
utilizar las entradas analógicas de la placa para detectar variaciones de voltaje y

58
deducir a partir de estas el valor buscado de la resistencia actual. Así pues, el esquema
de conexiones es idéntico al que ya usamos
con los fotorresistores (y fotodiodos): debemos conectar un terminal del termistor a
la alimentación (por ejemplo, el pin 5V de la placa Arduino) y el otro conectarlo en
serie a un terminal de una resistencia de valor fijo (que hará de resistencia
“pulldown”); el otro terminal de esta resistencia “pull-down” ha de conectarse a tierra.
Además, deberemos conectar una entrada analógica de nuestra placa Arduino a un
punto intermedio entre ambas resistencias para obtener una lectura de la caída de
potencial entre ese punto y tierra.
El chip analógico TMP36
Este chip utiliza una tecnología de estado sólido para medir la temperatura: a medida
que la temperatura crece, la caída de potencial entre la Base y el Emisor de un
transistor incrementa también una cantidad conocida. Amplificando este cambio de
voltaje, se genera una señal analógica que es directamente proporcional a la
temperatura. Este tipo de sensores son precisos, no se desgastan, no necesitan
calibración, pueden trabajar bajo condiciones climáticas diversas, son bastante
baratos y fáciles de usar. En Adafruit se distribuye con código de producto 165 y en
Sparkfun con código 10988. Otros detalles técnicos: su rango de temperatura va desde
los -4 0°C hasta los 125 °C y su rango de voltaje de salida llegar a los 1,75 V (a los 125
°C). Por otro lado, para que su circuitería interna funcione, necesita estar alimentado
por una fuente de entre 2,7 V y 5,5 V y 0,05 mA. Sus conexiones son sencillas: si se
tiene enfrente su parte plana (tal como se muestra en la figura), el pin de más a la
izquierda (nº 1) ha de conectarse a la alimentación y el de más a la derecha (nº 3) a
tierra. El pin del medio (nº 2) es el que sirve para obtener un voltaje analógico
linealmente proporcional a la temperatura (e independiente del voltaje
proporcionado por la fuente de alimentación). Por tanto, este pin nº 2 se tendrá que
conectar a un pin analógico de entrada de nuestra placa Arduino.
Luego, para convertir el voltaje leído en temperatura, simplemente hay que utilizar la
siguiente fórmula extraída del datasheet: T = (V - 0,5)*100 donde T se mediría en
grados centígrados y V en voltios. Así, por ejemplo, si se mide un voltaje de 1V, la
temperatura sería (1V - 0,5)*100 = 50 °C. De la fórmula anterior podemos deducir un
par de cosas: que la resolución es de 10 mV por grado (tal como ya hemos comentado)
y que a 0 °C existe un voltaje de 500 mV. Esta característica permite que el sensor
pueda devolver lecturas de temperaturas bajo cero sin que tengamos que
preocuparnos por manejar valores de voltaje negativos.

59
Si se desea probar este chip antes de incorporarlo a nuestros proyectos, podemos usar
un multímetro en modo medición de voltaje DC. Tendremos que alimentar no
obstante al chip mientras dure la medición. Para ello, podemos usar dos pilas AA (3 V
entra perfectamente dentro del rango de voltaje admitido por el chip), de tal manera
que conectemos su borne positivo y negativo a los pines correspondientes. El
multímetro deberemos conectarlo al pin 3 (tierra) y al pin 2 para realizar la medición.
En una habitación a 25 °C, el voltaje debería de ser de alrededor de 0,75 V. Se puede
jugar a apretar los dedos sobre el encapsulado (para calentarlo) o ponerlo en contacto
con hielo (para enfriarlo) y ver los cambios de valores medidos.

60
El chip digital DS18B20 y el protocolo 1-Wire
El fabricante Maxim (anteriormente conocido como Dallas
Semiconductor) produce una familia de componentes
electrónicos que pueden ser controlados mediante un
protocolo de comunicación propietario llamado “1-Wire”, el
cual permite conectar a nuestra placa Arduino multitud de
estos componentes mediante un solo cable de datos (de ahí su
nombre). Otra característica destacable es que los
componentes interconectados mediante este protocolo
pueden estar situados a grandes distancias (de hasta incluso
30 metros).
El termómetro digital DS18B20 es un chip que utiliza el protocolo 1-Wire. Es muy
popular debido a su bajo precio y facilidad de uso. Es capaz de medir temperaturas en
un rango de -10 oC hasta 85 oC con una precisión de ±0,5 °C. En Sparkfun se puede
encontrar con el código de producto nº 245, en Adafruit con el código nº 374 y en
Freetronics podemos adquirirlo en forma de plaquita breakout, llamada
“Temperature sensor module”, entre otros. Si observamos de frente la cara lisa de su
encapsulado, podemos observar que tiene tres patillas: la de más a la izquierda se
corresponde con la conexión a tierra, la patilla central es la salida digital de la señal de
datos (a conectar a unaentrada digital de la placa Arduino) y la patilla derecha sirve
para recibir la alimentación, la cual puede ser perfectamente los 5 V ofrecidos por la
placa Arduino. Por tanto, en principio necesitaríamos tres cables para utilizar este
componente.
Además, es muy importante, para que el sensor funcione, conectar una resistencia de
4,7 KΩ entre la patilla de señal de datos y la patilla de alimentación. No obstante, este
chip (como el resto de componentes 1-Wire, de hecho) tiene la característica de poder
conectarse de otra manera, utilizando tan solo dos cables. Esto es muy conveniente en
sensores alejados cierta distancia de nuestra placa Arduino y/o situados en un
entorno exterior. Es lo que se llama modo “parásito”, porque la alimentación que
necesita la “parasita” de la señal de datos.
Concretamente, las conexiones son: la patilla de la izquierda a tierra (como antes), la
patilla central a una entrada digital de la placa Arduino (como antes) y la patilla
derecha hay que unirla directamente a la patilla izquierda (para conectarla a tierra).
Además, es muy importante conectar una resistencia de 4,7 KΩ entre el pin de entrada
digital de la placa Arduino donde está conectada la patilla central y la alimentación de
5 V.

61
Sensores de humedad
El sensor DHT22/RHT03
En este apartado hablaremos concretamente del sensor
digital de temperatura y humedad RHT03 de Maxdetect
(http://www.humiditycn.com) , el cual se distribuye
(además de muchos otros) en Sparkfun con nº de
producto 10167 y en Adafruit (aquí con el nombre de
DHT22 y con nº de producto nº 385). También se le puede
encontrar con el nombre de AM2302. Este sensor es muy
básico y lento (solo se pueden obtener datos como mínimo
cada 2 segundos), pero es de bajo coste y muy manejable
para obtener datos básicos en proyectos caseros.
Sus características técnicas más destacables son: se puede alimentar con un voltaje de
entre 3 V y 5 V y 2,5 mA como máximo, puede medir un rango de temperaturas entre -
40 y 125 °C con una precisión de ±0,5 °C y un rango de humedad entre 0 y 100% con
una precisión del 2-5%. Está formado básicamente por un sensor de humedad
capacitivo y un termistor.
Este chip tiene cuatro pines; mirándolo de frente son: el de alimentación (nº 1, el de
más a la izquierda), el de salida digital de datos (nº 2), uno no conectado a nada y que
se puede ignorar (nº 3) y el de tierra (nº 4, el de más a la derecha). Así pues, para que
nuestra placa Arduino pueda leer los datos que emite este chip, deberemos conectar
su pin nº 1 al pin-hembra de 5 V de la placa (por ejemplo), su pin nº 4 a un pin “GND” y
su pin nº 2 a una pin-hembra de entrada digital. Además, es recomendable conectar
una resistencia (“pull-up”) de 4,7 KΩ entre el pin nº 1 y nº 2. Desgraciadamente, el
protocolo que utiliza este sensor para transmitir los datos digitales no es estándar, así
que en principio deberíamos de aprender su funcionamiento interno para poder
interpretar correctamente la información que nos esté llegando en un momento
determinado. Por suerte, tenemos a nuestra disposición gran cantidad de librerías
Arduino, compatibles con este sensor. Estas librerías, a pesar de ser diferentes entre
sí, son en gran medida equivalentes, ya que todas ellas lo que hacen básicamente es
permitir centrarnos en la obtención sencilla de los datos de temperatura y humedad
sin tener que conocer los detalles específicos del protocolo particular utilizado por el
chip. Por lo tanto, la elección de una librería u otra no es determinante.

62
Sensores SHT15 y SHT21
Otro sensor de humedad (y temperatura) es el SHT15, distribuido por Sparkfun en
forma de plaquita breakout con código de producto 8257. Esta plaquita consta de
cuatro pines: alimentación (5 V), tierra, conector “SCK” y conector “DATA”. Estos dos
últimos han de conectarse a dos entradas digitales cualesquiera de nuestra placa
Arduino. Aunque el protocolo de comunicación que utiliza este chip requiere el uso de
dos cables al igual que pasa con I2C, no hay que confundirlos porque son sistemas de
comunicación diferentes. Como datos técnicos a destacar, podemos decir que alcanza
una precisión de hasta +0,3 oC en medidas de temperatura y +2 % en medidas de
humedad y tiene un tiempo de respuesta menor de 4 segundos.
La manera más sencilla de programar este sensor es utilizando la librería disponible
en https://github.com/practicalarduino/SHT1x (también válida para otros sensores
de la misma familia fabricada por Sensirion, como el SHT10, el STH11, el SHT71 o el
SHT75). Por otro lado, un chip del mismo fabricante que sí es capaz de utilizar la
comunicación I2C es el sensor SHT21. LoveElectronics distribuye una plaquita
breakout que ofrece de forma muy cómoda los cuatro conectores necesarios:
alimentación (3,3 V, atención), tierra, pin SDA y pin SCL. Se puede programar
mediante la librería (también válida para el SHT25) disponible en
https://github.com/misenso/SHT2x-Arduino-Library. Otra plaquita muy parecida la
distribuye Modern Device, junto con la librería “LibHumidity”, descargable de la web
del producto.

63
Sensores de distancia
El sensor Ping)))
El sensor digital de distancia Ping)))™ de Parallax es capaz de medir distancias entre
aproximadamente 3 cm y 3 m. Esto lo consigue enviando un ultrasonido (es decir, un
sonido de una frecuencia demasiado elevada para poder ser escuchado por el oído
humano) a través de un transductor (uno de los cilindros que se aprecian en la figura
lateral) y espera a que este ultrasonido rebote sobre un objeto y vuelva, retorno que
es detectado por el otro transductor. El sensor devuelve el tiempo transcurrido entre
el envío y la posterior recepción del ultrasonido. Como la velocidad de propagación de
cualquier (ultra)sonido en un medio como el aire es de valor conocido
(consideraremos que es de 340 m/s –o lo que es lo mismo, 0,034 cm/μs–, aunque esta
sea solo una aproximación) este tiempo transcurrido lo podremos utilizar para
determinar la distancia entre el sensor y el objeto que ha provocado su rebote.
La plaquita en la que viene muestra tres pines marcados. Teniendo visibles enfrente
los transductores son, de izquierda a derecha: el pin de tierra, el de alimentación (5 V)
y el pin para comunicarse con un pin-hembra digital de nuestra placa Arduino (lo
llamaremos a partir de ahora “pin de señal”). Este sensor solo mide distancias cuando
se le solicita. Para ello, nuestra placa Arduino envía a través de su pin digital
(conectado al pin de señal de la plaquita) un pulso HIGH de una duración exacta de 5
microsegundos. Esta es la señal que activa el envío del ultrasonido. Tras un breve
lapso de tiempo, el sensor recibirá el rebote del ultrasonido y como consecuencia,
nuestra placa Arduino recibirá ese dato por el mismo pin digital utilizado
anteriormente. En ese momento, la placa Arduino podrá
calcular el tiempo transcurrido entre el envío y la
recepción de ese ultrasonido. El funcionamiento
descrito obliga a que se deba alternar el modo del pin
digital de la placa Arduino conectado al sensor, de forma
que sea de tipo INPUT o OUTPUT según convenga.
Para calcular la distancia, debemos recordar la fórmula
v = d/t (que no es más que la definición de velocidad:
distancia recorrida en un determinado tiempo). Si de la
fórmula anterior despejamos la “d” (la distancia recorrida) obtenemos finalmente d =
v·t, donde “v” la conocemos y la consideramos constante (0,034 cm/μs) y “t” es el
tiempo medido por el sensor. Hay que tener en cuenta, no obstante, que el dato
obtenido del sensor es el tiempo total que tarda el ultrasonido en “ir y volver”, así que
normalmente querremos dividir previamente este valor entre dos para asignárselo a
“t”.

64
Sensor SRF05
Otro sensor digital que utiliza el método de contar el tiempo transcurrido entre la
emisión de un pulso ultrasónico y su posterior recepción para medir distancias es el
SRF05 de Devantech. Es capaz de medir distancias entre 3 cm y 3 m a un ritmo de
hasta 20 veces por segundo.
Este sensor se puede conectar de dos maneras diferentes a nuestra placa Arduino: o
bien utilizando cuatro cables (“modo 1” compatible con su predecesor, el sensor
SRF04), o bien usando tres (“modo 2”). Si observamos el dorso del sensor y
mantenemos la serigrafía “SRF05” visible a nuestra izquierda, en el modo 1 los cinco
conectores de la zona inferior se corresponden, de izquierda a derecha, con:
alimentación (5 V), entrada del rebote ultrasónico (pin “echo”), salida del pulso
ultrasónico (pin “trigger”), pin que no se ha de conectar a nada y tierra. El pin “echo”
se ha de conectar a un pin de entrada digital de nuestra placa Arduino y el pin
“trigger” a un pin de salida digital. Este pin “trigger” es el responsable de generar una
pulso con una duración exacta de 10 microsegundos, el cual marca el inicio del envío
de la señal ultrasónica, y el pin “echo” utiliza el mismo truco que el sensor Ping))) para
contar el tiempo transcurrido entre envío y recepción del ultrasonido: el mantener
una señal HIGH mientras no se reciba el rebote.
Si utilizamos el modo 2, estos mismos conectores se corresponden (de izquierda a
derecha también) con: alimentación (5 V), pin que no se ha de conectar a nada, salida
y entrada todo en uno de la señal ultrasónica, tierra y tierra otra vez. En este modo, el
sensor utiliza un solo pin para enviar el pulso y recibir el rebote (tal como ocurre de
hecho con el sensor Ping)))). Esto permite utilizar un cableado más simple, aunque la
programación se complica, porque el mismo pin ha de alternar entre ser entrada y
salida dependiendo de las circunstancias.

65
El sensor HC-SR04
Este sensor es muy parecido a los anteriores. Dispone de cuatro pines: “VCC” (se ha de
conectar a una fuente de 5 V), “Trig” (responsable de enviar el pulso ultrasónico; por
tanto, se deberá conectar a un pin de salida digital de la placa Arduino), “Echo”
(responsable de recibir el eco de ese pulso; luego se deberá conectar a un pin de
entrada digital de la placa Arduino) y “GND” (a tierra). Se puede adquirir en
IteadStudio o Elecfreaks por menos de diez euros.
Al igual que los anteriores sensores, tiene un rango de distancias sensible entre 3 cm y
3 m con una precisión de 3 mm, y su funcionamiento también es muy parecido: tras
emitir por el pin “trigger” una señal de 10 μs para iniciar el envío de la señal
ultrasónica, espera a detectar el eco mediante la detección del fin de la señal HIGH
recibida por el pin “echo”.
El sensor LV-EZ0
Otro sensor de distancia que utiliza ultrasonidos es el sensor LV-EZ0 de Maxbotix. No
obstante, a diferencia de los anteriores, el LV-EZO es un sensor analógico. Por ello,
para usarlo con nuestra placa Arduino deberemos conectar (además del pin “+5 V” a la
alimentación de 5V proporcionada por la placa Arduino y del pin “GND” a la tierra
común) el pin etiquetado como “AN” a una entrada analógica de nuestra placa
Arduino.
El rango de distancias que puede medir este sensor depende mucho del tamaño del
obstáculo: si este es del tamaño de un dedo, el rango es aproximadamente de 2,5
metros; si este es del tamaño de una hoja de papel, el rango puede aumentar hasta 6
metros. En todo caso, no es capaz de detectar distancias más pequeñas de 30 cm. La
buena noticia está en que el comportamiento de este sensor es lineal: si un obstáculo
está por ejemplo a 2 metros, la lectura de tensión recibida por el pin de entrada
analógica será la mitad que si está a 4 metros. Esto permite que las lecturas sean muy
fáciles de realizar.

66
El sensor IS471F
Este sensor no es un detector de distancia propiamente sino simplemente de
presencia; concretamente detecta la existencia o no de un obstaculo entre 1 cm y 15
cm. Funciona emitiendo un haz infrarrojo y comprobando si le llega rebotado. Si es asi,
el sensor generara una senal LOW (que podra ser leida por una placa Arduino
conectada a el convenientemente) y si no se detecta ningun objeto, el sensor generara
una senal HIGH.
El sensor consta de cuatro pines, los cuales son (si observamos su cara plana de frente,
de izquierda a derecha): alimentacion (5 V), deteccion de datos (a conectar a un pin de
entrada digital de nuestra placa Arduino), tierra y emision de señal infrarroja (a este
lo llamaremos pin •gX•h). Se recomienda conectar tambien un condensador (de 0,33
ƒÊF) de tipo •gby-pass•h entre ese pin •gX•h y el pin de tierra.
Sensores QRD1114 y QRE1113
El sensor QRD1114 (código de producto 246 de Sparkfun) en realidad no es más que
un emisor de infrarrojos y un fototransistor bajo el mismo encapsulado, por lo que el
principio de funcionamiento es similar a los sensores infrarrojos analógicos ya vistos:
cuanta más distancia tenga el obstáculo, menos voltaje de salida obtendremos del
sensor. Su característica más destacable es su rango de distancias, ya que solo es
capaz de detectar objetos situados entre 0 y 3 cm de él. En realidad, este componente
no está pensado para medir distancias exactas, sino tan solo para comprobar la
proximidad de objetos por debajo de esos 3 cm.

67
Sensores de inclinación
Los sensores de inclinación son pequeños, baratos, y fáciles de usar. Pueden trabajar
con voltajes de hasta 24 V e intensidades de 5 mA. Constan de una cavidad y de una
masa libre conductiva en su interior (como por ejemplo una bola metálica rodante);
un extremo de la cavidad tiene dos polos conductivos de manera que cuando el sensor
se orienta con este extremo hacia abajo, la masa rueda hacia los polos y los cierra. Por
tanto, estos sensores actúan como interruptores, dejando o no pasar la corriente
según la inclinación del circuito. Aunque no son tan precisos o flexibles como un
completo acelerómetro, pueden detectar orientación o movimiento fácilmente.
Comprobar un sensor de inclinación es fácil: hay que poner el multímetro en modo de
continuidad y conectar un cable cualquiera del multímetro (ya que los sensores de
inclinación son dispositivos no polarizados) a cada borne del sensor. Seguidamente,
hay que inclinarlo para determinar el ángulo en el cual el interruptor se abre y se
cierra. Si se conecta este sensor en serie a un LED (y su divisor de tensión preceptivo) y se
alimenta el circuito, veremos cómo el LED se enciende o se apaga según la inclinación que le
demos al diseño, tal como si estuviéramos utilizando un pulsador “invisible”.

68
Sensores de movimiento
Los sensores PIR básicamente se componen de dos sensores piroeléctricos de
infrarrojos. Y todos los objetos emiten radiación infrarroja, estando además
demostrado que cuanto más caliente está un objeto, más radiación de este tipo emite.
Normalmente, ambos sensores detectarán la misma cantidad de radiación IR (la
presente en el ambiente procedente de la habitación o del exterior), pero cuando un
cuerpo caliente como un humano o un animal pasa a través del rango de detección, lo
interceptará primero uno de los dos sensores, lo que causa un cambio diferencial
positivo respecto el otro. Cuando el cuerpo caliente abandona el área de sensibilidad,
ocurre lo contrario: es el segundo sensor el que intercepta el cuerpo y genera un
cambio diferencial negativo. Estos pulsos son lo que en realidad el sensor detecta. Así
pues, estos sensores son casi siempre utilizados para saber si un humano se ha
movido dentro o fuera del (normalmente amplio) rango del sensor: alarmas de
seguridad o luces de casa automáticas son un par de usos comunes para estos
dispositivos.

69
Sensor IR
El sensor IR es básicamente un transistor FET con una ventana sensible a la radiación
infrarroja en su cubierta protectora; cambios en el nivel de luz IR con una longitud de
onda correspondiente al calor del cuerpo causan cambios en la resistencia
fuentedrenador, que es lo que el circuito monitoriza. De todas formas, el gran truco de
un sensor IR está en las lentes que incorpora: su función es condensar una gran área
en una pequeña, proporcionando al sensor IR un rango de barrido mayor. De hecho, la
calidad de las lentes es lo que básicamente diferencia un modelo de sensor PIR de
otro, ya que la circuitería es bastante común a todos; cambiando una lente por otra se
puede cambiar la amplitud y el patrón de sensibilidad del sensor.
Además de toda la circuitería ya comentada (sensores IR, lentes, etc.), un sensor PIR
incorpora siempre un chip que sirve para leer la salida de los sensores IR y procesarla
de tal manera que finalmente se emita un pulso digital al exterior (que es lo que
nuestra placa Arduino recibirá).
La mayoría de sensores PIR vienen en plaquitas con 3 pines de conexión a un lado o al
fondo: alimentación, tierra y señal de datos. El orden de estos tres pines puede variar
según el modelo, así que hay que consultarlo en el datasheet (aunque la mayoría de
veces cada pin ya tiene serigrafiada en la propia plaquita su función). La alimentación
usualmente es de 3-5 V DC pero puede llegar a ser de 12 V, así que con una fuente de 5
V-9 V ya funcionan perfectamente.
Otras características comunes a la mayoría de modelos es que a través de su pin de
datos emiten un pulso HIGH (3,3 V) cuando se detecta movimiento y emiten un pulso
LOW cuando no. La longitud de los pulsos se determinan por los resistores y
condensadores presentes en la PCB y difieren de sensor a sensor. Su rango de
sensibilidad suele ser hasta una distancia de 6 metros y un ángulo de 110° en
horizontal y 70° en vertical. La mayoría de modelos integran el chip BIS0001 para el
control de la circuitería interna y el sensor IR RE200B; las lentes pueden ser muy
variadas.

70
El sensor ePIR
En Sparkfun (entre otros sitios) se puede adquirir con código de producto 9587 un
sensor algo diferente llamado “ePIR”, del fabricante Zilog. La diferencia más
importante entre este componente y los sensores PIR vistos anteriormente está en
que el primero incluye además un microcontrolador propio dentro de su encapsulado.
Esto permite una mayor flexibilidad a la hora de controlar el sensor y de gestionar los
datos obtenidos.
Concretamente, se puede establecer comunicación con este componente de dos
formas diferentes: en “modo hardware” y en “modo serie”. En el “modo hardware”, se
puede ajustar la sensibilidad del sensor (es decir, a partir de qué valor detectado se
considera movimiento) o el retardo (es decir, cuánto tiempo se esperará el sensor
después de la detección de movimiento para volver a continuar detectando otro
nuevo), entre otros parámetros. El “modo serie”, por su parte, ofrece todas las
funcionalidades del “modo hardware” pero además permite configuraciones más
avanzadas mediante el envío de comandos específicos (como por ejemplo detectar
movimiento en solo una dirección, ampliar el rango de detección de 3 m x 3 m a 5 m x
5 m y más). Por ejemplo, para forzar la detección de movimiento, deberemos enviar el
comando “a”, el cual sirve para obtener la lectura del sensor en forma de carácter
ASCII ‘Y’ (si hay movimiento) o ‘N’ (si no). De todas formas, para conocer todos los
comandos disponibles y sus posibles usos, recomiendo consultar el datasheet del
sensor. Para seleccionar el •gmodo hardware•h, en el momento de arrancar el
sensor (o al salir de su modo de bajo consumo) se debe proporcionar una tension
menor de 1,8 V a su pin no 4. Ademas, el valor concreto de esta tension determina la
sensibilidad del sensor, donde 0 V corresponde a la mayor sensibilidad y 1,8 V a la
menor.
Por lo tanto, si este pin se conecta directamente a tierra tendremos el •gmodo
hardware•h ya activado con la sensibilidad maxima posible. Si lo que se desea es
regular dicha sensibilidad a mano, una opcion seria conectar este pin a la patilla
central de un potenciometro (los extremos del potenciometro en este caso deberian ir
conectados a tierra y alimentacion, respectivamente), utilizando los divisores de
tensión pertinentes para obtener el rango 0-1,8 V deseado. Para seleccionar el gmodo
serie•h, en el momento de arrancar el sensor (o al salir de su modo de bajo consumo)
se debe proporcionar una tension mayor de 2,5 V a su pin no 4. Una manera de
conseguir esto es conectar una resistencia •gpull-up•h (generalmente de 100 Kƒ¶)
entre este pin no 4 y la fuente de alimentacion (que, atencion, ha de ser de 3,3 V).

71
Sensores de contacto
Sensores de fuerza
Estos sensores (también llamados FSRs, del inglés, “Force Sensitive Resistor”)
permiten detectar fuerza. Son básicamente un resistor que cambia su resistencia
dependiendo de la fuerza a la que es sometido (concretamente, su resistencia
disminuye a mayor fuerza recibida). Estos sensores son muy baratos y fáciles de usar
pero no demasiado precisos: una misma medida puede variar entre un sensor y otro
hasta un 10%. Así que lo que uno puede esperar de un FSR es conseguir medir rangos
de respuesta; es decir: aunque los FSRs sirven para detectar peso, son mala elección
para detectar la cantidad exacta de este. Sin embargo, para la mayoría de aplicaciones
sensibles al tacto, del tipo “esto ha sido apretado cierta cantidad” son una solución
aceptable y económica.
Los FSRs están compuestos por una zona “activa” (de forma generalmente circular o
cuadrada y de diferentes tamaños según el modelo), y dos terminales que, al ser este
dispositivo una resistencia, no están polarizados. Normalmente, pueden soportar
rangos de fuerzas de 0 a 100 newtons y el rango de resistencias que ofrecen van desde
resistencia infinita cuando no detectan fuerza hasta aproximadamente 200 ohmios a
máxima fuerza. En el datasheet del modelo concreto de FSR deberemos encontrar
siempre cómo es esa relación “fuerza aplicada -> resistencia obtenida”, la cual no es
exactamente lineal (ya que a pequeñas fuerzas hay una variación muy grande de la
resistencia, y a fuerzas mayores la variación ya es menor).
Para comprobar su funcionamiento se puede utilizar un multímetro en modo de
medida de resistencia. Apretando la zona sensible del FSR se deberá observar los
cambios de resistencia.

72
Sensores de flexión
Unos sensores parecidos a los FSR son los sensores de flexión (en inglés llamados “flex
sensors” o “bend sensors”). Estos sensores están compuestos por una tira resistiva
flexible solo en una dirección. Su resistencia cambia según cuánto sea arqueada: si
están en equilibrio (es decir, sin combarse) su resistencia es mínima y cuanto más se
flexiona más resistencia ofrece.
Al igual que las FSR, tienen dos terminales: uno podemos conectarlo dentro de
nuestros circuitos a la fuente de alimentación (preferiblemente a través de un divisor
de tensión) y el otro a una resistencia “pull-down” que va a tierra (también se podría
usar la configuración alternativa usando “pull-up”s). En el punto donde se conecta el
sensor a la resistencia “pull-down” se debe conectar una entrada analógica de la placa
Arduino para leer el voltaje resultante en ese punto. Como ya sabemos, ese valor
depende del valor de la resistencia del sensor, por lo que nos servirá para saber
cuánto está flexionado.

73
Sensores de golpes
Debido a su constitución eléctrica interna, los zumbadores también pueden utilizarse,
además de como emisores de sonidos, como sensores de golpes. El mecanismo es
justo a la inversa del convencional: los golpes (suaves) recibidos por el zumbador se
traducen en vibración de su lámina interna, la cual genera una serie de pulsos
eléctricos que pueden ser leídos por una placa Arduino. De esta manera, podemos
diseñar circuitos que respondan al tacto y que distingan incluso la presión ejercida.
Como el zumbador es un dispositivo analógico, según lo fuerte que se golpee, la señal
leída por la placa Arduino será de menor o mayor intensidad.

74
Sensor de sonido
Un sensor de sonido no es más que un sensor de presión que convierte las ondas de
presión de aire (las ondas sonoras) en señales eléctricas de tipo analógico; es decir, un
micrófono. Existen muchos tipos de micrófonos según el mecanismo físico que utilizan
para realizar esa conversión: los de tipo “inductivo”
(también llamados “dinámicos”), los “de
condensador”, los piezoeléctricos, etc. Dependiendo
del tipo, unos tendrán una mejor respuesta a un
rango determinado de frecuencias de sonido que
otros (es decir, que serán más “fieles” a la onda
original), unos tendrán una mayor sensibilidad que
otros (es decir, que ya generarán un determinado
voltaje a menores variaciones de volumen
detectadas), unos comenzarán a distorsionar a
menores volúmenes que otros (es decir, que
ofrecerán una THD menor para un determinado
voltaje), unos serán más resistentes y duraderos
que otros, etc.
No obstante, en nuestros proyectos con placas Arduino UNO la variedad de
micrófonos a elegir se reduce drásticamente. Arduino UNO no es una plataforma
pensada para el procesamiento de audio: ya hemos visto que (aunque existen
proyectos destacables en el ámbito de la síntesis) la generación y emisión de sonido es
ciertamente limitada. Y lo mismo ocurre con la recepción de sonido: para empezar, los
pines-hembra de la placa no son capaces de recibir corriente AC (que es lo que son las
señales de audio). Además, el conversor analógico-digital tarda como mínimo 100
microsegundos en realizar una lectura de una entrada, por lo que la máxima
frecuencia de muestreo posible es de 10 KHz (es decir, una calidad relativamente
baja). Además, el procesamiento de una señal acústica (compuesta en realidad de un
conjunto de múltiples señales analógicas de diferentes frecuencias y amplitudes) es
mucho más complejo de lo que el ATmega328P y su limitada memoria es capaz de
realizar con solvencia.
Por eso, los micrófonos que se utilizan junto con las placas Arduino UNO en la mayoría
de los casos son utilizados solamente como simples detectores de presencia y/o
volumen de sonido (o como mucho, conectándolos a chips especiales como el MSGEQ7
de Mixed Signal Integration, podrían ser usados como detectores de frecuencias de
sonido,

75
Ejemplo de programación
EJEMPLO No. 1: PROGRAMA QUE LEE DOS NÚMEROS Y ESCRIBE EL MAYOR DE LOS
DOS.
#include <stdio.h>
main()
{
int x, y;
printf(“Escribe el primer número: “);
scanf(“%d”,&x);
printf(“Escribe el segundo número:”);
scanf(“%d”,&y);
if (x > y)
printf(“El mayor es: %d”,x);
else
if ( y > x )
printf(“El mayor es: %d”,y);
else
printf(“Son iguales”);
}

76
2.-En este ejemplo el LED conectado al pin 13 parpadea cada segundo.
int ledPin = 13; // LED que se encuentra en el pin 13
void setup(){
pinMode(ledPin, OUTPUT); // El p1n 13 será una salida digital
}
void loop(){
digitalWrite(ledPin, HIGH); // Enciende el LED
delay(1000); // Pausa de 1 segundo
digitalWrite(ledPin, LOW); // Apaga el LED
}
Salida digital II
En este ejemplo el LED conectado al pin 13 parpadea en un intervalo de tiempo
variable que depende del número de veces que se ejecuta el programa (función loop)
int ledPin = 13; // LED que se encuentra en el pin 13
int n = 0; //Entero que contará el paso por la función loop
void setup(){
pinMode(ledPin, OUTPUT); // El p1n 13 será una salida digital
}
void loop(){
digitalWrite(ledPin, HIGH); // Enciende el LED

77
digitalWrite(ledPin, LOW); // Apaga el LED
n++; //Incrementamos n
delay(delayVal(n)); //Pausa de un tiempo variable
}
//Función que devuelve un valor tipo entero según el parámetro pasado
int delayVal(int f){
return f*100;
}

78
Conclusión
Hemos llegado al término de la investigación en la cual fue muy factible
establecer diferentes puntos asignados del Arduino, conocer por qué
utilizar los elementos del microcontrolador establece la función que cada
uno desarrolla, establecimos las familias más comunes que se utilizan, de
la misma manera definimos que es el botón reset, tipo de memoria entre
otros importantes como el compilador que nos dice que es un programa
informático, que se encarga de traducir el código fuente de una aplicación
que este en desarrollo, es decir convierte un programa hecho en lenguaje
de programación de alto nivel a un lenguaje de máquina y así gracias al
Arduino se han facilitado muchos procesos industriales en donde se
aplique dicha tecnología por lo cual es algo muy útil y necesario que se
debe de aprender a usar para poder realizar trabajos más efectivos de
manera más sencilla.

79
Bibliografías
Arduino. Curso práctico de formación - Óscar Torrente Artero
http://www.cortoc.com/2011/12/introduccion-arduino.html
https://aprendiendoarduino.wordpress.com/2015/03/30/sensores/
https://www.arduino.cc/
http://www.xataka.com/especiales/guia-del-arduinomaniaco-todo-lo-
que-necesitas-saber-sobre-arduino

Qué es arduino

Más contenido relacionado

La actualidad más candente (20)

Destacado (17)

Similar a Qué es arduino (20)

Último (11)

Qué es arduino