Copyright © 2017,Rubén Beiroa Mosquera

Todos los derechos reservados.

Queda prohibida la reproducción total o parcial sin el permiso previo y
por escrito del titular del Copyright.

1
Índice
¿Qué es Arduino? 3
Hardware Arduino 8
Software Arduino 22
Lenguaje de programación 24
Historia y filosofía de Arduino 26
¿Qué podemos hacer con Arduino? 27
Otras plataformas 31
Introducción 32
Primeros Pasos 34
Pines digitales: salida 34
Temporizaciones Arduino 53
Pines digitales: entrada 54
Variables 70
Regulación led 80
Estructuras de control de flujo 104
Estructuras de control de flujo no repetitivas 105
If 107
else 112
if else if 118
Operadores lógicos 123
Operadores de comparación 129
Operadores compuestos y aritméticos 136
switch 136
Web grafía 139

2
¿Qué es Arduino?
Arduino se ha convertido en un referente del hardware libre que
surgió como una herramienta para estudiantes, pero que, poco a
poco, ha conseguido romper barreras. Cada vez son más las personas
que ven en esta plataforma la herramienta idónea para aprender todo
aquello que quisieron conocer y no pudieron.

Debido a su filosofía, a una gran comunidad de desarrolladores y

desarrolladoras y a toda la tecnología y plataformas de las que
disponemos, Arduino se ha convertido en una herramienta básica en
el movimiento maker(crear objetos artesanales , pero utilizando la
tecnología), la docencia (en las áreas de ciencia, ingeniería,
tecnología y matemáticas), el impulso del IoT (Internet of Things o
«internet de las cosas») y el prototipado.

Arduino se ha convertido en la herramienta fundamental para el

aprendizaje de la electrónica y programación. Todos aquellos que
hayan estudiado estos campos saben que muchos de los conceptos
básicos son muy abstractos. Con Arduino esto cambia: en el
momento en el que aprendamos, por ejemplo, una nueva instrucción,
podemos realizar un programa de pocas líneas, conectar un simple
led y, si el led se enciende (si ese es nuestro objetivo), significa que,
no solo hemos aprendido algo nuevo, sino que hemos afianzado ese
conocimiento.

¿Y si no funciona ese programa? Lo modificaremos las veces que

sea necesaria hasta que encontremos el error. Este proceso de
aprendizaje es relativamente rápido. Sin embargo, Arduino no es solo
una herramienta importante en el aprendizaje, sino también en el
desarrollo de prototipos, en el que disponemos de un hardware
totalmente operativo.

Empecemos por ver qué es Arduino: Arduino es una plataforma libre,

educativa y de desarrollo. Generalmente, cuando se habla de un
Arduino –«Estoy programando un Arduino»–, nos estamos refiriendo
al elemento físico de la plataforma Arduino, su hardware (también
conocido como tarjeta, placa o PCB). Arduino es algo más que un
hardware, por lo que su definición más exacta es la de plataforma
formada por: un hardware, un software (o entorno de programación)
y un lenguaje de programación.

La función de la plataforma Arduino es facilitar el uso de un

microcontrolador (MCU). A partir de ahora, utilizaremos las siglas
MCU para referirnos a un microcontrolador.

3
 Imagen 1. MCU

Un MCU es un circuito integrado que puede ser reprogramado y que

está diseñado para el control de procesos, mediante la lectura y
generación de señales.

¿Control de procesos?

Qué complejo parece esto… Vamos a buscar en el diccionario de la

RAE qué significa «control» y «proceso».

• Control:
«Regulación manual o automática sobre un sistema».

• Proceso:
«Conjunto de fases sucesivas de un fenómeno natural o de una
operación artificial».

Entonces el control de procesos sería: La regulación manual o

automática sobre un conjunto de fases sucesivas de un fenómeno
natural o de una operación artificial... Tampoco parece que
solucionemos mucho, vamos a poner un ejemplo para entenderlo
mejor:

4
 Imagen 2. Proceso

En la imagen 2, tenemos un caso práctico sobre un proceso. Este

proceso consiste en llenar y vaciar un tanque cuando sea necesario.
Si queremos controlar ese proceso, necesitaremos implementar un
sistema para que se conecte a los diferentes elementos que
intervienen en el proceso de llenado y vaciado (bomba, válvula y
sensor).

Si no nos vemos capaces de hacerlo nosotros, buscamos a quién nos

solucione el problema, y resulta que, en internet, encontramos que
alguien hace algo similar con un Arduino.

¿Arduino? ¿Qué es esto? Empezamos a buscar en internet temas

relacionados con Arduino y nos aparece una gran cantidad de
proyectos de diversa índole usando todo tipo de tecnología y de
forma muy económica. Por lo tanto, si yo mismo puedo solucionar el
problema y, además, no me sale caro, parece interesante.

¿Cuántos de nosotros hemos tenido alguna idea que nos

parece muy innovadora? Pero, quizás, por no tener conocimientos
sobre electrónica o programación, abandonamos esa idea.

¿Por qué Arduino? ¿Para qué sirve? Volvamos al caso anterior:

tratemos de implementar una solución para el control del nivel de
líquido de un tanque. No obstante, no disponemos de una plataforma
como Arduino o similar ni conocimientos previos sobre programación,
electrónica, ni MCU.

Como no disponemos de Arduino, necesitamos un MCU.

Primeramente, tenemos que escoger el más adecuado, considerando
las características técnicas del proceso que vamos controlar. En el
mercado disponemos de varios fabricantes de MCU, todos ellos con
un amplio catálogo. Tendremos que decantarnos por un fabricante y

5
escoger un MCU de entre todos los que tiene; para analizar los MCU,
necesitamos trabajar con sus manuales.

El manual de un MCU no está desarrollado para que cualquier

persona, independientemente de su formación, pueda interpretarlo.
Nos enfrentaremos a manuales de hasta 450 páginas, con un
lenguaje muy técnico, por lo que no solo es necesario un
conocimiento previo sobre MCU, sino sobre programación, muchos
«mecanismos internos», como Timers, interrupciones, etc.
Posiblemente, si nunca hemos programado, no entenderemos para
qué sirven.

Imagen 3. Manual

Además, debemos analizar sus limitaciones en cuanto a potencia

eléctrica y si necesita más componentes para poder operar (como
osciladores, condensadores…).

Imagen 4. Componentes

También nos limitará el formato (tamaño) de cada MCU, nos

encontramos con muchos que no vamos a poder «manejar» por su

6
reducido tamaño. Aún con todas estas dificultades, vamos a suponer
que nuestra elección es la correcta.

A continuación, el siguiente problema sería cómo conectar el MCU al

PC para poder programarlo: tendremos que comprar un módulo para
poder programarlo, lo que nos va a obligar a realizar diferentes
conexiones (implicará protoboards, cables). A todo esto, quizás le
debamos sumar más componentes que necesite el MCU para poder
operar.

Imagen 5.

Sin embargo, podemos con todo, solucionamos todos estos pasos y

ya estamos listos para programar. Necesitamos un entorno de
programación: lo más seguro es que el fabricante del MCU disponga
de uno propio, pero quizás disponemos de diferentes versiones (de
prueba, para estudiantes, para profesionales) y podrán ser de pago o
no.

Descargamos el entorno y ahora sí que empezamos a programar. No

obstante, puede que ese entorno no sea todo lo «amigable» que
esperemos. Puede ser un entorno muy con una gran cantidad de
herramientas, menús… Lo cual es bueno, pero quizás, al principio,
nos llegue a confundir, aunque al final, después de revisar
documentación, lo entendamos y podamos seguir.

Si no tenemos conocimientos de programación, no nos va a quedar

otro remedio que aprender, tendremos que buscar información
(ejemplos, documentación, manuales).

Como acabamos de ver, existe una gran cantidad de obstáculos para

simplemente empezar a programar un MCU y, con todo esto, una vez
que los superemos, tenemos que ser capaces de llegar a una

7
solución, desarrollar el programa adecuado e implementar
físicamente este sistema (conectarlo a un entorno).

Sin una formación adecuada, lo más seguro es que no nos veamos

capaces de afrontar este reto, pero con Arduino, esto cambia.
Arduino nos elimina toda una serie de obstáculos para que nuestra
principal preocupación sea programar un MCU y conectar el Arduino a
los elementos que intervengan en un proceso.

A continuación, veremos cómo se nos platea la misma tarea con un

Arduino y veremos qué papel desempeña cada uno de los elementos
de la plataforma Arduino.

Hardware Arduino

Planteémonos el mismo trabajo, pero ahora, con un Arduino.

Primeramente, al igual que pasaba con el MCU, tendremos que elegir
un Arduino. Disponemos de un gran catálogo de placas Arduino,
todas las placas presentan diferencias entre ellas (debido a la
incorporación de periféricos como: WIFI, Ethernet, conector tarjetas
SD), aunque las diferencias básicas son debidas al MCU en concreto
que incorpore cada placa.

Es importante recalcar que Arduino no fabrica los MCU de su

hardware, estos MCU son desarrollados y fabricados por Atmel.
Arduino incorpora los MCU en el proceso de fabricación de las placas.
En consecuencia, lo que hicieron fue estudiar ese manual de 450
páginas de cada MCU y dar una solución a ese problema,
ofreciéndonos un sistema que incorpora todo la electrónica necesaria
para programar e implementar un MCU.

Imagen 6. MCU Arduino UNO

En realidad, el hardware de Arduino no es más que una extensión de

las patillas de un MCU con una serie de componentes electrónicos de
por medio.

8
 Imagen 7.

Gracias a este hardware de Arduino disponemos de:

- conexión para PC,

- la electrónica necesaria para el correcto funcionamiento del
MCU,
- puntos de conexión para las patillas del MCU,
- alimentación externa (pila, batería, cargador).

Al comprar un Arduino, no tenemos que preocuparnos por cómo

conectarlo a nuestro PC, solo habrá que comprarlo y, con un cable
USB (del tipo correspondiente según el modelo), conectarlo y
empezar a programar (la mayoría de los Arduinos aportan esta
solución), sin preocuparnos de si necesitamos componentes
electrónicos a mayores, como ocurría cuando trabajábamos
directamente con el MCU.

Además, si necesitamos conectar sensores, resulta más sencillo

realizar la conexión a través de los pines del Arduino que a través de
las patillas de MCU. A mayores añadieron un conector Jack (con la
electrónica correspondiente) para poder alimentar nuestro Arduino a
través de pilas o baterías (no todos lo incluyen).

Como disponemos de un gran catálogo de Arduino, revisaremos las

placas más conocidas. Primero analizaremos el Arduino UNO y
compararemos las restantes placas con respecto a este Arduino
mediante un análisis básico.

Partimos entonces del Arduino UNO, ¿por qué el Arduino UNO?

Porque es el único que permite reemplazar su MCU, gracias a que se
encuentra insertado en un zócalo, el cual sí que está soldado a la
placa y no el MCU.

9
El resto de Arduinos tienen directamente soldado su MCU a la placa;
el no estar soldado a la placa presenta unas grandes ventajas, como
la posibilidad de programar un MCU, quitarlo de la placa e insertarlo
en otro sistema electrónico.

Asimismo, lo hace ideal para principiantes (y no tan principiantes). En

cualquier momento podemos cometer un error y dañar nuestro
Arduino y podrían darse varias posibilidades: dañar simplemente el
MCU, la placa, o ambos. En los dos últimos casos, no tendríamos más
remedio que reemplazar nuestro Arduino. No obstante, en el primer
caso, tenemos la posibilidad de reemplazar el MCU, podemos adquirir
el MCU por separado y reemplazarlo. Aunque este paso no sería tan
sencillo.

Como comentábamos antes, Arduino no fabrica los MCU, sino que los
adquiere y los implementa en el proceso de fabricación de las placas;
es necesario que le carguen un programa (bootloader) para que
pueda trabajar ese MCU en la plataforma Arduino.
Al comprar por nuestra cuenta el MCU, no vendrá con ese programa
cargado y será trabajo nuestro realizar ese proceso.

Vamos a empezar a analizar nuestro Arduino UNO. Para ello, vamos a

la página oficial de Arduino (https://www.arduino.cc/), que podemos
considerar como la Wikipedia de Arduino. En ella, disponemos de
información tanto del hardware (accesorios, módulos o placas), como
de programación (instrucciones, librerías...) e incluso disponemos de
un foro para realizar nuestras consultas.

En la página oficial nos dirigimos a Products > Arduino

(https://www.arduino.cc/en/Main/Products). Nos mostrará una tabla
con todos los productos Arduino clasificados por tipo. Seleccionamos
el que nos interese (Arduino UNO: https://store.arduino.cc/arduino-
uno-rev3).

Sea cual sea nuestra selección, lo primero que nos muestran en la

página es la opción de comprarlo. Si seguimos navegando por la
página, nos encontramos con los siguientes tres apartados:

• Overview: Breve descripción del producto.

• Tech Specs: Especificaciones técnicas.
• Documentation: Explicación mas detallada del producto.

10
Revisemos las especificaciones técnicas:

Parámetro Valor Descripción

Microcontroller ATmega328P El MCU en concreto que

incorpora esta placa.

Tensión de trabajo del MCU;

tensión máxima de
Operating Voltage 5 V
alimentación, de salida y
entrada.
Input Voltage Tensión óptima de alimentación
7-12 V
(Recommended) externa (conector Jack).
Tensión límite de alimentación
Input Voltage (Limit) 6-20 V
externa (conector Jack).
Número de entradas y salidas
14 (of which 6 provide
Digital I/O Pins digitales (de las cuales 6 se
PWM output)
pueden comportar como PWM).
Los 6 pines que nos indica el
Digital I/O PWM Pins 6 PWM
apartado anterior.

Analog Input Pins 6 Número de entradas analógicas.

DC Current per I/O Máxima intensidad de entrada/

20 mA
Pin salida por los pines del Arduino.
DC Current for 3.3V Máxima intensidad por el pin de
50 mA
Pin 3,3 V.
32 KB (ATmega328P) of
Flash Memory which 0.5 KB used by Memoria de programa.
bootloader

SRAM 2 KB (ATmega328P) Memoria de datos temporales.

Memoria de datos
EEPROM 1 KB (ATmega328P)
permanentes.

Clock Speed 16 MHz Velocidad.

Led asociado al estado del pin
LED_BUILTIN 13
13.
Length 68.6 mm Tamaño.
Width 53.4 mm Tamaño.
Weight 25 g Peso.

Nos damos de cuenta de que será más sencillo enfrentarnos a una

tabla como la anterior que a un manual de un MCU con demasiada

11
información. Además de ser mucha menos información, es mucho
más concreta y, para una persona principiante, será más fácil
asimilar ciertos conceptos con este tipo de disposición.

Si soy principiante en electrónica, Arduino o programación, ¿qué es

lo que debo tener en cuenta? Lo primero que tenemos que hacer
es fijarnos en la potencia eléctrica de cada placa. En cuanto al
voltaje, esta tabla nos dice que la operación de trabajo es de 5V, lo
quiere decir que es la máxima tensión que puede aportar (salida) por
cualquiera de los pines y que puede soportar (entrada). Otro
apartado nos dice que la intensidad máxima es de 20 mA por pin
(tanto de entrada como de salida).

En conclusión, trabajamos a 5V y, como máximo, 20 mA (por pin), lo

que hace que sea imposible encender directamente, por ejemplo, una
bombilla de nuestra casa; será necesario un elemento intermedio,
como puede ser un relay (se trata de un interruptor, pero, en lugar
de gobernarlo por una acción manual, se hace mediante una señal
eléctrica).

Esta cuestión es muy importante y, sobre todo, el parámetro de la

intensidad, la limitación de 20 mA, ¿quiere decir que por cada pin
no puede salir mas intensidad? No, lo que nos indica es que nos
debemos asegurar de que no se supere esa demanda de intensidad.

Hay que tener en cuenta que un Arduino no produce energía, en todo

caso la distribuye, es decir, si nosotros programamos nuestro Arduino
para que active una salida, este hará dicha operación y aportará la
intensidad que se le demande por esa salida.
En otras palabras, «coge» intensidad de la fuente de alimentación y
la «saca» por el pin correspondiente. El problema viene si superamos
esa intensidad que nos indican; el hecho de que circule a través de
nuestro MCU una intensidad superior a la indicada lo quemaría. Este
punto lo revisaremos con detenimiento en cada caso práctico de este
libro.

Lo que siempre debemos hacer es un estudio del proceso que

queremos controlar. Dentro de ese estudio, es importante valorar los
consumos; se trata una condición que nos puede hacer decantar por
un Arduino u otro, a pesar de no haber grandes diferencias entre
ellos en cuanto a potencia eléctrica.
Otro parámetro importante es el número de entradas o salidas
digitales (Digital I/O Pins). Disponemos de 14 pines (o patillas) para
tal propósito; si nos fijamos, al lado de cada pin, este viene con una
referencia.

12
 Imagen 8. Pines digitales Arduino UNO

¿Qué quiere decir esto de entradas y salidas? ¿Y esto de

digitales? «Entrada» o «salida» hace referencia al modo de
funcionamiento de un pin. Si lo configuramos como una salida,
significa que podemos activar o desactivar una señal; serviría, por
ejemplo, para encender o apagar un led. Si, por el contrario, lo
configuramos como entrada, significa que podemos leer el valor de
una señal, por ejemplo, para saber si se ha pulsado un botón. El
término «digital» nos indica que, con ese pin, solo se puede trabajar
con dos estados: activado o desactivado.

Este tipo de señales nos limitan, ya que habrá una gran cantidad de
situaciones en las que, únicamente con dos estados, no podemos
evaluar una situación, como, por ejemplo, regular la velocidad de un
motor. Un motor tiene más de dos estados de trabajo, no solo
encendido o apagado, también podemos regular su velocidad; por lo
tanto, en muchos procesos necesitamos trabajar con otro tipo de
señales (las señales analógicas, como veremos).

Con este parámetro ya podemos seguir filtrando la elección de

nuestro Arduino. Si, por ejemplo, necesitamos conectar 30
pulsadores, el Arduino UNO no nos serviría, puesto que tan solo
dispone de 14 pines para tal propósito (es cierto que otros pines se
pueden configurar para tal comportamiento, como también veremos).

A continuación, si nos fijamos, nos dice que 6 de los 14 pines pueden

generar señales PWM («of which 6 provide PWM output») . En el
hardware de Arduino encontramos el símbolo ~, qué pines permiten
este tipo de comportamiento (aún así, por programación podríamos
generar este tipo de señales por otros pines, pero sería más
complejo).

Imagen 9. Señales PWM Arduino UNO

13
¿Qué es una señal PWM? Ahondaremos más en las señales PWM
en el capítulo correspondiente, pero, a grandes rasgos, es una señal
que nos permite variar el valor de una señal digital a lo largo del
tiempo, con lo que ya podemos regular, por ejemplo, la velocidad de
un motor o la luminosidad de un led.

Imagen 10. Señal PWM

En resumidas cuentas, si dado el caso, necesitamos regular, por

ejemplo, 10 motores, el Arduino UNO no sería la mejor elección, ya
que solo dispone de 6 pines.

Otro parámetro que hay que tener en cuenta es el número de

entradas analógicas. Estas entradas, a diferencia de las digitales,
permiten analizar más de dos estados; es decir, se tienen en cuenta
un amplio rango de valores posibles.

Imagen 11. Entradas analógicas Arduino UNO

14
 Imagen 12. Señales digitales/analógicas

Este tipo de entradas se pueden usar para la lectura de sensores, por

ejemplo: un sensor de temperatura que puede medir un rango de
entre 0º y 50 º, devolviendo una señal proporcional de entre 0 V y
5 V. En este caso, es necesaria una entrada analógica, si el sensor
nos devuelve 2,5 V significa que la temperatura que mide es de 25º.
Como podemos comprobar, esto solo es posible con una entrada
analógica y no con una digital, la cual no tiene en cuenta los valores
intermedios de entre 0 y 5 V, solo los extremos.
¿Y qué pasa si, en una entrada digital, la señal de entrada es
de 4, 3, 1,5 V? Las entradas digitales de un Arduino tienen un
margen de estado.

Imagen 13. Márgenes entrada digital

15
Como explicábamos, cabe la posibilidad de que a una entrada digital,
en vez de entrarle una señal con un valor de 0 o 5 V, le entre un
valor intermedio (2,2, 3, 4,8 V). Aún así, el Arduino nos daría uno de
los dos estados posibles: activado (5 V) o desactivado (0 V).

Con esta misma duda, realizamos diferentes pruebas y detectamos

que existen unos márgenes para cada estado: El estado de activado
comprendería valores de entre 2,5 y 5 V y, el estado de desactivado,
valores de entre 0 y 2,5 V.

Volviendo a las entradas analógicas, si, por ejemplo, queremos tomar

la lectura de 10 sensores, que como salida proporcionan una señal
analógica, el Arduino UNO no sería el indicado. Es necesario
puntualizar que las entradas analógicas pueden comportarse como
digitales si las configuramos con un programa. Con lo que, si fuese
necesario, contamos con 20 entradas o salidas digitales.

Hay que recalcar que no disponemos de salidas analógicas, no

podemos generar señales de, por ejemplo, 1.1, 4, 3,7 V, etc.
Disponemos de salidas PWM que se asemejan en funcionamiento a
estas.

Estos serían los aspectos básicos que hay que analizar en un Arduino.
Esto no quiere decir que haya muchos otros igual o más importantes,
por ejemplo: n.º de interrupciones, resolución de entradas
analógicas, Timers. No obstante, son conceptos más complejos que
es necesario trabajar antes con Arduino para luego tener la capacidad
de evaluarlos.

Vamos a acabar de analizar esta tabla, ya que aparecen datos

interesantes: nos indica unos valores (óptimos y límites) sobre la
tensión de alimentación y vemos que estos son superiores a 5 V.
Puede resultar extraño, puesto que vimos que el MCU opera a 5 V y,
en cambio ,lo puedo alimentar hasta un límite de 20 V.

Imagen 14. Alimentación externa

16
Muchos de los Arduinos incorporan un conector para alimentarlos a
través de una fuente de alimentación diferente al USB, para poder
alimentarlo con pilas, baterías o cargadores, por ejemplo. En el
diseño de algunas placas decidieron añadir esta solución, es decir, no
era imprescindible este conector con su electrónica correspondiente
para alimentar un Arduino. Sin embargo, resulta una funcionalidad
añadida muy útil para cuando queremos que nuestros proyectos no
estén conectados a nuestro PC o un cargador como el de un móvil.

Este añadido permite alimentar nuestro Arduino a más de 5 V, pero,

realmente, al MCU solo le van a «llegar» 5 V, gracias a la electrónica
de regulación que incorporan las placas de Arduino. Nos recomiendan
alimentar a través de este conector entre unos valores de 7 y 12 V,
siendo tensiones límite 6 y 20 V. Es importante ceñirnos a la tensión
que nos recomiendan. Si nos vamos a una tensión inferior a 7 V, y
debido al circuito de regulación, puede que no «lleguen» al MCU los
5 V que necesita, por lo que no funcionaría correctamente. Si nos
pasamos de 12 V, y según nos vayamos aproximando a los 20 V,
podemos notar que se puede llegar a calentar nuestro Arduino.

¿Alimento mi Arduino por USB o por el conector Jack? Es

indiferente, podemos alimentarlo por ambos puertos, el Arduino es
capaz de seleccionar en cada momento la mejor fuente de
alimentación.

Igual de importante es seleccionar el Arduino en cuanto a sus

limitaciones de potencia eléctrica, como la selección de la fuente de
alimentación (independientemente del punto de conexión USB o
Jack). Supongamos que nuestro sistema con Arduino incluido
consume 300 mA y cumpliendo las limitaciones eléctricas del Arduino,
pero no seleccionamos la fuente de alimentación adecuada y esta nos
ofrece solo 200 mA. El resultado sería el mal funcionamiento del
sistema, por lo que es importante pararnos a analizar los consumos
que pueda haber. Otro apartado nos dice que la intensidad límite por
el pin de 3,3 V es de 50 mA.

Imagen 15. Pines de potencia Arduino

17
Como hemos visto, todos los pines de la placa Arduino tienen
asociada una referencia. Explicábamos que la limitación de intensidad
para cada pin es de 20 mA, tanto sea de salida como de entrada, y es
cierto, pero existe un pin, el de 3,3 V, que permite aportar hasta
50mA.

En la tabla, podemos ver información sobre tres memorias, nos

vamos a parar a analizar la memoria Flash. Esta memoria es en la
que se almacena el programa que queremos que ejecute nuestro
Arduino. La información nos indica su capacidad de 32 Kb, pero nos
dice que 0,5 Kb están ocupados por el bootloader.

Bootloader es el programa que se conoce como el gestor de arranque

que se carga en nuestro Arduino antes de comprarlo. Por eso nos
dicen que la capacidad de la memoria del MCU es de 32 Kb, pero
0,5 Kb están ocupados. Debemos tenerlo en cuenta si decidimos
cambiar el MCU por otro comprado por separado, ya que no va a
traer cargado el gestor de arranque.

En resumen, como principiantes, lo que tendremos en cuenta de un

Arduino es:

• N.º de entradas/salidas digitales.

• N.º de señales PWM.
• N.º de entradas analógicas.
• Limitaciones de potencia eléctrica.

A continuación, realizaremos un recorrido por algunas de las

diferentes placas de las que dispone Arduino, comparándolas con el
Arduino UNO.

Imagen 16. Arduino Mega 2560

El Arduino Mega 2560 dispone de más entradas/salidas digitales y

mayor número de entradas analógicas.

18
 Imagen 17. Arduino NANO

Para el Arduino NANO, ya no nos serviría el mismo cable USB para

programarlo, puesto que cambia el conector USB. Dispone de más
entradas analógicas y el doble de intensidad de salida 40 mA.

Imagen 18. Arduino Micro

Al igual que ocurre con el Arduino NANO, necesitamos un cable USB

diferente que el que utilizamos para el Arduino UNO. Dispone de más
salidas para señales PWM y más entradas analógicas.

Imagen 19. Arduino DUE

Podemos considerar el Arduino DUE como uno de los que ofrece

mayor potencia de cálculo, es de los únicos que dispone de salidas
analógicas. Dispone de un mayor número de entradas/salidas
digitales y entradas analógicas.

Imagen 20. Arduino Mini

19
Su tamaño lo hace ser uno de los más pequeños y la principal
diferencia que encontramos con respecto al Arduino UNO es la falta
del hardware específico para poder programarlo. Necesitamos un
programador FTDI:

Imagen 21. Programador FTDI

Conectamos este programador a los pines adecuados del Arduino

Mini, lo programamos y, si no empleamos el puerto USB para ninguna
otra operación, podemos retirarlo y el Arduino quedará funcionando.

Imagen 22. Arduino Ethernet

Este Arduino supone un gran avance, puesto que incorpora un

periférico para la comunicación a través de Ethernet, lo que nos
permite establecer una conexión a internet y, además, incorpora un
conector para tarjetas micro SD, con lo que podemos registrar datos.

Imagen 23. Arduino YÚN

20
Este Arduino, además de una conexión a internet a través de
Ethernet, dispone de un módulo WIFI para una conexión inalámbrica.

Con el Arduino YÚN finalizamos el recorrido por las placas Arduino,

aún así hay que resaltar que existen muchas más. Vemos que las
grades diferencias entre Arduinos vienen en si incorporan periféricos.
¿Quiere esto decir que para una comunicación con una web,
por ejemplo, el Arduino UNO no vale? Sí que vale, podemos
ampliar las funcionalidades de un Arduino a través de módulos:

Imagen 24. Módulos

Con el análisis de la tabla de especificaciones técnicas finalizado, nos

podemos adentrar en el apartado de Documentation o explicación
detallada del producto, en el nos explicarán aspectos que, para
entenderlos, es mejor empezar a programar y, llegado el momento,
los analizaremos. Lo que sí es importante de esta sección son los
archivos que pone a nuestra disposición:

Imagen 25. Archivos de diseño

En la definición de ¿qué es Arduino? nos referíamos a él como una

plataforma libre, educativa y de desarrollo. Ya que acabamos de

21
analizar el hardware, vemos que este elemento de la plataforma
Arduino es libre.

Disponemos de toda la información del diseño de las placas de

Arduino a través de los archivos que ponen a nuestra disposición.
Podemos estudiarlas, modificarlas o distribuirlas. Con Arduino, surge
un concepto interesante como es el de hardware libre, esto era más
propio del software, el caso más conocido es el de GNU Linux.

Por eso podemos encontrar Arduinos por apenas 6-7 euros; al

disponer de libertad de distribución, no solo los fabricantes oficiales
de Arduino fabrican y distribuyen sus modelos, sino que otros
fabricantes pueden distribuir sus propios Arduinos con o sin
modificaciones.

Software Arduino

Una vez que disponemos de nuestro Arduino lo conectamos a nuestro

PC y empezamos a desarrollar nuestro programa. Para ello,
necesitamos un entorno de programación. Arduino dispone de un
entorno de programación integrado (conocido como IDE de Arduino).
A partir de ahora, nos referiremos a este entorno de programación
como IDE de Arduino.

El IDE de Arduino es un entorno multiplataforma, lo podemos instalar

en cualquier sistema informático (Windows, Mac Os, Linux). Este
entorno nos permite escribir un programa, verificarlo (comprobar
errores) y cargarlo a nuestro Arduino. Dispone de una herramienta
como es el Monitor Serie que permite recibir o enviar información a
través del puerto USB de nuestro PC. Si, por ejemplo , programamos
nuestro Arduino para que, cuando reciba un mensaje por el puerto
USB que ponga «encender leds», debe encender los leds que tenga
conectados a sus salidas, a través del Monitor Serie, podemos enviar
el mensaje «encender leds». Entonces, si programamos
adecuadamente el Arduino, podemos controlarlo a través del IDE.

El Monitor Serie también permite mostrar información que reciba por

el puerto USB del PC. Si, por ejemplo, programamos nuestro Arduino
para que tome las lecturas de unos sensores, a los cuales esté
conectado, y que envíe esos valores por el puerto USB, podemos
visualizarlos en el IDE de Arduino. Por lo tanto, también podemos
decir que, con el IDE, podemos monitorizar un Arduino. Y, por
supuesto, con la programación adecuada, podemos controlar y
monitorizar nuestro Arduino simultáneamente.

Además del Monitor Serie, disponemos de un creador de gráficas que

nos permite graficar datos que recibamos por el puerto USB de

22
nuestro PC. También disponemos de ejemplos y librerías para que
nos sea más sencillo aprender a programar. Las librerías que tiene
instaladas son las oficiales. ¿Qué es una librería? El término de
«librería» viene de la mala traducción de library («biblioteca») , pero
hace referencia a un programa que tenemos o podemos tener
instalado en nuestro IDE, que podemos usar en cualquier momento.

Por ejemplo, queremos programar un módulo, pero su programación

es muy compleja y realmente queremos hacer una serie de funciones
simples. Si instalamos la librería adecuada en nuestro IDE, esta
dispone de un programa con una serie de funciones (con una
programación compleja) que pone a nuestra disposición para que las
utilicemos y no tengamos que realizar un programa tan complejo.

¿Un Arduino solo se puede programar con el IDE de Arduino?

¿El IDE de Arduino solo puede programar Arduinos? No,
podemos programar un Arduino con otro entorno de programación
siempre y cuando sean compatibles. Si tenemos práctica con un
entorno de programación determinado podemos comprobar si es
posible programar con ese software nuestro Arduino, seguramente
necesitemos instalar alguna extensión. Y con el IDE de Arduino pasa
lo mismo, con las extensiones correctas podemos programar otros
módulos.

Antes de continuar, el IDE de Arduino tiene su origen en otro entorno

de programación, Processing. Processing es un entorno de
programación libre enfocado para artistas, diseñadores… Personas
con un perfil creativo que necesitan digitalizar sus trabajos, pero que
carecen de conocimientos para eso. Processing nace como una
herramienta para dar una solución a esta necesidad, orientada a
todos aquellos sin conocimientos de programación.

Han logrado su propósito gracias a un entorno y un lenguaje de

programación intuitivos. Este entorno no solo es interesante por ser
del cual parte el IDE de Arduino (de hecho, basta con abrir los dos
entornos para encontrar las similitudes), sino por permitir crear una
interfaz para controlar y monitorizar un Arduino a través de un puerto
USB.

23
 Imagen 26. Interfaz Processing

Para comprar un Arduino, podemos hacerlo a través de la web oficial

o distribuidores de material electrónico. El IDE de Arduino lo podemos
descargar directamente de su web:
https://www.arduino.cc/en/Main/Software .

Este elemento de la plataforma Arduino también es libre. Podemos

instalar este entorno en cualquier sistema operativo
(multiplataforma), lo podemos utilizar para cualquier propósito
(programar Arduinos u otros sistemas), podemos estudiar su diseño
(acceso al código fuente) y podemos distribuir copias.

Lenguaje de programación

Con nuestro Arduino conectado al PC y el IDE instalado, solo nos falta

empezar a programar. En cuanto al lenguaje de programación
(idioma artificial diseñado para expresar instrucciones que pueden ser
llevadas a cabo por una máquina), podemos diferenciar varios
niveles. El lenguaje a más bajo nivel sería el lenguaje máquina, es el
lenguaje capaz de almacenar e interpretar una máquina, en nuestro
caso, un MCU.

En los inicios de los MCU, estos se programaban en lenguaje máquina

(a día de hoy también se hace). El lenguaje máquina consiste en
instrucciones simples, lo que nos obliga a encadenar una cierta
cantidad de ellas para poder realizar tareas sencillas. Además, cada
máquina puede tener su propio lenguaje.

Con este lenguaje de programación surgen ciertos inconvenientes:

primeramente, un mismo programador debe aprender un lenguaje
diferente para cada máquina. Por lo general, no son lenguajes

24
intuitivos (lo que los hace difíciles de recordar) y programas sencillos
pueden llegar a alcanzar un gran tamaño.

Un programa desarrollado en lenguaje máquina se convierte en difícil

de interpretar y modificar. Viendo todo esto, se empezó a evolucionar
en la programación hasta llegar a lo que conocemos a día de hoy
como lenguaje a alto nivel.

Existen varios lenguajes a alto nivel: C, Python, C++, Java… El

lenguaje a alto nivel está formado por instrucciones más complejas
que el lenguaje máquina, lo que significa que una instrucción en este
lenguaje puede equivaler a varias en lenguaje máquina.

Ilustración 27. Lenguaje a alto nivel y máquina

Con esto conseguimos programas más cortos, más fáciles de

interpretar y modificar. El lenguaje a alto nivel que emplea el IDE de
Arduino se basa en el lenguaje C, aunque es cierto que la mayoría de
los lenguajes comparten estructuras o funciones similares, como
pueden ser los bloques de control de flujo de programa (if, esle,
while). A parte del lenguaje compartido con C, dispone de
instrucciones propias para un Arduino.

¿Solo puedo programar un Arduino en lenguaje a alto nivel?

No, podemos programar en el IDE de Arduino con el lenguaje que nos
encontremos más a gusto; de hecho, podemos mezclar ambos
lenguajes.
Antes de cargar un programa, el IDE comprueba que no haya errores
de escritura a lo largo de él; una vez comprobado que no contenga
errores, «traduce» todo aquel lenguaje que no sea máquina al
lenguaje máquina que entienda el MCU.

25
Por lo tanto, aunque nosotros programemos en lenguaje a alto nivel,
ese no será el programa que realmente se cargue en la memoria de
programa del MCU, sino su «traducción» al lenguaje máquina
correspondiente, posibilidades:

• Solo lenguaje a alto nivel: se «traduce» y carga al MCU.

• Solo lenguaje máquina: no se «traduce».
• Mezcla máquina y alto nivel: solo se «traduce» el de alto nivel.

Con el lenguaje de programación descrito, acabamos de ver qué es

Arduino y comprobamos que, sin cualquiera de los tres elementos
que lo forman, no sería posible trabajar con él. Vemos que Arduino
nos elimina una gran cantidad de obstáculos a la hora de empezar el
desarrollo de un sistema.

Historia y filosofía de Arduino

Hemos visto en el capítulo anterior qué es Arduino y nos hemos
hecho una idea del trabajo y tiempo que nos ahorra. Es importante
conocer cómo y para qué surgió Arduino.

Arduino nace en el año 2005 en el Instituto Interactivo Ivrea (Italia).

En este centro, se dedicaban al estudio de la forma, en cómo
interactúa el ser humano con la tecnología.

En el capítulo anterior, definimos todas las tareas que debíamos

realizar de no contar con un Arduino. La tecnología de la que
disponían no era precisamente versátil, no agilizaba el aprendizaje
como lo hace Arduino.

A todo esto hay que añadirle el aspecto económico, la tecnología de

la que disponían podía llegar a los 80 euros. Viendo todo esto,
podemos imaginarnos que no disponían de una herramienta que
incentivase o motivase al alumnado a desarrollar sus propias ideas.

Decidieron empezar con el proyecto de Arduino parte del profesorado

(no solo del centro) y parte del estudiantado. Al poco de empezar,
tenían la sospecha de que el centro iba a cerrar y, con el temor de
que el proyecto de Arduino quedase en el olvido, decidieron compartir
su trabajo en internet (lo que ha sido un paso importantísimo para
que Arduino sea lo que es hoy en día).

El proyecto empezó a crecer con la colaboración de una gran cantidad

de personas; los fundadores de Arduino reconocen que Arduino es el
trabajo de mucha gente. Esta es la gran ventaja de Arduino:
alrededor de este proyecto se ha generado una gran comunidad muy
activa que siempre está compartiendo ideas y aportando soluciones.

26
A través de la web de Arduino se crean foros sobre cualquier
temática, no solo para aportar ideas sino para solucionar dudas que
puedan tener otras personas usuarias. Sin embargo, no solo a través
de la web de Arduino se comparte este proyecto, disponemos de una
gran cantidad de webs, blogs, vídeos tutoriales dedicados a Arduino.

Los objetivos de Arduino consistían en desarrollar un sistema

económico que no costase más que un libro y que hiciera que
personas sin conocimientos de programación, pero con ansias de
aprender y desarrollar, pudiesen tener la herramienta que
necesitaban, y podemos asegurar que lo han conseguido. En el
siguiente capítulo, veremos si realmente el hecho de ser un proyecto
colectivo es una ventaja o una desventaja.

¿Qué podemos hacer con Arduino?

Lo que podamos hacer con Arduino dependerá en gran medida de

nuestra imaginación y capacidad. No obstante, apoyándonos en su
gran comunidad, en la tecnología de la que disponemos y otras
plataformas, veremos que, cada vez, tendremos menos límites. Por lo
tanto, en este capítulo no se verá tanto qué podemos hacer con
Arduino, sino lo fácil que puede llegar a ser hacer algo con Arduino.

Al controlar un proceso con un Arduino, no solo estamos trabajando

con este hardware sino que necesitamos conectarnos a sensores,
módulos... Arduino presenta una gran ventaja para todas aquellas
personas con inquietudes por desarrollar, aportándoles todas las
facilidades que hemos visto en el primer capítulo. ¿Qué pasaría si
no existiesen sensores o módulos fáciles de usar? Que todas las
soluciones que aporta Arduino se pueden ver en cierto modo
limitadas, para las personas que están empezando.

Para una persona inexperta en programación o electrónica ¿de qué

le sirve que Arduino sea relativamente sencillo de usar si, a la
hora de implementarlo con otros componentes, estos son
difíciles de programar o de conectar? Perdemos parte de la
agilidad de Arduino. Si soy un desarrollador y fabricante de tecnología
y Arduino amplía el uso de sistemas electrónicos a una comunidad
que antes nunca los utilizaría, posiblemente me plantee cómo adaptar
mi tecnología para hacerla igual de accesible que Arduino y así
introducirme en ese mercado. Tenemos a nuestro alcance toda una
serie de sensores o módulos con los que podemos empezar a trabajar
de forma sencilla.

27
 Imagen 28. Módulos Arduino

Lo que no quiere decir que no nos podamos ir a otros sistemas más

cerrados, dependerá de nuestras necesidades y posibilidades.

Tenemos nuestra plataforma Arduino y toda una serie de tecnología

desarrollada con el mismo enfoque, pero ¿sin conocimientos,
puedo llegar a usar, por ejemplo, un sensor ultrasonidos? Aquí
entra en función la Comunidad Arduino, debemos tener en cuenta
que, posiblemente, lo que nosotros queremos hacer con un Arduino
ya lo ha hecho otra persona y, posiblemente, haya puesto a
disposición nuestra toda la información necesaria.

Sin embargo, quizás no disponemos de la solución exacta; tampoco

debe ser un gran problema, al fin y al cabo, el llegar al diseño de un
sistema no es más que la unión de pequeñas soluciones, debemos ser
capaces de dividir nuestro problema en pequeñas partes e ir
solucionando poco a poco.

Por ejemplo, nos podemos plantear diseñar el sistema de seguridad

de nuestra casa. Con unos sensores de movimiento que, cuando está
activada la alarma y detecten movimiento, con un módulo de
telefonía me envíe un mensaje al móvil. Puede que no encontremos
la solución exacta, pero seguro que encontramos la solución de cómo
trabajar con esos sensores y, por otro lado, encontramos la solución
de cómo enviar mensajes con un módulo de telefonía y Arduino. Lo
primero será probar esas soluciones y luego juntarlas y
conseguiremos diseñar nuestra alama.

Por lo tanto, disponemos de una tecnología igual de accesible que

Arduino e información para usarla, pero ¿realmente cualquier
persona que empiece con Arduino será capaz de interpretar
esa solución? Comprobémoslo.

28
Queremos conocer la temperatura y humedad de una sala de
calderas, no tenemos más que irnos a nuestro navegador web y
realizar la búsqueda adecuada.

Imagen 29. Búsqueda información

Encontraremos una gran cantidad de páginas que tratan sobre cómo

solucionar esto con un Arduino. Por lo general, nos empezarán a
describir el entorno al que nos enfrentamos.

Con esta presentación del problema que queremos solucionar, nos

propondrán una solución con un sensor en concreto, indicándonos sus
prestaciones y características. En este momento, quizás ya
evaluamos si, en función de lo que necesitamos, ese sensor nos sirve.

Si fuese así, continuamos: lo primero que nos mostraría sería cómo

conectarlo a nuestro Arduino con un esquema como el siguiente.

Imagen 30. Conexión sensor

Como podemos apreciar en la imagen anterior, se trata de un

esquema sencillo de interpretar.

Prácticamente cualquier esquema de conexionado de un Arduino

aparecerá descrito gráficamente con este estilo, con más o menos

29
componentes, pero en este formato. Por lo tanto, el conectar
cualquier componente siguiendo este tipo de esquemas no va a
suponer un inconveniente.
Si necesitamos algún componente a mayores, como es este caso, nos
aparecería reflejado en la información.

Acabamos de conectarlo sin saber nada sobre electrónica, nos falta

programarlo, pues lo más seguro es que pongan a nuestra disposición
un programa y nos digan qué solución nos aporta ese programa.

Imagen 31. Programa ejemplo

En este caso, visualizaríamos la temperatura y humedad que está

midiendo ese sensor en nuestro PC.

Si fuese la solución que buscásemos, lo acabamos de lograr sin saber

ni programación ni electrónica, simplemente siguiendo el esquema
visto en la imagen 30, copiando y pegando el programa anterior en
nuestro IDE y cargándolo al Arduino. Aunque esta no sea la solución
que buscamos, podemos partir de ella y modificarla hasta llegar a lo
que necesitamos, por lo menos tenemos algo de lo que partir.

30
¿Disponemos de todo tipo de sistemas electrónicos como el
que acabamos de ver? Si, disponemos de todo tipo de sistemas
que necesitemos.

Al disponer de todas estas herramientas, conseguimos interactuar de

una forma diferente con la tecnología. Por ejemplo, como podemos
comprar módulos de pantallas táctiles y módulos de telefonía,
podríamos montar un móvil con unas ciertas funcionalidades.
Lo que nos permite todo esto es entender mejor lo que nos rodea,
porque nos podemos imaginar cómo lo haríamos nosotros mismos
con un Arduino, por eso el título de este libro es: Arduino.
Entendiendo el Mundo.

Para finalizar este capítulo, veremos cómo con otras plataformas

podemos seguir ampliando nuestros conocimientos y, por ende, las
soluciones que podemos realizar con un Arduino.

Otras plataformas

App Inventor es una plataforma de desarrollo de aplicaciones muy

interesante. Es una plataforma de Google desarrollada por el MIT; al
igual que Arduino, pretende acercar, abrir o simplificar la tecnología
que nos rodea. En este caso, sería el desarrollo de aplicaciones
mediante una herramienta de programación por bloques.

Dispone de una gran comunidad, al igual que Arduino; resaltamos

esta herramienta porque puede llegar el momento en el cual
necesitemos controlar o comunicar nuestro Arduino con una
aplicación, encontraremos una gran cantidad de casos prácticos de
cómo hacer esto con App Inventor.

Al aprender a programar un Arduino, todos los conocimientos que

adquiramos son perfectamente adaptables a App Inventor. La
diferencia radicará más en el modo de programar que en la
programación en sí: mientras que en un Arduino escribimos el
programa, en App Inventor juntamos bloques para crear nuestro
programa, al igual que haríamos al unir las piezas de un puzle.

En cuanto empecemos a profundizar en Arduino, cada vez nos

plantearemos proyectos de mayor envergadura y pronto nos
encontraremos con la necesidad de vincular nuestros proyectos a
internet. Como se suele conocer IoT, el internet de las cosas, ¿será
difícil gestionar procesos a través de internet con un Arduino?
¿Necesitaré conocimientos de protocolos como http? ¿De
programación web o de servidores web? No necesariamente, si
por nuestra formación tenemos conocimientos sobre estas áreas,
podemos implementar todos esos conocimientos sobre Arduino o,
incluso, si los quiero aprender, Arduino sigue siendo la plataforma

31
ideal. No es necesario, puesto que disponemos de herramientas que
nos van a facilitar este tipo de programación.

Una de esas herramientas es ThingSpeak, nos va a permitir controlar

y monitorizar nuestro Arduino a través de la web sin necesidad de
programación web, simplemente accedemos a la página de
ThinsgSpeak, nos registramos y configuramos siguiendo unos pasos
muy sencillos un panel de control (con botones , sliders…) y, como es
obvio, necesitamos programar nuestro Arduino, disponemos de
programas de ejemplo. Y siempre tenemos la opción de modificar ese
programa para llegar a la solución que necesitemos.

Por último, quizás necesitamos almacenar datos en la nube.

Disponemos de una herramienta similar a la anterior: aRest nos
permite almacenar datos y graficarlos sin necesidad de programación
alguna, simplemente siguiendo una serie de pasos, configurando el
sistema de forma sencilla. Y, al igual que ThingSpeak, tenemos
programas de ejemplo.

Como resumen de este capítulo, podemos decir que no solo

disponemos de Arduino, sino de una serie de tecnologías y
plataformas para realizar todo tipo de proyectos, apoyándonos en
toda la información y casos prácticos que encontramos en internet.

Introducción
Como hemos visto, Arduino es algo más que un hardware, está
formado por un software y un lenguaje de programación. Además, en
ciertos casos, necesitaremos conocimientos sobre electrónica.

Como formador sobre la plataforma Arduino, encontramos un

pequeño vacío en el aprendizaje de Arduino. En un principio, puede
llegar a ser un poco caótico, vemos que podemos hacer tantas cosas
que es difícil centrarnos y adquirir una base sólida para luego afrontar
cualquier reto. Por este motivo surgió la decisión de escribir una serie
de libros (según el grado de conocimiento).

El objetivo de este libro no es simplemente aportar los primeros

conocimientos, sino mostrarlos de una forma lógica y ordenada; es
decir, no tendremos un capítulo sobre todo el hardware de Arduino,
otro sobre todos los principios de la electrónica que necesitemos, otro
sobre todo el lenguaje de programación y otro sobre el IDE de
Arduino.

32
Lo que busca este libro es que, a través de casos prácticos,
adquiramos conocimientos en paralelo sobre cada una de estas áreas.
Los casos irán creciendo en dificultad para ir exigiéndonos más
conocimientos sobre alguna de ellas.

Por ejemplo, empezaremos viendo como encender un led; en ese

primer caso, veremos las leyes básicas sobre la electrónica para
poder entender el circuito que montemos, analizaremos simplemente
la parte del hardware de Arduino que usaremos. Asimismo, como
será la primera vez que trabajemos con el IDE de Arduino, veremos
las características necesarias de este para realizar el programa y lo
mismo haremos con la programación.

Por lo tanto, la intención de este libro es que su lectura sea lineal, en

la cual no sea necesario saltar a otros capítulos con temáticas
diferentes para entender lo que se está haciendo.

Lo recomendable para el buen uso de este libro es disponer del

material necesario para poder realizar todos los casos, puesto que
para aprender la mejor forma es practicar.

Materiales Unidades
Protoboard 1
Arduino UNO 2
Resistencias 330 ohmios 4
Led 2
Potenciómetro 1k 1
Pulsadores 2
Cables protoboard 20

33
Primeros Pasos

Pines digitales: salida

Imagen 32. Solución para encender led

En la imagen anterior, se muestra la solución para poder encender un

led a través de un Arduino. Como es la primera vez que trabajamos
con la plataforma Arduino, necesitaremos definir los conceptos
básicos que necesitamos para entender esta solución.

En cuanto al Arduino, es la primera vez que vamos utilizar los pines

digitales. Como ya hemos visto en capítulos anteriores, estos pines
pueden comportarse como salidas (por ejemplo, para poder
encender/apagar un led) o como entradas (por ejemplo, para
conectar un pulsador y comprobar su estado). En este caso, para
poder encender un led, debemos configurar el pin como salida.

Imagen 33. Potencia eléctrica de los pines

Debemos tener en cuenta el límite de potencia eléctrica de cada uno

de los pines del Arduino para no dañar el MCU.

34
 Tenemos que recordar que el límite de 20 mA no significa que no
pueda «salir» más intensidad por el pin, sino que, por criterios de
seguridad, no debe salir más.
El primer elemento con el cual vamos a trabajar es una resistencia,
según la RAE:

• Resistencia:
«Elemento que se intercala en un circuito para modificar el paso de la
corriente o para producir calor»

En función del valor de una resistencia (ohmios), se opondrá más o

menos al paso de la corriente eléctrica; por lo tanto, una resistencia
nos va ha permitir proteger elementos de nuestro sistema frente a
intensidades que los puedan dañar.

El valor de las resistencias viene definido por un conjunto de bandas y

colores

Color 1.ª banda 2.ª banda Multiplicadora Tolerancia

Negro - 0 x1
Marrón 1 1 x10 1%
Rojo 2 2 x100 2%
Naranja 3 3 x1000
Amarillo 4 4 x10000
Verde 5 5 x100000 0,05%
Azul 6 6 x10000000
Violeta 7 7 -
Gris 8 8 -
Blanco 9 9 - 5%
Dorado x0.1 10%
Plata x0.01 20%

35
Hasta ahora, hemos hablado de tensión e intensidad sin definir estos
términos. Vamos a explicarlos a través de un caso práctico.

Según la RAE:

• Tensión:
«Voltaje con que se realiza una transmisión de energía eléctrica»;
«Voltaje entre dos polos o electrodos».

• Intensidad:
«Magnitud física que expresa la cantidad de electricidad que atraviesa
un conductor en la unidad de tiempo, y cuya unidad en el sistema
internacional es el amperio».

Quizás no queda claro, pongamos un ejemplo:

Imagen 34. Tensión e intensidad

El voltaje (unidad de medida: voltios), también conocido como

tensión, diferencia de potencial o caída de tensión, es uno de los
conceptos básicos de la electricidad.

Podemos considerar el voltaje como una fuerza, más bien como una
diferencia de fuerzas. Si la pila por un extremo me aporta un fuerza
de 9 V y, por el otro, una fuerza de 0 V, la fuerza resultante, si nos
conectamos a los dos polos de la pila, es la diferencia de ambas
fuerzas (9-0); por lo tanto, la tensión de la pila es de 9 voltios.

36
 Imagen 35. Tensión

Entonces podemos asegurar que la tensión aplicada a la resistencia

también es de 9 voltios.

Imagen 36. Tensión

La intensidad (unidad de medida: amperios), es la cantidad de carga

eléctrica que circula por un cuerpo en un determinado momento.

Para que circule intensidad, se deben cumplir varias condiciones: la

primera es que ese cuerpo se encuentre sometido a una diferencia de
potencial; la segunda condición debe ser que por el material que
circule sea un conductor.
Como podemos ver en la imagen anterior, la intensidad, al igual que
la tensión, tienen un sentido (representado por las flechas).

37
 Imagen 37. Inversión conexión

Si invertimos la conexión de la resistencia con la pila, también se

invierte el sentido de la tensión e intensidad. El sentido de la tensión
va siempre de la fuerza más grande (en este caso, 9 voltios) a la
fuerza más pequeña (en este caso, 0 voltios). El sentido de la
intensidad es el mismo que el de la tensión.

Por último, es necesario tener en cuenta la Ley de Ohm, para poder

cuantificar los valores de tensión e intensidad en un circuito.

V(tensión) = I(intensidad)*R(resistencia)
V = I*R
V(voltios) = I(amperios)*R(ohmios)

Volviendo a la imagen 36, si queremos conocer la intensidad que

circula por la resistencia, suponiendo que esta tiene un valor de
100 ohmios, debemos despejar la variable I:

IR = V(de la resistencia)/100
IR = 9/100
IR = 0.09 amperios
Con estos conceptos básicos de electrónica, podemos empezar a
trabajar con nuestro Arduino.

38
 Imagen 38. Salida Arduino

Si configuramos alguno de los pines como salida, podemos aportar

5 V, pero será necesario cerrar nuestro circuito con alguno de los
pines GND, para poder ejercer esa diferencia de fuerzas al igual que
una pila.

Con todo lo que sabemos, ya podemos asegurarnos de no superar el

límite de 20 mA de intensidad si conectamos la resistencia adecuada.

De la ecuación de la ley de Ohm debemos despejar el valor de la

resistencia:
V(tensión) = I(intensidad)*R(resistencia)

R = 5 V/0,02 = 250 ohmios

En conclusión, si conectamos una resistencia de un valor mínimo de

250 ohmios, nos aseguramos de no superara el límite de 20 mA. A
partir de este punto y a menos que se indique, emplearemos
resistencias de 330 ohmios.

A continuación, necesitamos conectar un led. Un led es un tipo de

diodo especial. Los diodos tienen una gran cantidad de usos y
características, por lo que no ahondaremos demasiado en ellos,
simplemente veremos lo necesario para este caso.

Imagen 39. Diodo led

39
Como indicamos, un led es un diodo especial, que emite luz al
circular corriente eléctrica a través de él. Dispone de dos patillas: una
más grande (ánodo) que la otra (cátodo). Debemos conectar el diodo
conforme circule corriente de ánodo a cátodo.

Imagen 40. Circuito led

En la imagen anterior, vemos cómo se realizaría la conexión entre un

led, una pila y una resistencia. Ya podemos realizar las conexiones en
nuestro Arduino. Si nos fijamos en la imagen anterior, conectamos
directamente los cables a las patillas de los componentes, esto no nos
sería sencillo, por lo que vamos a utilizar una protoboard.

Imagen 41. Protoboard partes

Una protobard es como un panel para poder realizar conexiones a

través de sus puntos, distinguimos varias partes en función del modo
de conexión interno de los puntos: una parte superior e inferior
(recuadros azules) en la cual todos los puntos de una misma fila está
conectados entre sí; dos partes intermedias (recuadros verdes) en las
que los puntos de una misma columna están conectados entre sí. En
la siguiente imagen, se observan las conexiones más claramente.

40
 Imagen 42. Conexión puntos protoboard

En la parte media nos encontramos una ranura que separa cada

columna en dos partes, las cuales son independientes entre sí.

Imagen 43. Circulación de corriente por el circuito

Por último, otro elemento de hardware que interviene en este caso es

el conector USB.

Imagen 44. Conector USB

Este puerto no solo permite disponer de un elemento físico para

conectar nuestro Arduino al PC y programarlo, permite alimentar
nuestro Arduino y restantes componentes del sistema (en este caso,
el led). La potencia de la que disponemos al alimentar un Arduino por
USB sería de 5 V y 500 mA. Si se supera la demanda de intensidad se
corta la conexión hasta que se restablezcan las condiciones eléctricas
adecuadas.

41
Sabemos ya que, si entre nuestro Arduino y el resto de componentes
que usemos, superamos los 500 mA en consumo, la alimentación por
USB no sería la adecuada.

Con todo lo que sabemos sobre el circuito y el Arduino, podemos

empezar a programar. Para ello debemos descargar el IDE de Arduino
(https://www.arduino.cc/en/Main/Software); seleccionamos el
archivo correspondiente al sistema operativo de nuestro PC.

Nos encontramos con un entorno, sencillo sin una gran cantidad de

menús ni botones. Analizaremos lo indispensable de este entorno
para poder realizar un programa que encienda un led, así como
definir las normas y pautas que debemos seguir a la hora de usarlo
correctamente.

Imagen 45. IDE de Arduino

Podemos dividir el IDE de Arduino en cuatro partes: barra de menú,

barra de botones, desarrollo programa y consola. En la barra de
menú, disponemos de diferentes opciones que, según sea necesario,
iremos descubriendo.

42
Lo primero que debemos hacer es irnos al apartado de herramientas
y asegurarnos de tener seleccionada la placa que usemos en cada
momento. Esto es importante para que el IDE realice las operaciones
necesarias y se asegure de cargar correctamente el programa.

Imagen 46. Seleccionar Arduino

Disponemos de todos los Arduinos para indicar en cada momento con

cuál estamos trabajando, también podremos descargar extensiones
para programar otros sistemas y deberemos indicarlo en este
apartado (imagen 46).

Imagen 47. Comprobar si detecta Arduino

Antes de empezar a programar, comprobaremos si el IDE reconoce

que el Arduino está conectado al PC. No solo debe detectarlo, sino
que debe estar seleccionado.

Este segundo paso lo suele hacer de forma automática el IDE de

Arduino, pero si nos encontramos con problemas a la hora de subir
nuestro programa, podemos asegurarnos de que el IDE ha detectado
el Arduino.

43
Empecemos a programar: para ello, nos vamos a la parte de
desarrollo de programa; es importante conocer la estructura de un
programa y las normas que debemos seguir a la hora de programar.

Imagen 48. Esquema básico de un programa

Al abrir el IDE, nos genera un documento con unas pocas líneas del
programa ya escritas. Si nos situamos antes del void setup(){ y
pulsamos la tecla Enter, vemos que, al igual que en un documento
Word, crearemos un campo en blanco cada vez más grande. Puede
ser todo lo grande que queramos, los espacios en blanco no influyen
en el programa.

Este espacio en blanco está dedicado para la declaración de variables,

librerías, constantes. De momento no le daremos uso.

Imagen 49. Void loop y setup

El apartado de void setup(){ } es la parte del programa que se

ejecuta una única vez con cada encendido del Arduino o reseteo.

44
Una vez finalizada su ejecución «salta» al void loop para ejecutar lo
que haya entre llaves de forma continua.

En ambos casos, el programa se ejecuta de forma secuenciada desde

la primera instrucción hasta la última. La diferencia es que el loop al
finalizar la última instrucción vuelve a ejecutar la primera y se vuelve
a repetir este proceso una y otra vez.

Antes de empezar a programar debemos tener en cuanta ciertas

normas:

• El IDE de Arduino distingue mayúsculas de minúsculas, por lo

tanto, debemos fijarnos a la hora de escribir una instrucción si
se escribe en mayúsculas o minúsculas (cada una de sus
letras).

• No son necesarias tabulaciones, no es obligatorio separar las

instrucciones del margen izquierdo del IDE, pero si
recomendable, sobre todo cuando veamos instrucciones de
control de flujo, para estructurar el programa adecuadamente.

• La mayoría de las instrucciones acaban en ;, de no hacerlo y al

tratar de cargar el programa a nuestro Arduino, el IDE no nos
lo va ha permitir y nos mostrará un error. El punto y coma
permite que el IDE diferencie cuándo empieza y acaba una
instrucción; si nos lo saltamos, juntaría una o más
instrucciones, las evaluaría como si fuesen una y nos daría un
error diciéndonos que no reconoce esa instrucción.

• Es obligatorio que un programa contenga los dos campos

básicos de void setup y void loop.

Si nos fijamos, al abrir un archivo nuevo para empezar a crear

nuestro programa, hay más líneas de código que las de void loop y
void setup:

45
 Imagen 50. Comentarios

Dentro del setup y loop, encontramos dos líneas de código que

empiezan por //. Estas líneas son comentarios. Es importante
comentar nuestros programas, un comentario sirve para hacer
aclaraciones o explicaciones a lo largo del programa. Esto nos va ha
permitir que, por ejemplo, si hacemos un programa y, dentro de un
año, lo queremos modificar, nos va ha resultar más sencillo
interpretarlo con comentarios que sin ellos y, por lo tanto, poder
modificarlo.

Podemos hacer tantos comentarios como queramos, no va ha influir

en el tamaño del programa que finalmente se cargue al Arduino. El
IDE de Arduino evalúa qué líneas del programa son comentarios y
cuáles no, las que sean comentarios no las va ha tener en cuenta a la
hora de enviarlas al Arduino.

Podemos hacer dos tipos de comentarios: de una sola línea o

multilínea. Podemos hacer comentarios en cualquier parte del
programa.

Imagen 51. Comentarios multilínea y una sola línea

Como sabemos, los pines se pueden comportar como entradas o

salidas, por lo que necesitamos una instrucción para configurar el
comportamiento de los pines.

46
pinMode(param1,param2);

Vemos que, entre paréntesis, esta instrucción necesita dos

parámetros: el primero hace referencia al pin que queremos
configurar y, el segundo, al modo de configuración
(entrada/salida).

• Pin 13 como salida: pinMode(13,OUTPUT);

• Pin 13 como entrada: pinMode(13,INPUT);

¿Es necesario configurar todos los pines? No, solo los que
utilicemos. Antes de seguir, vamos a explicar un poco el sistema
binario, lo que nos va ha permitir entender mejor lo que estamos
haciendo.

El sistema binario es un sistema de numeración en el que solo existen

dos números: 0 o 1. Todos los sistemas informáticos trabajan con
sistemas binarios. ¿Qué estamos haciendo realmente con la
instrucción pinMode(param1,param2)? El MCU del Arduino
internamente trabaja con ceros y unos, el MCU dispone de unos
registros para realizar configuraciones. Lo que nosotros estamos
haciendo con la instrucción pinMode es escribir un valor determinado
en esos registros.

Imagen 52. Escritura registros

47
Imaginemos un registro como si fuera un celda, en la cual solo puede
haber dos valores posibles, 0 o 1, lo que estamos haciendo entonces
con la instrucción pinMode es ir a ese registro y escribir un 0 (INPUT)
o 1 (OUPUT). Es importante recalcar que, en una celda, siempre tiene
que haber un valor, bien sea 0 o 1; no es posible que una celda se
encuentre vacía. Cada vez que se enciende o resetea el Arduino,
estos registros se ponen a un valor por defecto, es trabajo del
programador cambiar el valor de los registros que sean necesarios.

Conocer el sistema binario nos va ha permitir entender mejor lo que

estamos haciendo y, llegado el momento, entender el porqué de
muchos problemas que nos encontremos. El sistema binario es
complejo, pero según surja la posibilidad de ampliar conocimientos
sobre él, lo haremos.

Ya sabemos configurar un pin, el hecho de configurarlo como una

salida para que encienda un led no significa que se vaya encender,
significa que podemos encenderlo o apagarlo, debemos ser nosotros,
a la hora de programar, los que definamos cuándo debe encender o
apagar el led. Para ello, disponemos de otra instrucción.

digitalWrite(param1,param2);

Al igual que pinMode, dispone de dos parámetros, el primero

para indicar sobre qué pin estamos realizando la operación y el
segundo para señalar si queremos que se active o no.

• Activar salida 13 digitalWrite(13,HIGH);

• Desactivar salida 13 digitalWrite(13,LOW);

Al igual que ocurría con pinMode, con digitalWrite estamos

escribiendo en el registro correspondiente un 0 o un 1. Por defecto
tiene un cero, por lo tanto, si no lo cambiamos, no se encenderá el
led. Vamos al IDE de Arduino y programamos las instrucciones que
hemos visto.

48
 Imagen 53. Primer programa Arduino

Lo primero que tenemos que hacer es comprobar que no hayamos

cometido ningún error. Para ello, nos vamos a la barra de botones y
pulsamos el botón de verificar (botón de color blanco en la imagen
anterior).

Cada vez que abramos un nuevo proyecto en Arduino y tratemos de

cargar o verificar su contenido, si nunca hemos guardado este
proyecto, nos indicará si queremos guardarlo. Es recomendable
hacerlo, por una parte, para poder reutilizarlo cuando lo necesitemos
y, por otra, para que no nos aparezca continuamente la ventana de
diálogo para almacenarlo. Por defecto, le asocia un nombre en
función de la fecha de creación y del número de proyectos que
llevemos creados ese día, todo esto precedido del término sketch
(«boceto», en inglés).

Imagen 54. Guardar archivo

49
Al instalar el IDE de Arduino se genera una carpeta con el nombre de
Arduino en el directorio de Mis Documentos. Por defecto, los
programas se guardan en esta carpeta (podemos cambiar la carpeta
de destino). Al guardar el programa, se crea otra carpeta dentro de la
anterior con el nombre del programa y, dentro, el archivo de
programa, con extensión .ino; a través de la consola podemos
conocer el proceso de verificación (en este caso, compilando
programa). Si no hay errores nos mostraría un mensaje similar al
siguiente:

Imagen 55. Programa sin errores

Además de indicarnos que el programa está compilado, nos muestra

información relativa al programa.

Si realizamos un programa con varios errores, el IDE nos muestra el

primero que encuentre. Si, por ejemplo, tenemos cuatro errores, el
IDE nos mostrará el primero que encuentre; debemos solucionarlo y
volver a compilar para que nos diga cuál es el siguiente error. Sin
errores, podemos subir el programa al Arduino.

Imagen 56. Subir programa

Para ello, hacemos clic sobre el botón que aparece en la imagen

anterior en blanco, la consola nos irá mostrando información del
proceso.

Imagen 57. Programa subido

Como podemos ver en esta imagen, al finalizar el proceso, nos lo

indicaría con el mensaje «Subido». Si subimos el programa sin
comprobar errores y hemos cometido algún error, ¿cargará el
programa de todas formas al Arduino? No, antes de cargar
cualquier programa, el IDE comprueba siempre si hay errores.

50
El proceso de carga del programa es un poco complejo: primero, el
IDE comprueba que no haya errores; luego, «traduce», si es
necesario, ese programa a un lenguaje que pueda almacenar e
interpretar el MCU del Arduino.

Para que esto sea posible, el IDE resetea el Arduino. Cada vez que se
resetea un Arduino, entra en funcionamiento el bootloader que, tal y
como vimos en capítulos anteriores, es un programa que cargan al
MCU antes de vendernos el Arduino.

El bootloader es un gestor de arranque, que establece un protocolo

por el cual se puede almacenar el programa en la memoria Flash del
Arduino, sustituyendo el programa anterior, para, a continuación,
empezar a ejecutar la parte del programa que se encuentra en el void
setup y, una vez finalizado, ejecutar cíclicamente el programa del
void loop.

Si nos fijamos en el Arduino, dispone de varios leds. Al cargar un

programa, veremos cómo parpadean rápidamente los leds de Tx y Rx
para luego quedar apagados (a menos que, por programa, se use la
comunicación serie).
Con todos estos pasos y manteniendo el circuito de la imagen 43,
deberíamos ver el led encendido; de no ser así, sería bueno
comprobar las conexiones o algún parámetro de las instrucciones.
Vamos a realizar algunas pruebas para finalizar este caso:

Imagen 58. Programa

Si cargamos el programa de la imagen anterior, veremos que el

funcionamiento del Arduino es exactamente el mismo.

Parece más lógico cargar el programa de la imagen 53: en ese

programa, el digitalWrite() se encuentra dentro del void setup. Como
sabemos que las instrucciones que se encuentran dentro del setup
solo se ejecutan una vez, esto es más que suficiente para encender el
led.

En el programa de la imagen 58, estamos continuamente escribiendo

1 en el mismo registro, por lo que no parece muy lógico realizar esta
solución cuando con escribir una vez el valor es suficiente.

51
Resumiendo: encender led

Otras pruebas

Imagen 59.Programa

Si cargamos este programa, vemos que el led no se enciende: esto

es debido a que, cada vez que reseteamos el Arduino, todos los
registros se resetean (valor por defecto). Por lo tanto, el registro
asociado a digitalWrite(13,____) se pone a cero. En consecuencia,
sería lo mismo escribir el programa de la imagen 59 que el de la
imagen 60.

52
 Imagen 60.Programa

En este caso, estamos escribiendo un cero en un registro que, por

defecto, ya debería estar a cero.

Temporizaciones Arduino

El leguaje de programación de Arduino dispone de instrucciones para

la gestión de tiempo. En este caso, veremos cómo hacer que un led
parpadee cada segundo.

delay(parámetro);

Esta instrucción detiene la ejecución del programa durante un tiempo

pasado por parámetro. La unidad de tiempo con la que trabaja es en
milisegundos. Por ejemplo:

• Detener durante 1 segundo: delay(1000);

Límites del parámetro: 0 a 4294967295 (sin decimales).

delayMicroseconds(parámetro);

Instrucción similar a la anterior, pero cambia la unidad de tiempo:

esta instrucción trabaja en microsegundos y los límites del valor del
parámetro son de 3 a 16383. Esta función nos permite detener la
ejecución del programa en tiempos más pequeños que el delay,
mientras que el delay permite llegar a temporizaciones más grandes.

53
 Imagen 61.Programa

En este caso, en el setup simplemente configuramos el pin como

salida, dejando las instrucciones de parpadeo en el loop, puesto que
es una operación que se tiene que ejecutar de forma cíclica.

Podéis probar a escribir todo el programa en la parte del void setup y

comprobaréis que solo parpadea una vez el led.

Pines digitales: entrada

Trabajar con un pin como una entrada significa que este debe leer el
valor de una señal. Antes de aprender a hacerlo con un Arduino,
vamos a hacerlo con un multímetro.

Según la RAE:

• Multímetro:

«Instrumento que permite medir varias magnitudes eléctricas, como

la intensidad la tensión y la resistencia»

Imagen 62. Multímetro

54
Como sabemos, la tensión de una pila es la diferencia de tensiones de
sus polos. Por lo tanto, para calcular la diferencia, debemos conocer
la tensión de cada polo. El multímetro devolverá la tensión de la pila
si se conecta cada polo de la pila a este.

Imagen 63. Medir tensión

Por lo general, el cable negro se debe conectar al polo de menos

tensión y el rojo al de más tensión. ¿Qué pasa si lo hago al revés?
Pues que, en vez de mostrarte un valor de 9 V, te mostraría un valor
de -9 V. Debemos tener cuidado, con Arduino no podemos medir
tensiones negativas, llegado el momento debemos asegurarnos de
conectarlo correctamente.

Imagen 64. Medir tensión Arduino

55
Para medir el voltaje de una señal con un multímetro, teníamos que
conectar los dos polos de la batería a este. En el Arduino, sucede lo
mismo; al fin y al cabo, estamos realizando la misma operación.

En el multímetro teníamos dos cables: negro (-) y rojo (+). Sus

equivalentes en el Arduino son GND y cualquier otro pin (digital o
analógico, a través del cual se quiera tomar la lectura),
respectivamente.

Imagen 65. Posibilidades con pulsadores

En la imagen anterior, vemos las tres posibilidades que tenemos para

conectar un pulsador. Antes de empezar con el conexionado de los
componentes, necesitamos ver otra parte del Arduino.

Imagen 66. Pines de potencia Arduino UNO

56
Disponemos de: un pin de 5 V y otros de 3,3 V, a través de los cuales
podemos demandar 20 y 50 mA, respectivamente; dos pines GND y
uno a mayores (encima del pin 13). Es indiferente en cuál realicemos
la conexión. También observamos el pin de Vin, a través de él
podemos alimentar nuestro Arduino, comparte las mismas
propiedades que el conector Jack.

Lo ideal, en caso de alimentar el Arduino por el Vin, sería entre 7 y

12 voltios; según las especificaciones y la demanda de intensidad, no
debe superar 1 amperio. Vamos a ver primero cómo realizaríamos
una conexión Pull_Down con un multímetro y a estudiar las dos
posibilidades (suponemos que la pila es de 9 V).

Imagen 67. Pull_Down multímetro

Es necesaria una resistencia, para evitar un cortocircuito cuando

pulsemos el botón. De no haber la resistencia, se conectaría
directamente el polo positivo y negativo.

Imagen 68. Posibilidades

57
En la imagen 68, vemos qué marcaría el multímetro cuando se pulsa
y cuando no se pulsa el botón.

Imagen 69. Pulsador Pull-Down

En la imagen 69, se monta el mismo circuito pero con el Arduino

(como los 5 V son del propio Arduino, no se realiza conexión con el
polo negativo, puesto que, internamente, sería GND).

digitalRead(parámetro);

Esta instrucción utiliza un único parámetro, que es el pin del cual

queremos leer la tensión. Esta instrucción nos devuelve un 1 si la
tensión de entrada es de 5 V y un 0 si la tensión es de 0 V. Lo que
hacemos es leer el valor del registro correspondiente.

Imagen 70. Encendido/Apagado led pulsador Pull-Down

El código del void setup es sencillo de entender, simplemente

realizamos las configuraciones necesarias. Lo que puede llamar más
la atención es la línea de código del void loop.

58
Lo que hay que hacer es actualizar el estado de led en función del
valor del pulsador. Para ello, empleamos la instrucción que ya
habíamos visto de digitalWrite(13; hasta aquí, no tenemos ningún
cambio.

Lo diferente aparece en el segundo parámetro de la instrucción,

digitalRead(12));. Los parámetros de una instrucción no tienen por
qué ser valores fijos; realmente son campos que necesitan recibir un
valor y este valor puede tener varios orígenes: bien porque se
introduce un valor fijo, porque escribimos en ese campo una variable
y que tome el valor de la variable o, como es este caso, utilizamos
una instrucción que devuelve un valor.

Imagen 71. Funcionamiento programa

Imagen 72. Pull_Up

59
 Imagen 73. Posibilidades Pull_Up

El comportamiento del circuito Pull_Up funciona a la inversa que el

Pull_Down: en el Pull_Down, cuando pulsamos, la lectura es de 9 V y,
cuando no pulsamos, 0 V, mientras que en el Pull_Up es al revés,
cuando no pulsamos, medimos 9 V y, cuando pulsamos, 0 V.

Imagen 74. Pull_Up Arduino

Por lo tanto, si cargamos el último programa, veremos que el

funcionamiento del sistema es a la inversa. Esto se debe a que, como
ya hemos visto, la lógica del circuito cambia.

¿Qué hago si no puedo invertir el comportamiento con este

tipo de conexión? Lo podemos solucionar por programa. Para ello,
debemos indicarle al Arduino que invierta el valor leído.
!
Con el símbolo de cierre de exclamación, podemos invertir el valor de
un bit (es decir, de una celda o, lo que es lo mismo, de un 0 o un 1).

60
 Imagen 75. Invertir valor

Con este programa y manteniendo el circuito Pull_Up, el led se

encenderá si mantenemos pulsado el botón.

Por último, vamos a realizar una conexión Input_Pull_Up.

Internamente, los Arduinos incorporan unas resistencias. Si
configuramos adecuadamente, el Arduino conecta esas resistencias a
5 V y al pin que le indiquemos. Esto se entenderá mejor con la
siguiente imagen.

Imagen 76. Resistencia interna Pull_Up

Podemos configurar que el Arduino (realmente el MCU) conecte una

de sus resistencias internas al pin de 5 V y a uno de los pines en
concreto, si hacemos eso y utilizamos ese pin como entrada; por
defecto, estará leyendo 5 V (lo que es lo mismo 1 en binario).

61
 Imagen 77. Arduino circuito Pull_Up

Esto simplifica mucho el circuito. ¿Cómo funcionaría? Si no

pulsamos el botón, internamente ese pin está conectado a 5 V a
través de la resistencia interna, por lo que la instrucción
digitalRead(12) devolvería un 1. Cuando pulsamos, estamos
conectando directamente a GND, por lo que la instrucción
digitalRead(12) devuelve un 0. De hecho, ya hemos hecho algo muy
parecido.

Imagen 78. Pull_Up interna y externa

62
Es exactamente lo mismo que hemos hecho en el circuito de Pull_Up.
La única diferencia es que la resistencia que antes conectábamos en
la protoboard, ahora está conectada internamente.

Imagen 79. Programa Input_PULLUP

Con el programa de la imagen 79 y el circuito de la imagen 77, el led

debería encenderse si se mantiene pulsado el botón.

En el primer capítulo, en el apartado de hardware, vimos que las

entradas digitales tienen unos márgenes entre los cuales la tensión
es equivalente a 5 V o a 0 V.

Imagen 80. Márgenes lecturas digitales

Si la tensión varía entre 0 y 2,5 V es equivalente a 0 V y, de 2,5 V a

5 V, es equivalente a 5 V.

63
Ejercicios propuestos:

1. Conectar dos leds: uno debe parpadear cada 5 segundos y, el

otro, cada segundo.

2. Conectar un led y un botón (conectado de cualquiera de las

tres formas anteriormente vistas). En caso de que se pulse el
botón, el led debe parpadear cada 2 segundos; si no está
pulsado, debe permanecer apagado.

3. Conectar un botón y dos leds (A y B): el led A tiene que

encenderse mientras el botón está pulsado y apagarse cuando
no está pulsado; el led B funciona a la inversa que el led A.

4. Dos Arduinos: el Arduino A debe tener conectado un botón y, el

Arduino B, un led. Si se pulsa el botón del A, se debe encender
el led del B (y, si no, debe apagarse). El A no puede estar
conectado al led, ni el B conectado al botón.

64
 1. Conectar dos leds: uno debe parpadear cada 5 segundos
y, el otro, cada segundo.

Los leds se conectarán a los pines 11 y 13, respectivamente; el led

11 parpadeará cada 5 segundos y, el 13, cada segundo.

65
2. Conectar un led y un botón (conectado de cualquiera de
las tres formas anteriormente vistas). En caso de que se
pulse el botón, el led debe parpadear cada 2 segundos;
si no está pulsado, debe permanecer apagado.

66
3. Conectar un botón y dos leds (A y B): el led A tiene que
encenderse mientras el botón está pulsado y apagarse
cuando no está pulsado; el led B funciona a la inversa
que el led A.

67
 4. Dos Arduinos: el Arduino A debe tener conectado un
botón y, el Arduino B, un led. Si se pulsa el botón del A,
se debe encender el led del B (y, si no, debe apagarse).
El A no puede estar conectado al led, ni el B conectado al
botón.

Para solucionar este caso, el Arduino A generará la señal adecuada

para que el Arduino B encienda el led según el estado del pulsador.

Si alimentamos los dos Arduinos a través de fuentes de alimentación

diferentes, tendremos que, tal y como se muestra en la figura,
conectar el pin GND de ambos. Si, por el contrario, los dos Arduinos
se alimentan de la misma fuente, como puede ser el caso de estar los
dos conectados al mismo PC, no es necesario conectar los pines GND
de ambos, puesto que ya lo comparten.

68
69
Variables

En cierto modo, ya hemos trabajado con variables: podríamos

considerar los registros como una variable; al fin y al cabo, es un
«lugar» en el que se puede leer o escribir información. Por lo tanto,
como ya hemos visto algo similar a una variable, vamos a ver cómo
podemos crear variables y trabajar con ellas.

Una variable permite almacenar información con una referencia

(nombre de una variable). El crear una variable se conoce como
«declarar una variable». Existen diferentes tipos de variables, cada
una de ellas almacena un tipo de dato.

La estructura para declarar una variable es la siguiente:

Imagen 81. Declarar una variable

Cuando declaramos una variable, lo que hacemos es reservar un

espacio de memoria para almacenar información.

Imagen 82. Espacio de memoria

70
Al declarar una variable, esta toma el valor de 0 por defecto; también
tenemos la posibilidad de inicializar una variable, es decir, crear una
variable con un valor determinado.

Imagen 83. Inicializar variable

El primer tipo de variable que veremos serán el tipo boolean. Este

tipo de variable contiene un solo bit o, lo que es lo mismo, una celda
en la cual solo puede haber un 0 o un 1. Para declarar una variable
existen ciertas normas:

• No puede haber más de una variable con el mismo nombre.

• Los nombres de las variables no pueden empezar por un
número.
• Las variables no llevan signos de acentuación.
• Tampoco llevan la letra ñ o símbolos especiales.
• Las variables pueden estar formadas por más de una palabra,
pero no pueden estar separadas por espacios sino por barra
baja (_). Ejemplo: Sensor_de_temperatura.

Imagen 84. Primera variable

71
En la imagen anterior, usamos nuestra primera variable. Como
vemos, la declaramos antes del void setup y decidimos inicializarla a
0.

En las líneas del void loop, actualizamos el valor de la variable con la

lectura de la entrada 12. Una vez almacenado el valor en la variable,
actualizamos el estado del led. Para ello, recuperamos el valor
almacenado en la variable; este proceso se repetiría una y otra vez.

Las variables se pueden clasificar según el tipo de variable y según el

área de uso. ¿Área de uso? Este concepto hace referencia a las
zonas del programa en las que se puede utilizar una variable.
Atendiendo a este tipo de clasificación diferenciamos dos tipos:
globales y locales. Una variable es global cuando se puede utilizar en
cualquier parte del programa y una variable es local cuando solo se
puede utilizar en una parte concreta del programa.

Las variables globales son aquellas que se declaran antes del void
setup, como es el caso anterior. Por eso podemos utilizar esa variable
dentro del void loop, a pesar de no estar declarada en esa parte del
programa.

Hay que tener en cuenta que una variable se puede declarar en

cualquier parte del programa. En consecuencia, si se declara en otra
parte que no sea antes del void setup, se conoce como variable local.

Imagen 85. Variable local

72
Tal y como vemos en la imagen anterior, si declaramos una variable
dentro del void setup y la utilizamos en el void loop, nos saldrá un
error, diciendo que esa variable no está declarada para ser usada en
esa parte del programa.

Imagen 86. Variable local

Con el programa de la imagen 86, desaparece el error, puesto que

usamos una variable local en la misma parte del programa en la que
ha sido declarada (dentro del void loop).

73
Repetir los ejercicios propuestos anteriores, pero usando variables
para almacenar todos los datos con los que se trabajen (menos los
valores de los delay).

5. Conectar dos leds: uno debe parpadear cada 5 segundos y, el

otro, cada segundo.

6. Conectar un led y un botón (conectado de cualquiera de las

tres formas anteriormente vistas). En caso de que se pulse el
botón, el led debe parpadear cada 2 segundos; si no está
pulsado, debe permanecer apagado.

7. Conectar un botón y dos leds (A y B): el led A tiene que

encenderse mientras el botón está pulsado y apagarse cuando
no está pulsado; el led B funciona a la inversa que el led A.

8. Dos Arduinos: el Arduino A debe tener conectado un botón y, el

Arduino B, un led. Si se pulsa el botón del A, se debe encender
el led del B (y, si no, debe apagarse). El A no puede estar
conectado al led, ni el B conectado al botón.

74
5. Conectar dos leds: uno debe parpadear cada 5 segundos
y, el otro, cada segundo.

75
6. Conectar un led y un botón (conectado de cualquiera de
las tres formas anteriormente vistas). En caso de que se
pulse el botón, el led debe parpadear cada 2 segundos;
si no está pulsado, debe permanecer apagado.

76
7. Conectar un botón y dos leds (A y B): el led A tiene que
encenderse mientras el botón está pulsado y apagarse
cuando no está pulsado; el led B funciona a la inversa
que el led A.

77
8. Dos Arduinos: el Arduino A debe tener conectado un
botón y, el Arduino B, un led. Si se pulsa el botón del A,
se debe encender el led del B (y, si no, debe apagarse).
El A no puede estar conectado al led, ni el B conectado al
botón.

78
79
Regulación led

Lo que se pretende con este caso es trabajar con dos tipos de señales
nuevas, ampliar lo visto sobre el sistema binario y trabajar con
nuevas variables y operaciones.

Imagen 87. Regular led

Para regular un led, conectaremos un potenciómetro, que genera una

señal analógica y haremos que, en función de esa señal, el Arduino
genere una señal PWM para regular el led de forma proporcional.

Imagen 88. Potenciómetro

La RAE nos ofrece dos definiciones para un potenciómetro:

• Potenciómetro:
«Instrumento que mide las diferencias de potencial eléctrico»;
«Resistencia regulable en un circuito eléctrico».

Comúnmente, es conocido como «resistencia variable». Cuando

trabajemos con divisores de tensión, veremos que, quizás, la
definición más acertada para un potenciómetro es la de «divisor de
tensión variable».

80
Como vemos en la imagen 88, un potenciómetro dispone de 3
patillas: tanto la patilla de la izquierda como la de la derecha se
utilizan para alimentar el potenciómetro y la patilla central genera
una señal proporcional a la posición del mecanismo de rotación.

Imagen 89. Resistencia interna potenciómetro

Un potenciómetro tiene como elemento básico una resistencia. Como

podemos ver en la imagen anterior, las patillas exteriores del
potenciómetro se corresponden con las patillas de una resistencia.

Imagen 90.

Si, por el momento, consideramos un potenciómetro como una

resistencia, podemos estudiar con la ley de Ohm su consumo
(consideramos que el potenciómetro es de 1k = 1000 ohmios).

V(tensión) = I(intensidad)*R(resistencia)
V = I*R
I = 5/1000 = 0,005 amperios (A) = 5 miliamperios (mA)

Podemos asegurar que el consumo de intensidad es de 5mA, ¿para

qué sirve la tercera patilla (la central)? Esta patilla,
internamente, se encuentra en contacto con la resistencia del
potenciómetro; el punto de contacto cambia en función del
movimiento de rotación del potenciómetro, es decir, es solidario al
movimiento.

81
 Imagen 91. Tercera patilla potenciómetro

En función del giro del potenciómetro, el contacto de esta patilla con

la resistencia varía a lo largo de esta, siendo sus extremos la
conexión directa, en este caso, con el polo positivo y negativo de la
pila, respectivamente.

Lo que genera este funcionamiento es un cambio en la tensión de

salida por la patilla central, pero, antes de continuar, analizaremos
los conceptos de «conexión en serie» y «en paralelo».

Imagen 92. Conexión Paralelo/Serie

De la imagen anterior, deducimos que si dos resistencias tienen dos

puntos de conexión en común, se encuentran en paralelo y si, en
cambio, solo es uno se encuentran en serie.

Internamente, un potenciómetro se asemeja a una conexión en serie

de dos resistencias (aunque, en realidad, solo hay una), por lo que
vamos a centrarnos en la conexión en serie.

82
El hecho de que dos o más componentes se encuentren conectados
en serie hace que la intensidad que circula a través de cada uno de
ellos sea igual a la que circula por el resto.

Imagen 93.

Aunque haya dos resistencias más conectadas en serie, se puede

calcular la resistencia equivalente como la suma de los valores de las
resistencias.

Imagen 94. Resistencia equivalente

Según esta regla, podemos asegurar que es lo mismo tener dos

resistencias de 500 ohmios conectadas en serie que una resistencia
de 1000 ohmios. La diferencia entre estos dos casos (una resistencia
de 1000 ohmios o dos en serie de 500 ohmios) es que al conectar
varias resistencias en serie surge una caída de tensión por cada
resistencia en serie.

Vamos a cuantificar la caída de tensión: primero, calculamos con la

resistencia equivalente el consumo de intensidad del circuito, usando
la ley de Ohm.
V(tensión) = I(intensidad)*R(resistencia)
V = I*R

83
 I = 5/1000 = 0,005 amperios (A) = 5 miliamperios (mA)

Sabemos entonces que, tengamos una resistencia de 1000 ohmios o

dos de 500 en serie, el consumo de intensidad es de 5 mA.

Imagen 95. Caída de tensión resistencias en serie

Si recuperamos otra vez la ley de Ohm, y conociendo el valor de la

resistencia y la intensidad que circula por ella, podemos calcular la
caída de tensión en cada resistencia.

V = I*R

V = 0,005*500 = 2,5 voltios

En un potenciómetro ocurre algo similar: tenemos una resistencia con

un valor fijo y una tercera patilla que recorre esta resistencia
cambiando el punto de contacto.

Imagen 96.

Supongamos que giramos el potenciómetro (cuyo valor es de 1k)

hasta su punto medio, tal y como aparece en la imagen anterior; el

84
valor de la resistencia que contacta con la tercera patilla es de 500
ohmios. Por lo tanto, la tensión de salida de esa patilla es de 2,5
voltios (5 mA*500 ohmios).

Imagen 97.

En la imagen anterior, vemos que, según giremos hacia izquierda o

derecha, movemos el punto de contacto con la resistencia entre sus
extremos, proporcionándonos, en cada caso, una tensión equivalente.

La manera de variar el valor de la señal de salida de un

potenciómetro depende de su encapsulado: rotatorio, rectilíneo o
digital (pulsos eléctricos). La variación de la señal puede ser
proporcional al movimiento o en forma logarítmica (vamos a suponer
que es lineal).

Imagen 98. Funcionamiento potenciómetro

En resumen, alimentamos un potenciómetro por sus dos patillas

externas (no tiene polaridad, por lo que es indiferente donde

85
conectemos el positivo o el negativo). En función de la posición, se
varía la tensión de salida por la patilla central.

Imagen 99.

Para conocer la posición de la patilla central, debemos de leer el valor

de la señal de salida con nuestro Arduino, pero no podemos hacerlo
con los pines digitales, puesto que, como sabemos, solo diferencian
tensiones de 0 o 5 voltios y, en este caso, no es lo mismo una señal
de 1,4 voltios que una de 4,7; significa que la patilla central se
encuentra en posiciones diferentes.

Ilustración 100.

Disponemos de 6 entradas analógicas (ADC conversor analógico

digital), cada una de ellas con una resolución de 10 bits y un tiempo
de conversión de 100 microsegundos.
¿Resolución? ¿Tiempo de conversión? Son parámetros que
definen las características de lectura que tienen las entradas
analógicas. La resolución tiene que ver con la capacidad de detectar
incrementos de tensión y el tiempo de conversión con el tiempo que
debemos de esperar para tomar diferentes lecturas.

86
La resolución viene definida por el número de bits; en este caso, ya
no trabajamos con un único bit, como llevamos hecho hasta ahora.
Vamos a aprovechar esto para ampliar los conocimientos sobre el
sistema binario.

La unidad básica del sistema binario es un bit (lo que conocíamos

como una celda), cuyo valor puede ser 0 o 1. Esto solo nos permite
trabajar con dos estados, pero en la mayor parte de las ocasiones
trabajaremos con más de dos posibilidades.

Para poder expresar más posibilidades con el sistema binario, lo que

se hace es agrupar más bits. La siguiente unidad en el sistema
binario es 1 byte (conjunto de 8 bits).

0 0 0 0 0 0 0 0

¿Cuántas combinaciones de 0 y 1 podemos realizar con 8 bits?

2n.º de bits, en este caso: 28 = 256 combinaciones posibles.

Veamos cómo se codifican los números naturales en el código

binario:

Equivalente número
Codificación binario natural
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1
0 0 0 0 0 0 1 0 2
0 0 0 0 0 0 1 1 3
0 0 0 0 0 1 0 0 4
0 0 0 0 0 1 0 1 5

En la tabla anterior, vemos cómo se codifican los 6 primeros números

partiendo del 0. Como puede resultar obvio, en binario, si el valor de
un conjunto de bits (sea cual sea la cantidad) es de 0, su equivalente
en números naturales es 0.

Podría resultar complicada esta codificación, pero realmente, es más

sencilla que la que utilizamos nosotros. Hay que tener en cuenta que
en binario solo existen dos dígitos mientras que, en los números
naturales, disponemos de 10 (0-1-2-3-4-5-6-7-8-9) y, con la
combinación de estos, hacemos números más grandes.

Lo mismo ocurre con los números binarios: con la combinación de

bits podemos expresar valores cada vez más grandes. Lo que
tenemos que conocer es cómo ir codificando números cada vez más
grandes. En los números naturales partimos del 0, pero es lo mismo
decir 0 que decir 00000000000...

87
La configuración inicial sería con todos los bits (sean 8, 10, 20, etc.)
a cero. Al igual que hacemos con los números naturales, al empezar
a incrementar lo hacemos sobre el primer dígito, si desbordamos, es
decir, pasamos de 9, reseteamos ese dígito y sumamos uno al
siguiente.

En el sistema binario pasa exactamente lo mismo, lo que pasa es que

se desborda antes, puesto que hay menos dígitos (solo 2 frente a 10
del sistema natural).

Imagen 101. Incremento sistema binario

La tabla anterior representa los incrementos: las flechas azules

representan el incremento de una unidad (bit) para pasar al valor
siguiente. Esta suma siempre se hace sobre el primer bit (al igual que
con los números naturales). Las flechas verdes representan los
sucesivos desbordes (pasar de 1 a 0 y sumar 1 al siguiente bit).

Con 8 bits podemos representar 256 valores, desde el 0 hasta el 255,

si llegamos al 255, lo que equivale a 11111111, y volvemos a
incrementar, desbordan todos los bits y volvemos al valor inicial de
todo ceros (00000000).

88
 Imagen 102.

Volviendo al caso de las entradas analógicas o conversores analógicos

digitales. A través de estos pines se toman lecturas de tensión (entre
0 y 5 V) y devuelven un valor de entre 0 y 1023 (210). Este
parámetro nos indica la resolución, es decir, qué incrementos de
tensión es capaz de detectar la entrada analógica.

5/1023 = 0,005mV aprox.

Si, por características del sistema, necesitamos detectar incrementos

de tensiones más pequeños, debemos buscar un Arduino con más
resolución.

Imagen 103. Resumen entradas analógicas

89
En conclusión, conectamos una entrada que varía entre 0 y 5 V y el
valor numérico que devuelve el Arduino será de 0 a 1023,
proporcional a la entrada.

analogRead(param1);

Esta instrucción devuelve un valor de entre 0 y 1023 de la entrada

analógica que se le indique por parámetro (A0, A1, A2, A3, A4, A5 o
0, 1, 2, 3, 4, 5).

• Lectura analógica entrada A0: analogRead(0);

Por ahora, solo hemos visto un tipo de variable (boolean), pero es

una variable muy pequeña para poder almacenar el valor de una
entrada analógica. Tenemos otros tipos de variables de más bits que
pueden almacenar números más grandes:

• byte (8 bits): valores de 0 a 255.

• int o short (16 bits): valores de -32768 a 32767.
• word (16bits): valores de 0 a 65535.
• long (32bits): valores de -2147483648 a 2147483647.
• unsigned long (32 bits): 0 a 4294967295.

Pensar en la cantidad de bits, para elegir qué variable usar, nos va a

resultar complicado al principio. Por lo tanto, tendremos en cuenta
qué rango de valores puede almacenar cada tipo de variable.

Imagen 104. Primera lectura analógica

Con el potenciómetro conectado a la entrada analógica A0,

declaramos una variable tipo int (puesto que la lectura va desde 0 a
1023 y, en esta variable, puedo almacenar valores de -32768 a
32767).

90
Las entradas analógicas no necesitan ser inicializadas, como sí ocurre
con las entradas digitales; por defecto, se comportan como entradas
analógicas.

Imagen 105. Regulación led

El objetivo de este caso es tomar una lectura de un potenciómetro de

entre 0 y 5 V y regular un led (más o menos luminosidad), en función
de la lectura. Si el Arduino UNO dispusiera de salidas analógicas,
sería muy sencillo. Si, por ejemplo, la entrada fuera de 3,5 V,
regularíamos una salida a 3,5 V, pero no disponemos de una salida
con estas características.

Una señal PWM es una señal que varía periódicamente entre sus dos
posibles estados: encendido o apagado. Esos dos valores, en caso de
un Arduino, son 0 o 5 V.

91
Antes de empezar a generar señales PWM, debemos ver previamente
dos términos: «frecuencia» y «período».

La frecuencia es el número de veces que se repite un evento en un

segundo y su unidad de medida es el hercio (Hz). Por ejemplo: si
digo que, escribiendo con el teclado, mi frecuencia de escritura es de
5 Hz, esto quiere decir que escribo 5 palabras por segundo.

Por consiguiente, cuando decimos que la frecuencia con la que puede

generar señales PWM un Arduino UNO es de 490 Hz, significa que
genera 490 señales en un segundo.

El período es el tiempo que dura una señal (se encuentre o no

activada) y lo podemos conocer por la fórmula:

T(período) = 1/f(frecuencia)

T(segundos) = 1/hercios

En consecuencia, cada señal que genera el Arduino dura

T = 1/490 = 0,002040816 segundos, redondeamos y consideramos
que cada señal dura 2 milisegundos o, lo que es lo mismo, 2000
microsegundos.

Vamos a suponer el siguiente caso: tomamos una lectura de la

entrada analógica y esta nos devuleve el valor de 512, lo que
significa que tenemos 2,5 V. Para que el led se regule a una tensión
similar a 2,5 voltios, jugaremos con los tiempos de encendido y
apagado de cada señal.

Imagen 106

92
Por lo tanto, teniendo en cuenta que una señal analógica tiene un
valor de 0 o 5 V, si genero unas 500 señales por segundo y cada una
de ellas dura 2000 microsengudos, si programo que cada señal se
encuentre activa 1000 microsengundos y desactivada otros 1000
microsengundos, la tensión media con la que trabajará el led es de
2,5 V.

Esto es debido a la gran velocidad de las señales, por lo que un ser

humano visualmente no podría darse cuenta de que un led se ha
encendido y apagado 500 veces en un segundo. En conclusión, para
generar una señal proporcional a una entrada analógica, se genera
una señal PWM jugando con los tiempos de encendido y apagado.

analogWrite(param1,param2);

Esta instrucción permite generar señales PWM; el parm1 indica en

qué pin se va ha generar una señal PWM y el segundo indica el
tiempo de activación (valores entre 0 y 2000 microsegundos).

El problema es que el param2 solo permite valores de entre 0 y 255.

Por lo tanto, debemos hacer una regla de tres para tomar un valor de
la entrada analógica que varía entre 0 y 1023 y pasarlo a un valor de
entre 0 y 255.

map(valor,min_valor,max_valor,min_resul,max_resul);

Esta es una instrucción un poco compleja, que se entenderá mejor

con un ejemplo.

Imagen 107.

93
En resumen:

Imagen 108. Resumen regulación led

Hay que recordar que no a través de todos los pines se pueden

generar señales PWM con la instrucción analogWrite(,);. Podemos
generar PWM por los pines: 3, 5, 6, 9, 10, 11. Es necesario tener en
cuenta las limitaciones de intensidad, por lo que, cuando sea
necesario, se conectará una resistencia a la salida.

Imagen 109. Pines PWM

94
Ejercicios propuestos:

9. Modificar el tiempo de parpadeo de un led en función de la

señal de un potenciómetro. El tiempo debe variar entre 100 y
3000 milisegundos.

10. Repetir el ejercicio 9, añadiendo un botón y, además, el

led solo puede parpadear si el botón está pulsado; si no, debe
quedar apagado.

11. Dos Arduinos: al Arduino A se le conectará un

potenciómetro y, al Arduino B, un led. El led del Arduino B se
debe regular en función del valor del potenciómetro del Arduino
A. El Arduino A no puede estar conectado al led del B y el
Arduino B no puede estar conectado al potenciómetro del A.

12. Repetir el ejercicio 11, añadiendo un led al Arduino A y

comparar si los led del Arduino A y B se regulan del mismo
modo.

13. Modificar el ejercicio 2 para que el led del Arduino B se

regule a la inversa que el Arduino A.

95
9. Modificar el tiempo de parpadeo de un led en función de
la señal de un potenciómetro. El tiempo debe variar
entre 100 y 3000 milisegundos.

96
10. Repetir el ejercicio 9, añadiendo un botón y, además, el
led solo puede parpadear si el botón está pulsado; si no,
debe quedar apagado.

97
1. Dos Arduinos: al Arduino A se le conectará un
potenciómetro y, al Arduino B, un led. El led del Arduino
B se debe regular en función del valor del potenciómetro
del Arduino A. El Arduino A no puede estar conectado al
led del B y el Arduino B no puede estar conectado al
potenciómetro del A.

98
99
2. Repetir el ejercicio 11, añadiendo un led al Arduino A y
comparar si los led del Arduino A y B se regulan del
mismo modo.

100
101
3. Modificar el ejercicio 2 para que el led del Arduino B se
regule a la inversa que el Arduino A.

102
103
Estructuras de control de flujo
Hasta ahora, nuestros programas estaban formados por un conjunto
de líneas de código que se ejecutaban en su totalidad y de forma
secuencial, es decir, desde la primera línea hasta la última.

Imagen 110.

En la imagen anterior, vemos que la ejecución de los programas que

incluyen estructuras de control de flujo puede seguir diferentes
caminos. Esto quiere decir que podemos establecer condiciones para
que se ejecuten una serie de instrucciones.

Disponemos de diferentes tipos de estructuras de control de flujo,

que podemos dividir en dos grupos: repetitivas y no repetitivas. En
este libro, nos centraremos en las no repetitivas, dejando las otras
para el tomo II.

De la imagen anterior, también nos damos de cuenta que la ejecución

de un programa se puede definir mediante una especie de esquema.
Estos esquema son conocidos como «diagramas de flujo». Los
diagramas de flujo cobran gran importancia a la hora de realizar un
programa, ya que nos permite «dibujar» una idea de cómo debe ser
nuestro programa.

También se usan para la documentación de programas, es un

elemento que nos permite comprender mejor el programa hecho por
un tercero. Por todo esto, a lo largo de este capítulo, definiremos el
esquema de cada estructura.

104
Estructuras de control de flujo no repetitivas

Las estructuras de control de flujo no repetitivas representan una

estructura que engloba instrucciones que se deben ejecutar si se
cumplen una o más condiciones.

Por lo tanto, es necesario evaluar al principio de cada estructura si se

cumplen las condiciones definidas. Antes de empezar con estas
instrucciones, vamos a ver los elementos básicos de un diagrama de
flujo.

Imagen 111. Elementos básicos de un diagrama de flujo

Dentro del rectángulo, representaremos la acción o acciones que

vamos a realizar; la flecha nos indica cuál es el siguiente elemento
que se va a ejecutar y las elipses definen el principio y fin de las
principales partes de un programa: declaración de variables, void
setup y void loop.

Veamos un ejemplo de cómo dibujar nuestro primer diagrama de

flujo. Para ello, recuperemos un de los casos realizados:

Modificar el tiempo de parpadeo de un led en función de la

señal de un potenciómetro. El tiempo debe variar entre 100 y
3000 microsegundos.

Lo primero que tenemos que hacer es «dibujar» en el void setup.

105
 Imagen 112.

A continuación, dibujamos lo que haremos en el void loop:

Imagen 113.

106
Como podemos comprobar, un diagrama de flujo consiste en plasmar
ideas en un formato sencillo; podemos ser todo lo específicos que
queramos, pero se trata de hacer una primera división de las tareas
más importantes que hay que realizar.

Esto no quiere decir que, de antemano, seamos capaces de definir

todo el programa que vamos a desarrollar, pero, por lo menos,
tenemos un esquema del que partir, en vez de empezar a desarrollar
en primer lugar el programa.

A la hora de trabajos en grupo, tanto los comentarios como los

diagramas de flujo son muy importantes para compartir
modificaciones e incluso de cara al futuro, para cuando sea necesario
realizar modificaciones, nos serán de gran ayuda. A veces, puede
llegar a ser muy importante el diagrama de flujo, puesto que, si está
mal definido, difícilmente el programa llegará a funcionar. Es una
buena práctica, al acabar un programa, revisar el diagrama de flujo
y, en función del programa final, modificarlo para que plasme la
solución final.

If

Esta estructura nos va ha permitir que, cada vez que el Arduino la

ejecute, se evalúe una condición (o conjunto de ellas) y, si la
condición se cumple, ejecute las instrucciones que engloba la
estructura.

Antes de empezar, vamos a ver cómo se traduce esto en un

diagrama de flujo.

Imagen 114.

Con los rombos podemos indicar cuándo se toma una decisión y, en

función de si se cumple, que el programa siga un camino u otro.

107
Estructura if:

If(condición)
{
//instrucciones que se ejecutan
}

Imagen 115.

Primero, se comprueba la condición y, si se cumple, se ejecutan las

instrucciones que se encuentran dentro de las llaves (de forma
secuencial) y se continúa con la ejecución del programa. Si no se
cumple la condición, no se ejecutan las instrucciones que se
encuentran entre las llaves y se «salta» a la instrucción que se
encuentre después de la llave de cierre.

¿Qué es esto de una condición? ¿Qué quiere decir «evaluar

condición»? Como ya hemos visto, en el sistema binario podemos
hacer un símil; imaginemos que, al escribir una estructura if, estamos
creando una celda en la memoria del MCU.

«Evaluar» y «cumplir» una condición significa que, cada vez que se

llegue a la línea de ejecución del if, accedemos a esa celda, en la cual
sabemos que solo puede haber un 0 o un 1. Si hay un 1, significa que
se cumple la condición, por lo tanto se ejecutan las instrucciones que
se encuentran dentro de las llaves del if. Si, por el contrario, hay un
0, significa que no se cumple y saltamos a la línea en la que se
encuentra la llave de cierre.

108
 Imagen 116.

Con todo esto, vamos a realizar nuestro primer programa, usando la

instrucción if. Evaluar si se ha pulsado un botón; de ser así, encender
un led y, si no, que se apague.

Imagen 117.

Imagen 118.

109
Si seguimos el esquema de la imagen 116 y cargamos el programa
de la imagen 117, veremos que, si no pulsamos el botón, el led se
encuentra apagado, y si lo pulsamos, veremos cómo se enciende. En
realidad, esta no sería la mejor solución, puesto que, si probamos a
añadir un pequeño delay al final del programa, veremos cómo se
enciende muy débilmente el led, y si aumentamos ese tiempo, acaba
por no encenderse.

Imagen 119.

Esto es debido a que la instrucción digital(13,LOW); se ejecuta

siempre, independientemente de si se ha pulsado o no el botón. La
solución sería que se ejecute la instrucción digitalWrite(13,HIGH);
cuando se pulsa el botón y la instrucción digitalWrite(13,LOW);
cuando no se pulsa.

110
 Imagen 120.

Imagen 121.

Esta solución no parece la más idónea, si somos capaces de saber si

se ha pulsado ¿Por qué volver a preguntarnos si no se ha
pulsado? No tiene mucho sentido, por eso disponemos de la
estructura else.

111
else

Esta estructura tiene en cuenta si no se cumple la condición de una

estructura if que la precede. De no cumplirse la condición de la
estructura if, se ejecutarían las instrucciones que pertenecen a else.

If(condición)
{
//instrucciones que se ejecutan
}
else
{
//instrucciones que se ejecutan si no se cumple el if
}

Imagen 122.

Tenemos que tener claro lo siguiente: en caso de cumplirse la

condición, se ejecutan todas las líneas de código que se encuentren
dentro de las llaves que pertenecen al if; una vez ejecutadas, el
programa ejecuta la primera instrucción que se encuentre
inmediatamente después de la llave de cierre del else.

Si, por otro lado, no se cumple la condición el programa, «salta» y

ejecuta las instrucciones que se encuentran dentro de las llaves del
else y, al finalizar, ejecuta la primera instrucción que se encuentre
inmediatamente después de la llave de cierre del else.

En resumen: se cumpla o no la condición, todas las instrucciones que

se encuentren después de la llave de cierre del else serán ejecutadas.

112
 Imagen 123.

El programa de la imagen 122 funciona igual que el de la imagen

119, pero parece más lógico cargar este último programa.

¿Cuándo utilizar if? ¿Cuándo utilizar if else? Dependerá de cómo

sea el desarrollo del programa. Por lo general, se utiliza solo if en
caso de que solo se realice una acción si se cumple una condición y
se utiliza if else cuando hay que realizar una acción diferente si se
cumple o no una condición.

Aun así, hay que recalcar que estos casos son para entender el
funcionamiento de la instrucción if y else. Obviamente, el programa
con menos líneas que aporta el mismo funcionamiento sería el que ya
hemos visto en el capítulo de primeros pasos.

Imagen 124.

113
Ejercicios propuestos:

Utilizando las instrucciones if y else (cuando se pueda), resolver los

siguiente ejercicios:

14 Conectar un led y un botón. En caso de que se pulse el botón,

el led debe parpadear cada 2 segundos; si no está pulsado,
debe permanecer apagado.

15 Conectar un botón y dos leds (A y B): el led A tiene que

encenderse mientras el botón está pulsado y apagarse cuando
no está pulsado; el led B funciona a la inversa que el led A.

16Conectar un led, un pulsador y un potenciómetro. Regular el

led siempre y cuando el botón se encuentre pulsado; de lo
contrario, no regular el led.

17 No regular el led no significa que lo apaguemos, sino que

quede regulado con el último valor válido (justo antes de dejar
pulsado el botón).

114
14 Conectar un led y un botón. En caso de que se pulse el
botón, el led debe parpadear cada 2 segundos; si no está
pulsado, debe permanecer apagado.

115
15 Conectar un botón y dos leds (A y B): el led A tiene que
encenderse mientras el botón está pulsado y apagarse
cuando no está pulsado; el led B funciona a la inversa
que el led A.

116
16 Conectar un led, un pulsador y un potenciómetro.
Regular el led siempre y cuando el botón se encuentre
pulsado; de lo contrario, no regular el led.

No regular el led no significa que lo apaguemos, sino que

quede regulado con el último valor válido (justo antes de
dejar pulsado el botón).

117
if else if

Hasta ahora, podíamos evaluar una condición y realizar dos

operaciones diferentes en caso de cumplirse o no. No obstante,
puede darse la circunstancia de que, si no se cumple una condición,
debamos evaluar una o más condiciones a mayores.

If(condición)
{
//instrucciones que se ejecutan
}
else
{
//instrucciones que se ejecutan si no se cumple el if
}

Imagen 125. Diagrama if else if

Como apreciamos en la imagen anterior, el programa puede seguir

hasta tres caminos diferentes. De esta forma, en caso de no
cumplirse la primera condición, podemos evaluar una segunda y, en
función de esta, realizar dos operaciones diferentes.

Podemos agrupar tantos if else if como necesitemos; lo que tenemos

que tener claro es que, una vez que se cumpla una de las
condiciones, el programa no evaluará las restantes.

118
If(condición1)
{
//instrucciones que se ejecutan si se cumple la condición1
}else if(condición2)
{
//instrucciones que se ejecutan si se cumple la
condición2 y no la 1
}else if(condición3)
{
//instrucciones que se ejecutan si se cumple
la condición3 y no la 1 ni la 2
}else{
//instrucciones que se ejecutan si se no
se cumplen ninguna de las 3 condiciones
}

Imagen 126.

En el siguiente caso, probaremos esta nueva estructura de control.

Para ello, se establece el esquema de la imagen anterior y el
funcionamiento es el siguiente: si alguno de los dos botones está
pulsado, el led debe encenderse y, de no ser así, debe apagarse.

119
 Imagen 127.

Ejercicios propuestos:

17 Conectar dos botones (A y B) y un led.

• El led parpadeará cada segundo siempre que se pulse el A.

• El led quedará encendido si se pulsa el B (y no el A).
• Si no se pulsa ninguno, se apagará.

18 Conectar dos botones (A y B), un led y un potenciómetro.

• Si se pulsa el A, el led se regulará conforme al

potenciómetro.
• Si se pulsa el B (y no el A), el led se apagará.
• Si no se pulsa ninguno, no se actuará sobre el led.

120
 16 Conectar dos botones (A y B) y un led.

• El led parpadeará cada segundo siempre que se pulse

el A.
• El led quedará encendido si se pulsa el B (y no el A).
• Si no se pulsa ninguno, se apagará.

Para que se cumplan las condiciones anteriores, es importante el

orden en el cual se establecen las condiciones. Si cambiamos el
digitalRead(1) por digitalRead(2), el funcionamiento se invierte.

121
17 Conectar dos botones (A y B), un led y un
potenciómetro.

• Si se pulsa el A, el led se regulará conforme al

potenciómetro.
• Si se pulsa el B (y no el A), el led se apagará.
• Si no se pulsa ninguno, no se actuará sobre el led.

122
Operadores lógicos

Los operadores lógicos nos van a permitir evaluar más de una

condición por cada if (hasta ahora, solo evaluábamos una condición).
Según se empiecen a complicar los casos, el evaluar solo una
condición va a hacer que el programa crezca demasiado haciéndolo
cada vez más complejo; por lo tanto, vamos a ver cómo incluir más
de una condición en cada if.

Disponemos de tres tipos de operadores lógicos:

• && o and

o Este operador comprueba que se cumplan dos o más

condiciones.

• || o or

o Este operador comprueba que al menos una condición se

cumple.
• !

o Este operador invierte la condición.

Comprobar dos o más condiciones, invertirlas… Estos nuevos

términos pueden ser un poco complicados de entender al principio,
así que vamos a hacer algunos ejemplos.

Empezamos por el operador && o and: vemos que tenemos dos

formas de escribirlo, para entender cómo funciona, montaremos el
siguiente circuito.

Imagen 128.

123
El led solo se debe encender si los dos botones están pulsados. Si al
menos uno de ellos no lo está, el led tiene que apagarse. Si no
trabajamos con los operadores lógicos, el programa y el diagrama de
flujo sería el siguiente.

Imagen 129.

Imagen 130.

124
Si no utilizamos operadores lógicos, un programa tan sencillo como
encender un led, al haber dos botones pulsados, se complica
bastante. Vamos a comparar la solución anterior con la siguiente, que
usa operadores lógicos.

Imagen 131.

Imagen 132.

Como se puede comprobar, con operadores lógicos se simplifica el

programa, pero podemos seguir y concatenar más condiciones. Por
ejemplo: si, en vez de que el led se encienda cuando hay dos o más
botones pulsados, queremos que se encienda cuando haya tres. El
programa sería el siguiente:

125
 Imágenes 133.

Cada condición que necesitemos incluir debe venir precedida de un

operador lógico (salvo la primera).
El siguiente operador lógico sería el or o ||. Al igual que el anterior,
tenemos dos formas de escribirlo. La diferencia entre and y or radica
en que ya no es necesario que se cumplan dos o más condiciones
para «entrar» en la estructura del if. Con que se cumpla una de ellas
es suficiente.
Aprovechamos el circuito anterior, encender el led si, al menos, uno
de los dos botones está pulsado. Sin operadores lógicos, el programa
y su diagrama de flujo serían los siguientes.

Imagen 134.

126
 Imagen 135.

Al igual que ocurría sin el operador and, para realizar una simple
tarea, el programa se puede complicar. Por consiguiente, vamos a
incluir el nuevo operador lógico.

Imagen 136.

127
 Imagen 137.

Con este operador, el programa se puede simplificar y podemos

concatenar todas las condiciones que necesitemos.

El último operador es el que permite invertir una condición (!). Para

invertir una condición, es necesario que la condición vaya precedida
por el operador de inversión.

Si recuperamos el programa de la imagen 130, pero esta vez, en vez

de encenderse el led cuando se pulsen los dos botones, el led debe
encenderse cuando ninguno de los dos esté pulsado, una solución
sería la siguiente:

Imagen 138.

128
No obstante, otra solución sería invertir cada condición del if con el
operador !.

Imagen 139.

Operadores de comparación

Los operadores lógicos permiten realizar operaciones con un único bit

(0 o 1), lo que en ciertos casos no nos va a permitir evaluar
correctamente una condición.

• == Igualdad

o Permite comparar dos valores: si son iguales, devuelve

un 1 y, si son diferentes, un 0.

• != Diferencia

o Permite comparar dos valores: si son diferentes, devuelve

un 1 y, si son iguales, un 0.

• > Mayor que

o Devuelve un 1 si el primer término es mayor que el

segundo; de lo contrario, devuelve un 0.

• >= Mayor o igual que

o Devuelve un 1 si el primer término es mayor o igual que

el segundo; de no ser así, devuelve un 0.

129
 • < Menor que

o Devuelve un 1 si el primer término es menor que el

segundo; de lo contrario, devuelve un 0.

• <= Menor o igual que

o Devuelve un 1 si el primer término es menor o igual que

el segundo; de no ser así, devuelve un 0.

Hagamos algunos ejemplos para probar estos nuevos operadores.

Imagen 140.

Imagen 141.

130
Ilustración 142.

Imagen 143.

131
Imagen 144.

Imagen 145.

132
 Imagen 146.

Ejercicios propuestos:

18 Conectar un botón, un led y un potenciómetro. Si el valor de

la salida del potenciómetro es superior a 2,5 V y el botón
está pulsado, el led debe de encenderse.

19 Conectar led, botón y potenciómetro. Regular el led si el

botón está pulsado y la señal del potenciómetro es superior
a 2,5 V. El valor de regulación queda definido entre 2,5 y
5 V, siendo equivalentes a 0 y 1023, respectivamente.

133
19 Conectar un botón, un led y un potenciómetro. Si el valor
de la salida del potenciómetro es superior a 2,5 V y el
botón está pulsado, el led debe de encenderse.

134
20 Conectar led, botón y potenciómetro. Regular el led si el
botón está pulsado y la señal del potenciómetro es
superior a 2,5 V. El valor de regulación queda definido
entre 2,5 y 5 V, siendo equivalentes a 0 y 1023,
respectivamente.

135
Operadores compuestos y aritméticos

Aritméticos:

+ Suma
- Resta
* Multiplicación
/ División
% Módulo de una división

Compuestos:

x++; equivalente a x = x + 1;
x--; equivalente a x = x - 1;
x+=3; equivalente a x = x + 3;
x*=3; equivalente a x = x*3;
x/=3; equivalente a x = x/3;

Con estos operadores, podemos empezar a realizar operaciones

básicas.

switch

switch(expresión)
{
//La expresión puede ser una variable o una función.
case valor1:
//Si la expresión es igual a este valor, ejecuta las instrucciones
hasta que encuentre
break; //no se evalúan más valores, se sale del bucle.

case valor2:
//Si la expresión es igual a este valor, ejecuta las instrucciones
hasta que encuentre
break; //no se evalúan más valores se sale del bucle.
default;
//si la expresión no es igual a ningún valor, se ejecutan estas
instrucciones y se sale del bucle.
}

Una estructura switch equivale a dos o más estructuras if, en las

cuales se realiza un operador de comparación (==).

136
 Imagen 147.

Si tenemos que hacer muchas comparaciones, el programa podrá

llegar a ser demasiado grande y difícil de interpretar. La estructura
switch compara el valor de la expresión switch(expresión) con cada
valor que acompañe a los case. En el momento en que sea igual a
uno de ellos, se ejecutarán las líneas de código que engloben el case
y su break correspondientes.

Al ejecutar las instrucciones, dejaría de realizar las comparaciones

con el resto de case, saliendo de la estructura del switch. En caso de
no ser igual a ninguno de los case, se ejecutarían las líneas de código
escritas a continuación de default.

Vamos a realizar un ejemplo con esta nueva estructura, en el cual, si

el potenciómetro genera una señal de 0 V, el led se apagará y no se
encenderá hasta generar una salida de 5 V, y viceversa.

Imagen 148.

Para ello, conectaremos el circuito anterior y cargaremos el siguiente

programa.

137
 Imagen 149.

Imagen 150.

Podemos incluir tantos case como necesitemos y los valores de la

comparación deben ser números.

138
Con esta última estructura se dan por finalizadas las estructuras de
control de flujo no repetitivas y también este libro. En el siguiente
libro (Arduino. Entendiendo el mundo. Tomo II) trabajaremos con las
estructuras de control de flujo repetitivas, comunicación serie,
funciones e interrupciones.

Web grafía
http://www.rae.es/
https://www.arduino.cc/

139