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
Introducción 3
Estructuras de control de flujo repetitivas 3
while 4
do while 8
for 11
break y continue 13
go to 14
Comunicación serie 15
Monitor serie 17
Enviar datos del Arduino al IDE 21
Saltos de línea y tabulaciones 31
Variables 34
Recibir datos 42
Comunicación serie entre Arduinos 57
Funciones 68
Funciones con valor de retorno 73
Pasar parámetros a una función 76
Interrupciones 81
Interrupciones por señal 81
Interrupciones por tiempo 85
Fritzing 87
Simuladores 90

2
Introducción
Este ejemplar es la continuación del libro Arduino. Entendiendo el
mundo. Tomo I. Por lo tanto, si no has leído el Tomo I, te recomiendo
que lo hagas antes de continuar con la lectura de este. La finalidad de
este libro es compartir nuevos conocimientos relacionados con los
vistos en el libro anterior.

Pese a que los contenidos de ambos libros son diferentes, el

desarrollo de ambos es idéntico. Cada nuevo conocimiento que
descubramos vendrá acompañado de casos prácticos resueltos para
poder asimilarlo de forma sencilla y se propondrán ejercicios para que
el público lector evalúe lo aprendido.

Como ya sabemos, Arduino es una plataforma y, como tal, dispone

de varios elementos: hardware, software y lenguaje de
programación. Este libro pretende ampliar tu lenguaje de
programación y, teniendo en cuenta la base que hemos visto en el
libro anterior, no necesitamos añadir más conceptos sobre electrónica
y hardware, pero si sobre el IDE de Arduino.

Los temas que veremos serán: estructuras de control de flujo

repetitivas, comunicación serie, funciones, interrupciones, Fritzing y
simuladores. Una vez finalizado este libro, junto con el Tomo I,
dispondremos de una base para empezar a desarrollar nuestros
proyectos; aún así, existen otros tomos dentro de esta serie que
comprenden mayores niveles de programación y electrónica (sobre
Arduino).

Estructuras de control de flujo repetitivas

Este tipo de estructuras son también conocidas como «bucles»; se
diferencian de las estructuras no repetitivas en que, siempre y
cuando se cumpla la condición o condiciones, se ejecutan las líneas
de código una y otra vez sin salir de la estructura.

3
while

Esta estructura ejecuta las instrucciones que se encuentran entre sus

llaves de apertura y cierre. ¿Cuántas veces? Se ejecutarán mientras
la condición especificada se cumpla, sin ejecutarse ninguna otra línea
de código que se encuentre fuera de la estructura.

while(condición)
{
//Instrucciones que se ejecutan mientras se cumpla la condición
}

Imagen 1.

Imagen 2.

4
 Imagen 3.

Imagen 4.

Al cagar este programa con el circuito anterior, mientras el botón

esté pulsado, el led se encenderá y, en el momento en que deje de
estar pulsado, se apagará un mínimo de dos minutos. Al igual que
ocurría con las instrucciones de control de flujo no repetitivas,
podemos añadir tantas condiciones como sean necesarias.

5
 Imagen 5.

Imagen 6.

Ejercicio propuesto:

1.Conectar un led, un botón y un potenciómetro. Regular el led

mientras el botón esté pulsado.

6
1. Conectar un led, un botón y un potenciómetro. Regular el led
mientras el botón esté pulsado.

7
do while

La estructura do while funciona igual que while. La diferencia es que

las líneas de código de esta nueva estructura se ejecutan al menos
una vez; después de esto, se evalúa la condición y, si se cumple, se
vuelven a ejecutar mientras se siga cumpliendo.

do
{
//Instrucciones que se ejecutan al menos una vez y
mientras se cumpla la condición

}while(condición);

Imagen 7.

8
 Imagen 8.

Imagen 9.

Ejercicios propuestos:

2. Conectar un led y un potenciómetro. El led siempre se tiene que

encender durante al menos 1 segundo y, si la entrada analógica
(conectada al potenciómetro) recibe una señal entre 1 y 4 V,
permanecerá encendido al menos 1 segundo más. Cuando no se
cumpla esta condición, el led deberá apagarse durante al menos 4
segundos.

9
2.Conectar un led y un potenciómetro. El led siempre se
tiene que encender durante al menos 1 segundo y, si la
entrada analógica (conectada al potenciómetro) recibe una
señal entre 1 y 4 V, permanecerá encendido al menos 1
segundo más. Cuando no se cumpla esta condición, el led
deberá apagarse durante al menos 4 segundos .

10
for

Esta estructura permite fijar el número de veces que se repite la

ejecución de las líneas de código que engloba.

for(valor_inicial_contador ; valor_final_contador ; operación)

{
//Instrucciones que se repetirán un número determinado de
veces
}

La condición de esta estructura viene definida por tres parámetros:

Valor inicial: puede empezar por cualquier valor numérico.

Valor final contador: cada vez que se ejecuten las instrucciones

de la estructura, se incrementa el valor del contador conforme
se defina en el campo de operación y se comprueba si se
alcanza el valor final; de ser así, se da por finalizado el bucle y
se continua con la ejecución del resto del programa.

Operación: define qué operación se realiza sobre el valor del

contador del bucle (suma, resta, multiplicación, división…).

11
Imagen 10.

Imagen 11.

Imagen 12.

12
break y continue

Son instrucciones que permiten modificar la ejecución de una

estructura. Con la instrucción break, se da por finalizada la ejecución
de una estructura de control. La instrucción continue fuerza a volver
a la primera instrucción de la estructura, sin evaluar las condiciones
ni ejecutar las líneas de código restantes.

Imagen 13.

Imagen 14.

13
 Imagen 15.

go to

Esta instrucción permite saltar a la línea de código que contenga una

etiqueta en concreto.

go to nombre_etiqueta;
-
.
.
.
nombre_etiqueta:;

Imagen 16.

14
 Imagen 17

La instrucción go to puede «saltar» tanto a una etiqueta que se

encuentre después o antes. No puede haber dos etiquetas con el
mismo nombre, puesto que entonces no sabría a cuál de ellas saltar y
el nombre de las etiquetas sigue las mismas reglas que la declaración
de una variable.

Comunicación serie
Para transmitir datos al exterior, un Arduino dispone de varios
protocolos de comunicación: atendiendo a si es una comunicación
síncrona o asíncrona, disponemos de varios protocolos de
comunicación. En este capítulo, trabajaremos con la comunicación
serie (UART).

La comunicación serie es un elemento importante de un Arduino, no

solo por permitir establecer una comunicación con un entorno (PC,
módulos u otros Arduinos) de una forma diferente a lo que hemos
hecho hasta ahora (entradas/salidas digitales, salidas PWM o
entradas analógicas), sino porque nos va ha permitir afianzar los
conocimientos adquiridos en el primer tomo.

La conexión USB del Arduino, además de alimentar el Arduino, sirve

para la transferencia de información; de hecho, ya lo hemos utilizado,
cada vez que cargamos un programa. Esto es posible porque tanto el
PC como el Arduino pueden manejar el protocolo USB.

El protocolo USB es demasiado complejo para el MCU del Arduino

UNO, por lo que se necesita un elemento que «traduzca» el protocolo

15
USB. Para ello, el Arduino UNO dispone de un segundo MCU
(ATmega16U2), que realiza la traducción.

Imagen 18.

Todos los MCU de los Arduinos disponen entonces del hardware para
establecer una comunicación UART (transmisor receptor asíncrono
universal). No necesitamos profundizar en esta tecnología, lo que nos
interesa saber es que, para que dos dispositivos se comuniquen
mediante UART, se necesitan tres cables: TX, que es por el que se
transmite, RX, por el que se recibe y GND, conexión en común entre
ambos dispositivos. Al disponer de dos líneas diferentes para recibir y
enviar datos, la comunicación es full duplex (información en ambos
sentidos).

El MCU del Arduino UNO (ATmega328p) proporciona una

comunicación serie UART TTL (se trata de un tipo de tecnología),
presente en los pines 0 (RX) y 1 (TX). Por lo tanto, podemos
establecer una comunicación serie por el puerto USB o por los pines 0
y 1.

¿Quiere esto decir que puedo enviar y recibir datos por el

conector USB y por los pines 0 y 1? Sí y no, podemos establecer
una comunicación por una de las dos vías, pero no por las dos
simultáneamente.

16
 Imagen 19.

Como se puede ver en la imagen anterior, internamente, los pines 0

y 1 intervienen en la comunicación serie con el PC.

Monitor serie

Si nos vamos a la barra de botones del IDE de Arduino, en el margen

derecho, disponemos de un botón con una lupa.

Imagen 20.

Si hacemos clic sobre la lupa, se abre una pestaña, además del IDE
de Arduino, lo que se conoce como «monitor serie».

17
 Imagen 21. Monitor serie

Para que se abra, es imprescindible tener un Arduino conectado al

puerto USB del PC y que el IDE detecte el Arduino. Si no es así y
tratamos de abrir el monitor serie, el IDE nos mostrará un error.

Imagen 22. Error Arduino no conectado

Si volvemos al monitor serie, encontramos varios apartados, que

iremos descubriendo poco a poco.

Imagen 23.

18
 Imagen 24.

Imagen 25.

Una vez montado el circuito anterior y con el programa cargado,

comprobamos que el led parpadea 4 veces una vez finalizado. Si
abrimos el monitor serie, vemos que se vuelve a repetir la operación
y el led vuelve a parpadear 4 veces. Esto se debe a que, cada vez
que abrimos el monitor serie, se resetea el Arduino (gracias al MCU
ATmega16U2). Al resetearse, como sabemos, se vuelve a ejecutar la
parte del programa que se encuentra en el void setup y, después, de
forma cíclica, el void loop.

Al lado del conector USB del hardware del Arduino UNO, disponemos
de un botón que sirve para restear el Arduino. Si continuamos con el
mismo programa y circuito anteriores y pulsamos el botón, vemos
que ocurre lo mismo que al abrir el puerto serie.

19
 Imagen 26.

Empecemos a usar la comunicación serie del Arduino: para ello,

necesitamos programar el elemento Serial. Para cualquier operación
emplearemos el «prefijo» Serial, más la operación que hay que
realizar. Al igual que ocurría cuando utilizábamos los pines digitales,
cada operación venía precedida del «prefijo» digital más la operación,
por ejemplo: digitalRead, digitalWrite.

Serial.begin(parámetro);

Instrucción imprescindible para utilizar la comunicación serie,

sirve para inicializar la velocidad (bits/s) del puerto serie, que debe
ser la misma que tiene el monitor serie. Posibles valores:

• 300
• 1200
• 2400
• 4800
• 9600
• 19200
• 38400
• 57600
• 74880
• 115200
• 230400
• 250000

Estas velocidades son estándares; la mayoría de los sistemas utiliza,

por defecto, la velocidad de 9600 bits/s.

20
 Imagen 27.

Por lo tanto, con las velocidades configuradas, vamos a enviar

nuestro primer mensaje del Arduino al PC.

Enviar datos del Arduino al IDE

Disponemos de diferentes instrucciones para enviar datos del Arduino

al exterior por el puerto serie.

Serial.println();

Esta instrucción permite enviar datos por el puerto USB y, una

vez finalizado el envío, realiza un salto de línea (equivalente a pulsar
Enter en una hoja de Word).

Imagen 28.

21
 Imagen 29.

Si cargamos el programa anterior y abrimos el monitor serie, vemos

que cada dos segundos recibimos el mensaje de Arduino.
Entendiendo el mundo y cada mensaje en una línea diferente.

Podemos enviar un texto fijo con la instrucción Serial.println(“”); más

lo que queramos enviar entre comillas.

Serial.print();

Cuenta con el mismo funcionamiento que Serial.println();. La

diferencia radica en que no se produce un salto de línea.

Imagen 30.

Si cargamos este programa y abrimos el monitor serie, podemos

comprobar que, a diferencia del caso anterior, todos los mensajes no
se ven en diferentes líneas, sino en la misma línea, que se va
haciendo cada vez más grande.

Imagen 31.

Ahora que podemos enviar mensajes y visualizar información en

nuestro IDE, y antes de continuar, vamos a aprovechar estas
cuestiones para hacer un repaso de lo que ya hemos visto en el
primer tomo.

22
 Imagen 32. Conexión Pull-Down externa

Imagen 33.

Si recordamos lo que vimos en el primer tomo, un Arduino solo

trabaja con ceros y unos. Al leer una entrada en la que tengamos
5 V, el Arduino lo traduce a un valor binario de 1 y, si hay 0 V, lo
traduce a 0. Para enviar datos que provengan de una función, no se
escriben entre comillas.

Imagen 34.

Si, por el contrario, la conexión es INPUT_PULLUP, estos valores se

invierten.

23
 Imagen 35.

Imagen 36

Si abrimos el monitor serie, los valores se invierten:

Imagen 37.

Con el símbolo, invertimos el valor, por lo que el comportamiento es

el mismo que con una conexión Pull_Down.

24
 Imagen 38.

Imagen 39.

En cuanto a las entradas analógicas, y como el Arduino UNO tiene

una resolución de 10 bits, si conectamos un potenciómetro, la lectura
que se tome varía entre 0 y 1023, que equivale a 0 y 5 V.

Imagen 40.

25
 Imagen 41.

Imagen 42.

Imagen 43.

Si abrimos el monitor serie, comprobamos que, al llegar a 255 la

variable se resetea y se comienza otra vez a contar desde cero; esto
sucedería continuamente.

26
¿Por qué? Un byte está formado por 8 bits, esto significa que
tenemos 256 (28) posibles combinaciones de ceros y unos. Si esto lo
traducimos a números reales, comprendería números entre 0 y 255.
Como la variable es de tipo byte, al llegar a 255 y tratar de
incrementar el valor del contador, este se resetea y vuelve a empezar
desde 0.

Vamos a ir un poco más allá: enviamos el mismo contador, pero

ahora, añadimos, al lado de cada valor, su equivalente en binario.

Imagen 44.

Imagen 45.

Observamos que, al llegar a 255 en binario, se traduce de 8 bits a 1

y, al tratar de incrementar otra vez el contador, este se resetea.

27
Con todos estos conceptos más claros, vamos a sacarle un poco más
de partido a la monitorización de un Arduino.

Imagen 46.

Lo que vamos hacer es que el Arduino nos envíe un mensaje para

saber cuándo se enciende y cuándo se apaga el led.

Imagen 47.

28
 Imagen 48.

Con todo esto, podemos monitorizar el estado del led a través del
IDE. Puede darse la circunstancia de que, al cambiar de estado, nos
envíe dos veces el mensaje de encendido y apagado. Esto es debido
al mecanismo de un interruptor, que introduce interferencias en la
señal; veremos en próximos tomos cómo eliminar esto.

Imagen 49.

Si nos fijamos en la imagen anterior, lo ideal en el cambio de estado

de una señal (de 0 a 5 V y viceversa) es el camino definido por la
línea verde; sin embargo, por el mecanismo del botón que utilizamos,
que no es ideal, describe un camino similar al definido por la línea
roja.

Lo que hace esto es que la señal pase varias veces por el margen que
delimita los dos estados posibles: encendido o apagado, 0 o 1...
Entonces, cabe la posibilidad de tomar lecturas incorrectas. Veremos
cómo solucionar esta cuestión en el próximo tomo, profundizando en
un componente nuevo: el condensador.

Vamos a certificar el margen de 2,5 voltios, ahora que sabemos

enviar información al IDE.

29
Imagen 50.

Imagen 51.

Imagen 52.

Imagen 53.

30
Tenemos conectado el potenciómetro, por un lado, a la entrada
analógica y, por otro, a una entrada digital. Lo que se pretende
demostrar es que los márgenes para cada estado son: de 0 a 2,5 V,
estado = 0, y de 2,5 a 5 V, estado = 1. Si analizamos el
comportamiento, vemos que, entre 2,4 y 2,6, los cambios se pueden
volver difíciles de predecir; es un factor que hay que tener en cuenta
a la hora de diseñar los circuitos con los que trabajemos.

Saltos de línea y tabulaciones

Salto de línea: \n

Al añadir los caracteres \n, el IDE de Arduino lo interpretará como un

salto de línea.

Imagen 54.

Imagen 55.

En el caso del programa anterior, apreciamos que, a pesar de enviar

un mensaje con la instrucción Serial.print(); y no Serial.println();,
tras cada mensaje enviado a través del Arduino, se hace un salto de
línea; esto sucede por incluir, al final del mensaje, la cadena de
caracteres \n. Podemos incluir tantos saltos de línea como
necesitemos.

31
 Imagen 56.

Imagen 57.

Se realizarán tantos saltos de línea como \n se concatenen. Además,

se pueden incluir en cualquier parte del texto.

Imagen 58.

32
 Imagen 59.

Tabulación: \t

Al igual que ocurría con \n, que incluye un salto de línea, con los
caracteres \t se incluye una tabulación.

Imagen 60.

Imagen 61.

33
En resumen, el funcionamiento es igual que \n, pero haciendo una
tabulación y, por supuesto, se pueden usar en un mismo mensaje
varios saltos de líneas y tabulaciones.

Variables

Hasta ahora, hemos visto casi todos los tipos de datos numéricos,
salvo los datos tipo float y double, que permiten almacenar datos con
decimales. En estas variables, se pueden almacenar datos entre
3.4028235x1038 a 3.4028235x1038 y se escriben con punto y no con
coma.

En la introducción de la comunicación serie ya hemos «manejado»

datos no numéricos; por lo tanto, vamos a ver cómo se operan y
almacenan estos nuevos tipos de datos.

Los MCU solo operan con 0 y 1, ¿cómo podemos, entonces,

trabajar con caracteres? En realidad, un MCU no entiende nada
más allá de 0 y 1; por lo tanto, lo que se hizo fue una tabla para
codificar caracteres en dígitos binarios. Es algo similar a lo que ya
hemos visto con respecto a los números naturales y su
correspondiente codificación en binario. Para ello, disponemos de la
tabla ASCII; es una tabla que consta de tres partes: la primera parte
se conoce como «caracteres no imprimibles», la segunda,
«imprimibles» y, la tercera, «extendido». Nosotros vamos a
centrarnos en la segunda parte.

Si buscamos en Internet «tabla ASCII», encontraremos una gran

cantidad de resultados; en la siguiente tabla solo se presenta la parte
de la tabla ASCII que se refiere a los caracteres imprimibles.

34
Código Código Código
numérico Carácter numérico Carácter numérico Carácter
33 ! 65 A 97 a
34 " 66 B 98 b
35 # 67 C 99 c
36 $ 68 D 100 d
37 % 69 E 101 e
38 & 70 F 102 f
39 ´ 71 G 103 g
40 ( 72 H 104 h
41 ) 73 I 105 i
42 * 74 J 106 j
43 + 75 K 107 k
44 , 76 L 108 l
45 - 77 M 109 m
46 . 78 N 110 n
47 / 79 O 111 o
48 0 80 P 112 p
49 1 81 Q 113 q
50 2 82 R 114 r
51 3 83 S 115 s
52 4 84 T 116 t
53 5 85 U 117 u
54 6 86 V 118 v
55 7 87 W 119 w
56 8 88 X 120 x
57 9 89 Y 121 y
58 : 90 Z 122 z
59 ; 91 [ 123 {
60 < 92 \ 124 |
61 = 93 ] 125 }
62 > 94 ^ 126 ~
63 ? 95 _ 127 DEL
64 @ 96

Lo que se hace con la tabla ASCII es asignar valores numéricos a

caracteres, es decir, los codificamos. Aún así, el MCU hace una
segunda codificación, ya que pasa esos números al sistema binario.
Vamos a suponer que enviamos el mensaje «Arduino», según la tabla
sería: 65-114-100-117-105-110-111. Esta sería la codificación
numérica que se envía, pero como el Arduino solo trabaja con 0 y 1
la información con la que realmente trabajaría es la siguiente:
01000001-01110010-01100100-01110101-01101001-01101110-
01101111.

35
 Imagen 62.

Es necesario tener esto en cuenta para cuando trabajemos con

valores numéricos enviados por el puerto serie.

La variable más básica a la hora de trabajar con caracteres es la

variable tipo char (8 bits), la cual puede almacenar un único carácter
de los vistos en la tabla anterior y entre comillas simples.

Imagen 63.

Imagen 64.

Ya podemos almacenar y trabajar con, al menos, un carácter. Si nos

vamos a la tabla y modificamos este por su correspondiente valor
numérico y lo volvemos a almacenar en una variable tipo char, nos
encontraremos con el mismo resultado.

36
 Imagen 65.

Para finalizar, podemos comparar la codificación binaria del número

65 y del carácter A almacenados en sus correspondientes tipos de
datos (numérico y carácter).

Imagen 66.

Imagen 67.

Como conclusión, el MCU codifica un dato en función de su valor y el

tipo de dato. Una variable tipo char solo puede almacenar un
carácter, por lo que, para almacenar más caracteres, debemos
utilizar una variable tipo string, conocida como «cadena de
caracteres», los cuales deben ir definidos entre comillas dobles.

37
 Imagen 68.

Imagen 69.

Si necesitamos enviar un mensaje de texto y otra parte que dependa

del valor de una variable, se puede enviar todo en la misma
instrucción, Serial.print o Serial.println, uniendo todo con el operador
+ siempre y cuando las variables sean de tipo carácter o cadena de
caracteres.

Imagen 70.

Imagen 71.

Si necesitamos enviar un mensaje de texto y una variable de tipo

numérico, es necesario enviar cada parte por separado, tal y como
vemos en el siguiente caso.

38
 Imagen 72.

Imagen 73.

Imagen 74.

Este error aparece por tratar de «sumar» un dato de tipo numérico

con una cadena de texto; al ser formatos diferentes, no se puede
realizar la operación. Lo que tenemos que hacer es enviarlo en
mensajes separados.

39
 Imagen 75.

En este caso, visualizaríamos correctamente el mensaje, no como

anteriormente, porque tratábamos de «sumar» dos datos de
diferente tipo.

Serial.write();

Por último, la instrucción Serial.write(); permite enviar datos, al

igual que Serial.print, sin salto de línea, la diferencia es que solo
permite enviar un único carácter.

Antes de ver cómo podemos recibir datos del IDE y almacenarlos en

el Arduino o realizar cualquier tipo de operación, en función del dato
recibido, vamos a analizar cómo es el proceso de envío de datos.

El envío de un dato del Arduino al exterior se hace carácter a

carácter; cuando se ejecuta la instrucción Serial.print();,
Serial.println(); o Serial.write();, lo que se hace es «trocear» el
mensaje en caracteres y cada uno de ellos se almacena en una
memoria (buffer), la cual se va vaciando en función de la velocidad a
la que hayamos configurado el puerto serie.

El buffer tiene una capacidad de 64 bytes o, lo que es lo mismo,

64 caracteres.

40
 Imagen 76.

Lo entenderemos mejor con un par de ejemplos; esto no solo es

importante para entender el envío de datos, sino la recepción, puesto
que el comportamiento es el mismo.

Imagen 77.

41
Hasta aquí quizás sea fácil de entender, lo que puede resultar un
poco más complicado es el envío de números. Cuando se envía un
número, lo que se hace es traducir cada dígito con la tabla ASCII y,
luego, se envía cada dígito traducido.

Código
numérico Carácter
48 0
49 1
50 2
51 3
52 4
53 5
54 6
55 7
56 8
Es importante tener esta cuestión en cuenta a la hora de recibir
valores del IDE, puesto que, si son números, antes de operar con
ellos, debemos realizar la conversión correcta.

Recibir datos

Para recibir datos, realizamos el proceso inverso, por lo que

disponemos de una segunda memoria, el buffer de entrada, con otras
64 posiciones. Por lo tanto, para saber si nos han enviado datos,
debemos comprobar si en esa memoria hay algún dato.

Serial.availble();

Esta instrucción no lleva parámetros y nos devuelve un 0 si el

buffer de entrada está vacío, lo que significa que no hemos recibido
nada. Si hay datos en el buffer, nos devuelve el número de posiciones
ocupadas.

Imagen 78.

42
Una vez que sepamos si hay datos o no, debemos leerlos y
almacenarlos en una variable, para que se eliminen del buffer de
entrada y dejen espacio a otros datos que se puedan recibir. Si no lo
hacemos, una vez que se llene el buffer de entrada (con 64 datos),
cada carácter que nos envíen se perdería.

Serial.read();

Esta instrucción nos devuelve el dato que se encuentre en la

primera posición del buffer de entrada, es decir, lee el primer dato. Al
leerlo, lo elimina del buffer y, automáticamente, si hay más datos,
suben todos una posición, quedando siempre ocupada la primera
posición por el siguiente dato recibido.

Imagen 79.

Con esto entendido, ya podemos enviar datos del IDE al Arduino y

empezar a procesarlos.

En el siguiente caso, lo que hará el Arduino es reenviar las cadenas

de texto que se envían desde el IDE, devolviéndolas con un texto
añadido: «Mensaje enviado del IDE», más el mensaje.

43
 Imagen 80.

Si enviamos:

Imagen 81.

Recibiremos del Arduino:

Ilustración 82

Antes de continuar, vamos a ver cómo envía y recibe bytes un

Arduino. Volvamos al caso visto anteriormente: enviamos el mensaje
«Arduino», 65-114-100-117-105-110-111 = 01000001-01110010-
01100100-01110101-01101001-01101110-01101111. Entre byte y

44
byte o, lo que es lo mismo, entre carácter y carácter, ponemos un
guion para diferenciar cuándo empieza y acaba uno. En la
comunicación serie pasa algo similar: cada byte viene precedido por
un bit de «inicio» y un bit de «fin», que delimitan cada carácter.

Con esto, ya podemos trabajar con información que el Arduino reciba

por comunicación serie. Esto nos puede permitir controlar el Arduino.

Imagen 83.

Conectamos un led al pin 13 y, si el Arduino recibe el mensaje

«encender», el led se encenderá y, si recibe «apagar», se apagará.

Imagen 84.

45
Antes de enviar un mensaje por el puerto serie y probar si, al enviar
«encender», se enciende y, con «apagar» se apaga, debemos
configurar el monitor serie.

Imagen 85.

Esto se hace para no enviar la cadena junto con un salto de línea, lo

que haría que la comparación que realizamos no se cumpliese.

Vamos a regular un led a través del monitor serie; aquí es donde

debemos tener en cuenta que sean letras, símbolos o números todo
lo que se reciba por el puerto USB; se recibe carácter a carácter y
codificado en la tabla ASCII.

No obstante, recordemos antes cómo trabajaba la instrucción

analogWrite(): el primer parámetro indica sobre qué pin se genera la
señal PWM y, el segundo parámetro, el valor número entre 0 y 255
(con un tamaño de 1 byte). Sabemos cómo se codifican números en
el sistema 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

Código
numérico Carácter
48 0
49 1
50 2
51 3
52 4
53 5
54 6
55 7
56 8

Por ejemplo: el número 127 correspondería en binario a: 01111111.

El problema radica en que, por el puerto serie, vamos a recibir dígito
a dígito y codificado según la tabla ASCII.

46
 Imagen 86.

Por lo tanto, si recibimos por el puerto serie el valor 127, ya no es un

byte, sino tres bytes (00110001 00110010 00110111). ¿Cómo
solucionamos esto? Lo que tenemos que hacer es almacenarlo en
una cadena de caracteres y luego convertirlo en un número entero.

toInt();

Esta función transforma una cadena de caracteres (en la que

los caracteres solo pueden ser números) a su dato numérico
equivalente.

Imagen 87.

Si cargamos este programa y conectamos el led al pin 11,

observaremos cómo, si enviamos un valor entre 0 y 255, el led se
regula, como si tuviese conectado un potenciómetro.

47
Ejercicios propuestos:

3. Conectar un led, un botón y un pulsador a un Arduino. Configurar

tres modos de funcionamiento que se puedan controlar desde el IDE:
modo 1, el led parpadea cada segundo; modo 2, el led se puede
encender o apagar con el botón; modo 3, el led se puede regular con
el potenciómetro.

4-Dos Arduinos: el Arduino A recibe órdenes de encendido y apagado

de un led por el puerto serie; el Arduino B tiene conectado el led. Si
el A recibe el mensaje de encender, el B debe encender el led; si el A
recibe el mensaje de apagar, el B debe apagar el led.

5. Dos Arduinos: el Arduino A recibe el valor de regulación de un led y

el B tiene conectado el led. El Arduino B debe regular el led en
función del valor que se envíe por el puerto serie al Arduino A.

6. Dos Arduinos: el Arduino A se comunica por el puerto serie con el

IDE y el Arduino B tiene conectado un botón. En el momento en el
que se pulse o se deje de pulsar el botón del B, el A debe enviar el
mensaje correspondiente del evento que acaba de ocurrir. (Solo ante
un cambio de estado).

7. Dos Arduinos: el Arduino A se comunica por el puerto serie con el

IDE y tiene conectado un potenciómetro; por otro lado, el Arduino B
tiene conectado un botón. Cada vez que se pulse el botón del Arduino
B, el A debe enviar al IDE el valor actual del potenciómetro. Solo una
vez por cada pulsación.

8. Traductor de caracteres. Enviar un carácter y que el Arduino nos

devuelva su posición en la tabla ASCII y su codificación en binario.
13
14
15
16
17
18
19
20
21
22
23
24
25
26

48
3. Conectar un led, un botón y un pulsador a un Arduino.
Configurar tres modos de funcionamiento que se puedan
controlar desde el IDE: modo 1, el led parpadea cada
segundo; modo 2, el led se puede encender o apagar con el
botón; modo 3, el led se puede regular con el
potenciómetro.

49
Continúaà

50
4. Dos Arduinos: el Arduino A recibe órdenes de encendido y
apagado de un led por el puerto serie y el Arduino B tiene
conectado el led. Si el A recibe el mensaje de encender, el B
debe encender el led; si el A recibe el mensaje de apagar, el B
debe apagar el led.

A B

51
B

52
5. Dos Arduinos: el Arduino A recibe el valor de regulación de
un led y el B tiene conectado el led. El Arduino B debe regular
el led en función del valor que se envíe por el puerto serie al
Arduino A.

A B

53
6. Dos Arduinos: el Arduino A se comunica por el puerto serie
con el IDE y el Arduino B tiene conectado un botón. En el
momento en el que se pulse o se deje de pulsar el botón del B,
el A debe enviar el mensaje correspondiente del evento que
acaba de ocurrir. (Solo ante un cambio de estado).

A B

54
7-Dos Arduinos: el Arduino A se comunica por el puerto serie
con el IDE y tiene conectado un potenciómetro; por otro lado,
el Arduino B tiene conectado un botón. Cada vez que se pulse
el botón del Arduino B, el A debe enviar al IDE el valor actual
del potenciómetro. Solo una vez por cada pulsación.

B
A

55
8Traductor de caracteres. Enviar un carácter y que el Arduino
nos devuelva su posición en la tabla ASCII y su codificación en
binario.

56
Comunicación serie entre Arduinos

En este capítulo, veremos cómo comunicar dos Arduinos por el puerto

serie.

A B

Imagen 88.

Para comunicar dos Arduinos por el puerto serie, es necesario

conectar el pin RX del A con el pin TX del B y viceversa (siempre y
cuando no se use el puerto serie a través del IDE). Asimismo, si no
comparten la misma fuente de alimentación, es necesario conectar
los pines GND de cada uno.

A B

Imagen 89.

Lo que vamos a realizar, en este caso, es el control del led del

Arduino A, en función del mensaje enviado por el Arduino B.

57
 A

Imagen 90.

Imagen 91.

Vamos ahora a tratar de visualizar los mensajes que se reciben de

otro Arduino por el monitor serie del IDE.

A
B

Imagen 92.

58
Para esto, lo primero que tenemos que hacer es cargar el programa a
cada Arduino por separado y, luego, conectarlos. Hay que tener en
cuenta que el monitor serie utiliza el mismo canal y, si hay una
comunicación por los pines RX y TX proveniente de otro Arduino, no
vamos a poder cargar el programa.

Imagen 93.

Imagen 94.

En consecuencia, a cada segundo y si conectamos el Arduino A al

monitor serie, visualizaremos H o L.

A continuación, vamos a enviar un mensaje del monitor a dos

Arduinos; para comprobar que funciona correctamente, se va a
controlar un led de cada Arduino. Si se envía un mensaje por el
monitor de «encender», se deben encender los dos leds y, si se envía
«apagar», se deben apagar los dos.

59
 A B

Imagen 95.

Al igual que ocurría anteriormente, cargamos el programa a cada

Arduino y, después, realizamos las conexiones.

Imagen 96.

60
 B

Imagen 97.

En los dos últimos casos, debido a que el Arduino UNO solo dispone
de un puerto serie, tenemos que cargar primero los programas y,
después, conectar los circuitos. Si, por ejemplo, queremos establecer
un chat entre dos ordenadores a través del IDE de Arduino, no
podríamos hacerlo; en cambio, si dispusiéramos de otro Arduino,
como el Arduino Mega 2560, que dispone de varios puertos, esto ya
sería posible.

Imagen 98.

61
Como el Arduino Mega 2560 dispone de hasta cuatro puertos serie,
podemos utilizar uno para comunicar el Arduino con el IDE de su PC
y, otro, para la comunicación con el otro Arduino.

¿Con el Arduino UNO no podemos hacer un chat? Sí, pero, para

ello, necesitamos una librería. Es la primera vez que utilizamos una
librería; aún así, gracias al primer tomo, sabemos que una librería es
un programa que tenemos o podemos tener instalado en nuestro IDE
y que nos facilita la programación.

Una librería pone a nuestra disposición una serie de funciones con

una programación compleja, las cuales podemos utilizar facilitar la
tarea de programación. Vamos a ver qué operaciones podemos hacer
con una librería; para ello, necesitamos ver otro apartado del IDE de
Arduino.

Imagen 99.

Si nos vamos a la barra de menú y al apartado «Programa», se abre

un desplegable. En él, encontramos un apartado que pone «Incluir
Librería».

Imagen 100.

Si abrimos ese segundo desplegable encontramos tres apartados: el

primero, «Gestionar Librerías», abre un repositorio que nos permite

62
buscar una librería en concreto; si hemos encontrado algún caso
práctico en una web y vemos que necesitamos una librería, podemos
probar a buscarla en este apartado.

Imagen 101.

Disponemos de dos filtros de búsqueda e incluso un campo para

escribir la librería que necesitamos. La instalación es sencilla:
simplemente seleccionamos una librería, en el margen inferior
derecho nos aparecen las versiones disponibles, en un desplegable, y
un botón para instalar la versión seleccionada.

Imagen 102.

Con pulsar el botón de instalar se inicia el proceso de instalación, que

tardará unos pocos segundos en finalizar. Si, por el contrario,
queremos instalar una librería que hemos descargado de alguna web,
seleccionamos el apartado de «Añadir librería .ZIP…», buscamos el
archivo descargado a través de un directorio y, con seleccionarlo y
aceptar, se instala la librería.

Por último, nos aparece un listado con todas las librerías instaladas;
muchas de ellas ya vienen instaladas al descargar el IDE de Arduino,
son las que se conocen como librerías oficiales de Arduino.

63
Las librerías que instalemos por nuestra cuenta se incluirán en esta
lista de librerías, pero con un encabezado diferente. Ahora que
sabemos cómo instalar librerías, tenemos que saber utilizarlas para
tener acceso a sus funciones.
Para ello, debemos declarar qué librería o librerías vamos a utilizar;
una forma sencilla de hacerlo es seleccionarla de la lista. Para el caso
que nos ocupa, necesitamos la librería «SoftwareSerial».

Imagen 103.

Si la seleccionamos y volvemos a nuestro programa, veremos cómo

se hace referencia a ella al inicio.

Imagen 104.

Podemos referenciar una librería de esta manera o podemos escribir

nosotros mismos #include <nombre_librería.h>. Sea cual sea la
forma en la que lo hagamos, esto debe incluirse siempre en la parte
superior antes de cualquier línea de código.

64
Cada librería implementa sus propias funciones o instrucciones, por lo
que cada librería «es un mundo». Como al principio puede resultar
complejo entender cada librería, disponemos de ejemplos para
asimilar su funcionamiento.

Imagen 105.

Si nos vamos a la barra de menú y al apartado «Archivo», se nos

abrirá un desplegable. Si accedemos a «Ejemplos», se nos abre un
segundo desplegable en el cual encontraremos ejemplos sobre cada
librería.

Imagen 106.

Los ejemplos no son más que programas que podemos probar o

modificar para entender el funcionamiento de las funciones (o
instrucciones) que aporta cada librería.

Empecemos con la librería SoftwareSerial; esta librería nos permite

definir uno o varios puertos de comunicación serie adicionales a los
que incorpore cada Arduino. Podemos entonces solventar el problema

65
de utilizar un puerto del Arduino UNO para la comunicación con el IDE
y, otro, para la comunicación con otro Arduino.

En consecuencia, podemos realizar un chat entre dos ordenadores a

través de dos Arduinos y el IDE de Arduino. Lo primero que tenemos
que hacer es definir qué pines se van a comportar como un puerto
serie.

Imagen 107.

Creamos una instancia con SoftwareSerial y, a continuación,

definimos un nombre para el nuevo puerto serie. En este caso, lo
llamamos «mySerial» y, por último, indicamos qué pin sirve para
transmitir y cuál para recibir; 11 y 10, respectivamente.

Con este paso, ya podemos trabajar con este puerto igual que hemos
hecho con el Serial; la diferencia es que el prefijo es mySerial:
mySerial.print();, mySerial.println();, mySerial.available();.

Vamos a cargar el mismo programa a los dos Arduinos, puesto que

los dos tienen que realizar la misma operación: recibir los mensajes
del IDE (por el puerto Serial) y enviarlos al otro Arduino (por el
mySerial) y, los mensajes que reciban del otro Arduino (por el
mySerial) enviarlos al IDE (por el Serial). Ambos utilizarán los pines
10 (RX) y 11(TX) como nuevo puerto.

66
 A
B

Imagen 108.

Para una correcta comunicación, se debe conectar el pin 10 del

Arduino A con el 11 del B y el 11 del A con el 10 del B, ya que, por el
11, cada uno de ellos transmite datos y, por el 10, cada uno de ellos
recibe datos.

Imagen 109.

67
Cargamos el programa anterior a cada Arduino, conectamos entre sí
los Arduinos y cada uno a un PC. Abrimos en cada PC el IDE de
Arduino y empezamos a enviar mensajes. Al enviar mensajes,
comprobamos que, los que nosotros enviamos, se visualizan en
nuestro monitor en el margen derecho y, los que nos envía el otro
PC, en el margen izquierdo; se ha programado cada Arduino para
simular el funcionamiento de un chat.

Funciones
Una función no es más que un trozo de código que se identifica con
un nombre y que, para que se ejecute, debe ser «llamado». Por lo
tanto, podemos escribir líneas de código fuera del void setup y void
loop, que deben estar identificadas por un nombre y que se
ejecutarán si se las «llama» desde otra parte del programa.

Imagen 110.

Si abrimos el monitor serie, veremos la siguiente secuencia de

mensajes.

68
 Imagen 111.

Lo que vemos con este primer caso es cómo, al «llamar» a una

función, el programa «sale» de la ejecución de líneas de código del
programa principal (void loop) y ejecuta otra parte de código.

Imagen 112.

En la imagen anterior, vemos cómo se representa la llamada a una

función en un diagrama de flujo. Para indicar que se llama a una
función, se utiliza un rectángulo con doble rayado y se escribe el
nombre de la función.

Para representar las operaciones (recuadros) que se realizan dentro

de cada función, se engloban entre dos elipses. La de apertura

69
incluye el nombre de la función y, la de cierre, el nombre de retorno.
En cuanto al nombre de una función, debemos seguir las mismas
normas que en la declaración de funciones.

Las funciones nos permiten «trocear» un programa en partes e

identificarlas según la operación que se realice en cada una de ellas.
Esto nos permite escribir programas mucho más legibles, además de
optimizar la programación. Si, a lo largo de un programa, repetimos
una serie de operaciones, podemos englobarlas todas en una función
y «llamar» a la función que sea necesaria.

Por consiguiente, las funciones son un elemento importante para

optimizar un programa y hacerlo más legible.

Ejercicios propuestos:

7. Crear una función para que un led parpadee cada segundo.

8.Con una función, encender un led si se ha pulsado un botón.

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

70
7. Crear una función para que un led parpadee cada segundo.
55
56

57
58

59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

71
8. Con una función, encender un led si se ha pulsado un botón.
79

80
81
82

83
84
85
86
87
88
89
90
91
92
93
94

72
Funciones con valor de retorno

La función tipo void loop ejecutaba el código que había entre sus
llaves y, al finalizar, volvía a la línea desde donde había sido
«llamada». Las funciones permiten devolver un valor (tipo string,
int...) en la línea en la que son «llamadas».

Para ello, las funciones no deben ser declaradas tipo void, sino que
deben ser declaradas como algún tipo de variable, es decir: tipo int,
string, etc.

Al declarar así una función, el valor que devuelve es del tipo que sea
la función, es decir: una función tipo int devuelve un valor tipo int. Es
«obligación» de la persona que programa almacenar el valor que
devuelve la función.

Por último, ¿cómo se hace para devolver un valor? Para ello, se

implementa la instrucción return, la cual indica que el valor que la
acompaña es el que se devuelve. Veamos todo esto en un ejemplo.

Imagen 113.

73
 Imagen 114.

Ejercicios propuestos:

9. Crear una función que, al recibir un mensaje por el monitor serie, lo

almacene y, al finalizar, devuelva ese mensaje al programa principal,
para visualizarlo en el monitor serie.

74
9. Crear una función que, al recibir un mensaje por el
monitor serie, lo almacene y, al finalizar, devuelva ese
mensaje al programa principal para visualizarlo en el
monitor serie.

75
Pasar parámetros a una función

Una función no solo puede devolver datos, sino que, al ser llamada,
se le pueden pasar datos. Para ello, debe haber una concordancia
entre el valor que se envía y la variable en la que se almacena, es
decir, ambos deben ser del mismo tipo.

Imagen 115.

Imagen 116.

76
Podemos pasar a una función el número de parámetros que
necesitemos y todos los datos pueden ser, o no, del mismo tipo.
Mantenemos el mismo circuito y cargamos el siguiente programa.

Imagen 117.

Ejercicios propuestos:

10. Pasar como parámetros el valor de una entrada analógica y de un

pulsador, para que la función regule el led si el pulsador está pulsado
y lo apague si no está pulsado.

11. Crear funciones para establecer un chat mediante el puerto serie

con otro Arduino.

77
10 Pasar como parámetros el valor de una entrada analógica
y de un pulsador, para que la función regule el led si el
pulsador está pulsado y lo apague si no está pulsado.

78
11. Crear funciones para establecer un chat mediante el puerto
serie con otro Arduino.

79
El IDE de Arduino dispone de una herramienta que permite escribir
funciones en otras «ventanas» y así dejar la «hoja» en la que
escribimos el programa principal para: declarar librerías, variables y
las partes básicas del programa (loop y setup).

Imagen 118.

Si seleccionamos, en el desplegable, «Nueva Pestaña», en la parte

inferior del IDE, antes de la consola, surge una ventana como la
siguiente.

Imagen 119.

Cuando creamos una pestaña, el nombre de esta sigue las mismas

reglas que las de los nombres de las variables.

Imagen 120.

80
 Imagen 121.

Entonces, se crea una pestaña en blanco con el nombre que le

asignamos. El único funcionamiento de esta herramienta es separar
el programa en «hojas» diferentes para hacerlo más legible; en
realidad, no cambia el funcionamiento del programa.

Interrupciones
Este tipo de «mecanismo» interrumpe la ejecución normal de un
programa por la atención de un evento. Los eventos que puede
atender un Arduino son:

Por una señal externa.

Por tiempo.

Las interrupciones son similares a una función, la diferencia reside en

que la funciones que hemos visto hasta ahora tenían que ser
«llamadas» por otra parte del programa. Una interrupción no es más
que una función que se ejecutará, no por que sea «llamada», sino
porque se ha configurado el motivo por el cual se debe ejecutar
(atendiendo al tipo de evento y sus características).

Interrupciones por señal

Estas interrupciones se utilizan para dar una respuesta rápida a

eventos cortos y rápidos.

¿Cómo se configura una interrupción por un evento externo?

Este tipo de interrupciones necesitan configurar tres parámetros: el
primero es en qué pin se va ha producir el evento; el segundo, el
nombre de la función que se va a ejecutar y, el tercero, las
características del evento.

attachInterrupt(Pin_interrupción,nombre_función,tipo_evento);

Con esta instrucción, podemos configurar cada uno de los tres

parámetros de una interrupción por un evento externo.

81
No se pueden atender eventos en todos los pines: en el caso del
Arduino UNO, disponemos de dos eventos por interrupción en los
pines 2 y 3, que se configuran como interrupción 0 e interrupción 1,
respectivamente.

Una vez entendido el uso de las interrupciones y tras encontrarles

utilidad en nuestros proyectos, puede ser una característica que nos
haga decantarnos por un Arduino u otro. Si, por ejemplo,
necesitamos atender a más de dos eventos externos con
interrupciones, el Arduino UNO no es la mejor opción y podemos
optar, por ejemplo, por el Arduino DUE.

El nombre de la función que se va a ejecutar si se cumple el evento

queda a nuestra elección. Una vez definido el pin en el que se va a
producir el evento y el nombre de la función que se tiene que
ejecutar, si se produce el evento, queda por definir qué evento en
concreto debe ocurrir en el pin indicado para que se ejecute la
función.

Los eventos que puede atender una interrupción son los que
presentamos a continuación; vamos a suponer que el evento
sucederá en el pin 2, es decir, la interrupción 0 y la función que se
tiene que ejecutar tiene el nombre de «funcion_evento»:

LOW: si configuramos la interrupción con este parámetro, se

ejecutará la función «funcion_evento» cuando la entrada del pin 2
reciba una señal de 0 V.

CHANGE: si configuramos la interrupción con este parámetro, se

ejecutará la función «funcion_evento» cuando la entrada del pin 2
cambie de estado, tanto si es de 0 a 5 voltios (flanco subida) como
de 5 a 0 voltios (flanco bajada).

RISING: si configuramos la interrupción con este parámetro, se

ejecutará la función «funcion_evento» cuando la entrada del pin 2
cambie de 0 a 5 voltios (flanco subida).

FALLING: si configuramos la interrupción con este parámetro, se

ejecutará la función «funcion_evento» cuando la entrada del pin 2
cambie de 5 a 0 voltios (flanco bajada).

HIGH: si configuramos la interrupción con este parámetro, se

ejecutará la función «funcion_evento» cuando la entrada del pin 2
reciba una señal de 5 V. No obstante, el Arduino UNO no dispone de
este tipo de evento.

82
Vamos a realizar un ejemplo para entender cómo funciona una de
ellas, ya que el resto funciona exactamente igual; la diferencia reside
en el evento que se atiende.

Imagen 122.

Imagen 123.

El funcionamiento ideal sería que, al dejar de pulsar el botón, si el led

estaba encendido, se apague, y viceversa, pero, en ocasiones,
veremos que no se cumple; esto se debe a que se ejecuta varias
veces la interrupción.

83
 Imagen 124.

Si recordamos, debido al mecanismo de un botón, la señal sufre

perturbaciones; por lo tanto, puede ser que, aunque nosotros
pulsemos una vez, el Arduino reciba una señal que le haga «creer»
que se acaban de realizar dos o más pulsaciones.

La función de una interrupción no es la de ejecutar un programa

«largo»; está pensado para atender lo más rápido posible a un
evento y realizar un par de tareas necesarias.

Dentro de las interrupciones, instrucciones como delay no funcionan;

tampoco es recomendable usar el puerto serie (por su «lentitud»).

Para variables que dependan de modificar su valor por una

interrupción, deben ser declaradas como volatile:

No es un tipo de variable, sino una directiva para el compilador.

En algunas circunstancias, puede haber un conflicto con las

variables, por lo que se recomienda usar volatile.

volatile tipo_variable nombre_variable;

Disponemos de más instrucciones para trabajar con interrupciones.

noInterrupts(), desactiva cualquier interrupción del programa.

Interrupts(), para los casos en los que se han deshabilitado las

interrupciones con la instrucción anterior y queremos que se
vuelvan a activar.

detachInterrupt(), desactiva la interrupción indicada:

detachInterrupt ( interrupción )

detachInterrupt (digitalPinToInterrupt (pin));

detachInterrupt ( pin ) (solo arduino DUE y CERO)

84
Interrupciones por tiempo

Nos permiten configurar operaciones que se deben ejecutar cada

cierto tiempo. Son conocidas como Timers. Para ello, necesitamos
instalar la librería «TimerOne.h».

Imagen 125.

Imagen 126.

Imagen 127.

Ejercicios propuestos:

12. Conectar un led, un botón y un potenciómetro. El led, por

defecto, debe parpadear cada 2 segundos mediante una
interrupción de tiempo. Sin embargo, este tiempo puede cambiar
si se produce una interrupción por un evento externo, proveniente

85
del botón; si se da este caso, se regulará el tiempo de interrupción
con el valor del potenciómetro entre un valor de 0,2 y 2 segundos
proporcional a la medida del potenciómetro.

86
Fritzing
Fritzing es una herramienta que nos permite graficar los circuitos que
realizamos mediante un entorno sencillo e intuitivo. Todas las
imágenes de circuitos que se muestran en esta serie de ejemplares
fueron creadas en esta herramienta.

En muchos casos, necesitamos documentar algún circuito que

montemos y, si no conocemos los símbolos que se suelen utilizar en
electrónica, usar programas específicos o, simplemente, necesitamos
un esquema sencillo para nosotros, Fritzing es la herramienta que
precisamos.

La podemos descargar de forma gratuita desde su página web

(disponible para cualquier sistema operativo)
http://fritzing.org/download/. Con el entorno descargado nos
disponemos a realizar nuestro primer circuito.

Imagen 128.

En el menú superior accedemos al apartado «Protoboard».

87
 Imagen 129.

En la parte de lienzo es donde incorporamos los componentes y

trazamos las conexiones. Para realizar una conexión con un cable,
basta con seleccionar cualquier punto de conexión y desplazar el
ratón.

Imagen 130.

Esto lo podemos realizar con cualquier punto de conexión de

cualquier componente que incorporemos al lienzo. Existen
componentes que permiten algún tipo de configuración gráfica, por
ejemplo: rotación, color, etc. Según el componente, tendremos
diferentes opciones, pero todos se seleccionan de la misma forma:
hacemos clic en el componente y, después, pulsamos el botón
derecho de nuestro ratón.

88
 Imagen 131.

Para incorporar componentes, disponemos, en el margen derecho, de

un conjunto de opciones.

Imagen 132.

Si no encontramos el elemento que necesitamos, podemos buscarlo

en nuestro navegador web. Posiblemente alguien lo haya creado y lo
haya puesto a nuestra disposición.

89
 Imagen 133.

Si queremos generar la imagen del circuito que acabamos de crear,

basta con ir al menú del programa, Archivo à Exportar à Imagen, y
podemos guardar el resultado para incluirlo, por ejemplo, en una hoja
de Word. Fritzing dispone de más apartados, pero, de momento, con
este primer recorrido ya podemos dibujar nuestros circuitos.

Simuladores
Los simuladores son ideales para cuando no disponemos de un
Arduino, pero necesitamos realizar pruebas o, incluso, queremos
desarrollar un proyecto, pero, por seguridad y antes de cargarlo al
Arduino, queremos probarlo si peligro.

123D Circuits es una plataforma que nos permite simular circuitos y

programas. Es una herramienta online (https://circuits.io/) en la que
necesitamos crear un usuario. Una vez registrados, podemos
empezar a simular; para ello, lo primero será incorporar los
componentes.

90
 Imagen 134.

Al igual que en Fritzing, disponemos de un lienzo y el modo de

trabajo es muy similar. En la parte superior derecha, encontramos un
botón para añadir componentes: «+ Components».

Imagen 135.

Para incluir componentes, debemos arrastrarlos y podremos

configurar ciertas características.

Imagen 136.

91
 Imagen 137.

Con el Arduino en el lienzo y las conexiones realizadas, solo nos

queda programarlo. Al lado del botón «+ Components», tenemos el
«Code Editor», que nos abre una ventana como la de la imagen
anterior, en la que podemos escribir el programa y cargarlo al
Arduino.

92