Manual Imprescindible

Arduino Práctico
Edición 2022

Daniel Lozano Equisoain MULTIMEDIA

í ndice
de contenidos

Cómo usar este libro............................................................................. 12

Destinatarios de este libro................................................................................................13
Organización del libro......................................................................................................13
Convenios empleados......................................................................................................13
Ejemplos del libro..............................................................................................................14

1. Introducción a Arduino..................................................................... 16
¿Qué es Arduino?..............................................................................................................17
Shields............................................................................................................................21
Arduino Uno......................................................................................................................23
Instalación del entorno de programación......................................................................25
Entorno de programación................................................................................................29
Protoboard o breadboard......................................................................................................36
Primer sketch.......................................................................................................................39

2. Conceptos básicos. El lenguaje de programación........................... 42

General................................................................................................................................43
Aspecto de un sketch....................................................................................................43
Estilos en la programación.........................................................................................45
Comentarios.................................................................................................................45

Índice de contenidos 7
 Variables........................................................................................................................46 6. Pantallas.......................................................................................... 140
Modificadores..............................................................................................................50
Constantes enteras ......................................................................................................51 ¿Qué es un LCD?.............................................................................................................141
Operaciones.......................................................................................................................52 Montaje y programación................................................................................................142
Bloques de control.............................................................................................................55 Display LCD manejado por I2C.....................................................................................148
Estructura if..................................................................................................................56 El bus I2C....................................................................................................................148
Estructura switch.........................................................................................................57 Programación de un LCD a través de I2C.............................................................150
Estructura goto.............................................................................................................58 Definiendo nuestros propios caracteres.......................................................................151
For..................................................................................................................................59
Estructura while...........................................................................................................60 7. Actuadores...................................................................................... 154
Estructura do...while...................................................................................................61 ¿Qué es un actuador?.....................................................................................................155
Funciones............................................................................................................................61 Tipos de actuadores........................................................................................................155
Include y define.................................................................................................................64 Movimiento de un servo a través de un potenciómetro......................................162
Unificando lo estudiado...................................................................................................64
Primer programa.........................................................................................................67 8. Sensores I........................................................................................ 164
3. Entrada de datos analógicos y digitales........................................... 74 Fotorresistores.................................................................................................................166
Tipos de fotorresistores.............................................................................................167
Configuración de entradas y salidas..............................................................................75 Teremín digital...........................................................................................................170
Resistencias pull-up y pull-down.................................................................................76 Sensor de audio...............................................................................................................173
Entradas digitales........................................................................................................78 Sensores posición y movimiento de dispositivo.........................................................176
Configuración entradas digitales..............................................................................79 Acelerómetros y giroscopios....................................................................................176
Salidas digitales...........................................................................................................85 Sensores de posición, vibración e inclinación.......................................................180
Entradas analógicas.....................................................................................................88 Sensor de humos........................................................................................................186
Salidas analógicas........................................................................................................90
9. Sensores II....................................................................................... 196
4. Jugando con ledes............................................................................ 96
Sensor de temperatura...................................................................................................197
¿Qué es un diodo led?......................................................................................................97
Programación del sensor DHT11 utilizando librerías..........................................199
El display ánodo común..............................................................................................99 Keypad................................................................................................................................204
El display cátodo común..............................................................................................99
Ultrasonidos.....................................................................................................................209
Ejercicio práctico utilizando bucles........................................................................106
Control de salidas PWM con ledes.........................................................................108 ¿Cómo funciona un sensor de ultrasonidos?........................................................211
Detector de movimiento PIR.........................................................................................214
5. Interfaz serie. Comunicación entre dispositivos............................. 116 Lectura de tarjetas por RFID..........................................................................................219

Envío y recepción............................................................................................................119 10. Infrarrojos...................................................................................... 230

Ampliando conocimientos del envío de mensaje serial......................................119
Recepción de mensaje serie......................................................................................123 11. Memorias...................................................................................... 244
Comunicación con el PC................................................................................................127
Memorias Flash...............................................................................................................246
Comunicación Arduino‑PC......................................................................................127
Comunicación PC‑Arduino.....................................................................................130 Memoria EEPROM.........................................................................................................249
Comunicación entre Arduinos......................................................................................134 Memorias SD....................................................................................................................252
Comunicación unidireccional..................................................................................135 Información de las tarjetas SD.......................................................................................254
Comunicación bidireccional....................................................................................136 Escritura y lectura en tarjetas SD............................................................................255

8 Índice de contenidos Índice de contenidos 9

12. Bluetooth...................................................................................... 264
¿Qué significa Bluetooth?..............................................................................................265
¿Cómo funciona?.......................................................................................................266
Módulos Bluetooth para Arduino................................................................................268
Configuración del módulo Bluetooth..........................................................................269
Envío y recepción de datos entre un terminal y el módulo HC‑06..........................274
Control de ledes vía Bluetooth......................................................................................275

13. Internet de las cosas..................................................................... 278

¿Qué supondría tener todas las cosas interconectadas?............................................280
Primer programa con el esp‑01.....................................................................................291
Control de ledes mediante página web.......................................................................299
¿Qué es y para qué sirve HTML?..................................................................................299

Apéndice A. Resistencias.................................................................... 311

Resistencias en serie........................................................................................................312
Resistencias en paralelo..................................................................................................313
Codificación de los valores de las resistencias............................................................313
Resistencias SMT.......................................................................................................313
Resistencias through-hole...........................................................................................314
Resistencias SIL..........................................................................................................316

Apéndice B. Sistemas numéricos........................................................ 317

Sistema binario................................................................................................................317
Operaciones binarias.................................................................................................320
Números negativos...................................................................................................321
Sistemas de representación......................................................................................322
Sistema hexadecimal.......................................................................................................325

Índice alfabético.................................................................................. 328

10 Índice de contenidos
con unas funcionalidades concretas, que cubriera una serie de necesidades que
ninguna otra cubre y ya estaríamos creando una placa ‑duino. En relación a esto,
al ser de libre distribución, el fabricante Arduino siempre está abierto a nuevas
sugerencias e incluso a incluir placas realizadas por la comunidad en su listado
de placas oficiales.

Figura 1.2. Placa Arduino Uno R3.

Shields
Para facilitar el montaje de piezas que requieran conexiones más complejas o
múltiples (como pueden ser pantallas TFT), Arduino pone a disposición de los
usuarios una serie de placas con una serie de componentes ya montados que
facilitan el ensamblaje y la conexión de la placa de Arduino, de modo que se
montan sobre estas y son operables nada más ser colocadas. A estos bloques se
les llama shields (escudos) y los hay de diferentes tipos (Joystick, Ethernet, etc.).

Figura 1.1. Placas Arduino Nano, Mega y Lilypad.

La gran mayoría de estas placas no oficiales tienen una estructura prácticamente

igual que las placas Arduino en cuanto a disposición de pines, de tal forma que Figura 1.3. Shields Joystick y Ethernet.
sea fácil incorporarles complementos como los shields por ejemplo (que se descri-
birán más adelante). Normalmente las tarjetas shield suelen llevar una funcionalidad incorporada, es
Pese a que se ha visto que existen diferentes modelos de placas, nos centraremos decir, en la propia placa shield suele incluirse una serie de componentes embe-
en una de ellas, la Arduino Uno R3 (es decir, revisión 3). Aunque la versión no bidos (ya instalados) que son los que contienen la funcionalidad, como por
vaya a ser relevante en este libro, se puede saber la versión de la placa obser- ejemplo la shield Joystick, que se conecta a las entradas analógicas de la placa
vando el reverso de la misma (si no aparece nada es probable que se disponga Arduino y dispone de cuatro pulsadores conectados a unos pines digitales, o
de la R1, revisión 1). la placa Ethernet, que lleva el adaptador para la clavija RJ45 (cable de conexión

20 Capítulo 1 Introducción a Arduino 21

4
Mediante los capítulos anteriores, hemos visto cómo interactuar con el terminal
serie de forma básica y cómo funcionan las entradas y salidas de la placa. En
este capítulo vamos a conocer uno de los componentes principales que se usan
en los proyectos de Arduino, los ledes.
Se van a estudiar los distintos tipos que existen y se verán algunos ejemplos de
su uso, tanto utilizando las señales digitales, como las señales analógicas.

Jugando con ledes ¿Qué es un diodo led?

Si alguna vez ha visto unas pequeñas luces de diferentes colores que se encienden
y apagan, en algún circuito electrónico, ha visto los diodos led en funcionamiento.

Figura 4.1. Esquemático de un diodo led.

Un diodo led contiene de 2 a N pines, en función del tipo de led, en donde uno
de ellos será el ánodo y otro el cátodo. El ánodo será el pin que se conecte a la
señal de tensión, mientras que el cátodo será el que se conecte a tierra.
Trabaja como un diodo común, pero que, al ser atravesado por la corriente eléc-
En este capítulo aprenderás: trica, emite luz. Existen diodos led de varios colores que dependen del material
con el cual fueron construidos. Hay de color rojo, verde, amarillo, ámbar, infra-
rrojo, entre otros.
• Conocer los distintos tipos de led.
• Polarizar correctamente un led.
• Controlar las salidas PWM con ledes.
• Descubrir el display de 7 segmentos.

Figura 4.2. Distintos tipos de diodos led.

while (inputStream.available() > 0) {
int numBytes = inputStream.read(readBuffer); NOTA:
System.out.print(new String(readBuffer).trim());
}
Por el momento no se puede trabajar con comunicaciones serie en Processing si se está
en un entorno de 64 bits.
En un programa "útil" lo que se haría sería, en este caso, preservar lo leído e ir
procesándolo en lugar de mostrarlo por pantalla. Tras descomprimir el archivo, al ejecutar el programa veremos que es bastante
En cuanto a la parte Arduino, como montaje físico, no hay nada más que conectar semejante al entorno de programación Arduino (ya que es su descendencia). Lo
la placa al ordenador (al puerto que hayamos informado en el programa) y cargar que haremos es un programa con dos círculos que, al pasar el ratón por encima
el siguiente sketch: de ellos, enciendan distintos ledes. El programa en Processing sería:
void setup() { import processing.serial.*;
Serial.begin(9600);
} Serial myPort; // objeto para trabajar con el puerto serie
void loop() {
Serial.print("Datos variados"); int circleX, circleY; // posición del círculo 1
} int circle2X, circle2Y; // posición del círculo 2
int circleSize = 50; // diámetro
//colores a utilizar
Si ejecutamos el programa Java tras haber cargado el sketch, veremos cómo en color redColor;
la salida por defecto de nuestro editor Java irá apareciendo el mensaje indicado color yellowColor;
en el sketch. color baseColor;

boolean circleOver = false;

boolean circle2Over = false;
Comunicación PC‑Arduino
void setup() {
En la comunicación del PC con Arduino, podremos enviar datos desde el PC hacia size(340, 260); //tamaño de pantalla
//definición de los colores
la placa como si fuera una entrada y así poder ejecutar unas instrucciones u otras. redColor = color(255,0,0);
Podríamos tener por ejemplo un programa que controlara las persianas de casa yellowColor = color(0,255,100);
y, mediante una barra de desplazamiento en pantalla, pudiéramos subir y bajar baseColor = color(102);
//colocación de los círculos
las persianas dependiendo de la posición de la barra. La manera de trabajar con circleX = width/2-circleSize/2-10;
Java sería muy semejante a lo visto en el punto anterior, solo que en este caso se circleY = height/2;
circle2X = width/2+circleSize/2+10;
debe escribir en lugar de leer; se obtendría un objeto OutputStream del puerto circle2Y = height/2;
serie y se utilizaría para escribir en él: ellipseMode(CENTER);
println(Serial.list()); // obtiene la lista de puertos en pantalla
outputStream = serialPort.getOutputStream(); // aquí se debe ajustar el puerto que corresponda en cada caso
outputStream.write(64);//messageString.getBytes()); myPort = new Serial(this, Serial.list()[13], 9600);
}
Como ya sabemos hacerlo en Java, en este punto haremos un ejercicio utilizando void draw() {
otro lenguaje de programación. Se había comentado en el primer capítulo que la //Cuando se mueva el ratón se mirará si está dentro de cada círculo
programación de Arduino está basada en Processing, un lenguaje de programa- // si es así cambiar los colores y escribir carácter en el serial
update(mouseX, mouseY);
ción diseñado para la enseñanza que ha ido evolucionando. Será precisamente noStroke();
con Processing con el que crearemos el programa que enviará datos a la tarjeta if (circleOver) {
background(redColor);
Arduino. Para trabajar con Processing necesitamos su entorno de desarrollo, que myPort.write('A');
está disponible en http://processing.org/download. } else if (circle2Over) {

130 Capítulo 5 Interfaz serie. Comunicación entre dispositivos 131

del componente. Lo normal es comprobar la información técnica del fabri- Vamos ahora a definir una variable con la dirección de nuestro display, obtenida a
cante del componente y ahí suele decirnos cuál es la dirección por defecto. En través de las especificaciones del fabricante o utilizando el programa I2C Scanner
caso de que no consigamos obtener esa dirección utilizando las especificaciones mencionado anteriormente.
del fabricante, Arduino dispone de un programa en su batería de ejemplos que byte dir = 0x42 // Ese 0x significa que el valor es hexadecimal, no decimal
nos informa de lo que hay en nuestro bus y con qué dirección: el programa I2C
Scanner. Y, por último, creamos una instancia del objeto LiquidCrystal_I2C:
LiquidCrystal_I2C lcd( dir, 2, 1, 0, 4, 5, 6, 7);
Una vez definido el bus I2C, veamos cómo realizar las conexiones de nuestra
placa con este componente: Donde tenemos como parámetros la dirección del periférico y los pines EN, RW,
RS, más los pines D4, D5, D6, D7, que indicarán respectivamente el número
del pin con el que se han conectado esos pines del LCD a la placa de Arduino.
Por último, tenemos la función setup() y la función loop():
void setup()
{
lcd.begin (16,2); // Inicializar el display con 16 caracteres 2 líneas

lcd.home ();
lcd.print("Hello");
lcd.setCursor ( 0, 1 ); // va a la segunda línea
lcd.print("World");
}
void loop() {}

Con la instrucción lcd.begin() definimos el tipo de display a utilizar. Con la

Figura 6.8. Conexiones display LCD manejado por I2C. función lcd.home() situamos el cursor en la posición superior izquierda del
display. Con lcd.print() imprimimos en el display, en la primera línea. Con
Como se puede comprobar, solamente es necesario utilizar cuatro cables para lcd.setCursor(0,1) situamos el cursor en la posición inferior izquierda del
tener el display conectado, mientras que del otro modo eran necesarios doce. El display y con la siguiente instrucción volvemos a imprimir.
bus I2C ha supuesto una evolución en cuanto a la comunicación entre periféricos.
Conexiones: Arduino A4 a SDA (Datos) y A5 a SCL (Clock), más GND y alimen-
tación. Comencemos con el desarrollo del programa. Definiendo nuestros propios caracteres
Un display LCD está preparado para imprimir la mayoría de los caracteres ASCII
Programación de un LCD a través de I2C disponibles, pero es posible que alguno de ellos no esté disponible. En ese caso,
existe una forma a través de la cual podríamos definirlos y utilizarlos.
Para poder realizar la programación de este componente, primero es necesario Lo primero que hay que saber es que los caracteres se definen con un array de 8 × 8,
descargarse del repositorio la librería LiquidCrystal_I2C.h, siguiendo las como si se dibujara en una cuadrícula de ese tamaño, y rellenando el espacio
instrucciones indicadas en la web de Arduino (https://www.arduino.cc/reference/en/ completo. Por ejemplo, vamos a definir el símbolo de grados centígrados en la
libraries/liquidcrystal-i2c/). Después, debemos incluir también las librerías Wire.h matriz en la figura 6.9. Que definiéndolo en un sketch sería:
y LCD.h desde Programa>Incluir Librería>Administrar bibliotecas, obteniendo
byte grado[8] =
como primeras tres líneas del código las siguientes: {
#include <Wire.h> 0b00001100, // Los definimos como binarios 0bxxxxxxx
#include <LCD.h> 0b00010010,
#include <LiquidCrystal_I2C.h> 0b00010010,

150 Capítulo 6 Pantallas 151

y algún tipo de amplificadores como el LM393. En las tiendas se suelen encon- que alguno de ellos se encenderá el led correspondiente. Comenzaremos por el
trar sin dificultad micrófonos ya ensamblados en pequeñas placas junto con los umbral más alto, de modo que, si se enciende el led rojo, no se encienda el naranja
componentes necesarios para obtener una buena recepción del sonido, incluso ni el verde, aunque el valor leído también sea mayor que el del umbral de estos.
podemos encontrar en este formato micrófonos de alta sensibilidad para frecuen-
cias altas. Mi recomendación es siempre que se pueda, sobre todo al comenzar a
realizar circuitos, utilizar micrófonos ya montados en placas. En caso de utilizar
un sensor de audio en tarjeta con tres terminales, una de ellas se empleará para
la alimentación de la tarjeta, otra como masa y la tercera como señal analógica;
en caso de ser de cuatro terminales, el cuarto suele ser para salida digital, dispa-
rándose al sobrepasar un umbral de sonido. Otra de las ventajas que tienen estas
placas ya montadas es que suelen disponer de otros elementos que pueden estar
ligados directamente al micrófono, como puede ser un potenciómetro para ajustar
su sensibilidad o umbral de disparo digital, o incluso elementos no ligados como
ledes para indicar si está conectado o no el micrófono o si se ha superado el valor
umbral y la salida digital está en HIGH.

Figura 8.8. Circuito con sensor de audio.

const byte audioPin = A0;

int val; //valor leído
const byte greenLed = 2;
const byte yellowLed = 3;
const byte redLed = 4;
//umbrales de los leds
Figura 8.7. Sensores de audio. const int greenThreshold = 700;
const int yellowThreshold = 850;
const int redThreshold = 1000;
Aunque estemos trabajando con un sensor con tres terminales, podemos utilizar
void setup() {
el de señal analógica como disparadora de señal digital, tal y como lo hemos pinMode(greenLed, OUTPUT);
hecho con el circuito y con la fotorresistencia. pinMode(yellowLed, OUTPUT);
pinMode(redLed, OUTPUT);
Para ver cómo funciona el micrófono, usaremos un montaje en el que, depen- pinMode(audioPin, INPUT);
diendo de la fuerza de la señal recibida, se irán encendiendo distintos ledes; }
lo que haremos será leer la señal captada y, dependiendo del valor recibido,
void loop() {
encender unos ledes u otros. val = analogRead(audioPin);
Para el circuito necesitaríamos un led verde, un led amarillo, un led rojo, tres //se comienza a comparar por el más alto
if(val > redThreshold) {
resistencias de 200 ohmios y un micrófono; en el ejemplo usaremos un micrófono digitalWrite(redLed, HIGH);
de tres terminales (5 V, tierra y señal analógica). delay(15); //mantener encendido
digitalWrite(redLed, LOW);
Para el sketch lo que haremos será definir tres salidas para los distintos ledes y } else if(val > yellowThreshold) {
unos umbrales para los cuales se activarán cada uno de ellos. En el loop() se digitalWrite(yellowLed, HIGH);
delay(15); //mantener encendido
procede a la lectura del valor recibido por el puerto analógico correspondiente digitalWrite(yellowLed, LOW);
al sensor de audio y compararlo con cada uno de los umbrales, y si es mayor } else if(val > greenThreshold) {

174 Capítulo 8 Sensores I 175

Keypad
Un teclado es, básicamente, una colección de botones que, en función de su
pulsación, se obtiene un resultado u otro. Estos mecanismos son ampliamente
conocidos por el público en general, teniendo un ejemplo claro en los teclados
utilizados en los ordenadores.
Como cada tecla tiene una funcionalidad, podríamos conectar cada tecla a una
placa que tuviera tantos pines de entrada como teclas, pero eso es totalmente
ineficiente, ya que necesitaríamos una ingente cantidad de pines y tiempo para
conectarlos. Para solventar este problema, se crearon los keypads, matrices de
teclas. Estas matrices permiten codificar todos estos botones en un conjunto de
bits, cuya combinación definirá la tecla que está siendo pulsada.

Figura 9.7. Esquemático de un keypad genérico.

Figura 9.6. Keypad.

Estos teclados matriciales usan una combinación de filas y columnas para conocer
el estado de los botones. Cada tecla es un pulsador conectado a una fila y a una
columna. Cuando se pulsa una de las teclas, se cierra una conexión única entre una
fila y una columna siguiendo un esquema como el que aparece en la figura 9.7.
Los keypads permiten al usuario introducir datos durante la ejecución de un
programa. Para poder utilizarlos con una placa de Arduino, necesitaremos una
librería externa que podremos obtener desde el propio entorno de Arduino, por
lo que procedemos a descargarla siguiendo los pasos de la figura 9.8.
Figura 9.8. Descarga de la librería Keypad (1).
Lo que estamos haciendo es seguir la ruta Programa>Incluir librería>Administrar
bibliotecas. Haciendo clic en Administrar bibliotecas se abrirá la ventana mostrada
Cuando seleccionamos la librería, nos dará la opción de instalarla. Hacemos clic
en la figura 9.9. Introduciremos en el filtro de búsqueda la palabra "Keypad" y
en el botón Instalar y listo, ya podremos usar las funciones de nuestro keypad.
pulsamos Intro para hacer la búsqueda. De las librerías que nos aparecen, para
este ejemplo debemos seleccionar la que pertenece a los programadores Mark Comenzamos con la conexión del componente con la placa. En este ejercicio se
Stanley y Alexander Brevig, en concreto la versión  3.1.1 que se refleja en la ha utilizado un teclado matricial numérico de 3 x 4 (3 filas, 4 columnas) como el
figura 9.9. que aparece en la figura 9.10.

204 Capítulo 9 Sensores II 205

Por último, si se ha pulsado el botón, si checkButton está en estado TRUE, lo pone las tarjetas de estos fabricantes por motivos de compatibilidad. Acerca de estas
a FALSE y deja de atender pulsaciones. Posteriormente, llama a la función que especificaciones, es la SD Association la que se encarga de definir estos proto-
definiremos después, changeCaps(). Si checkButton se encuentra en FALSE, se colos de almacenamiento.
habrá soltado el botón, por lo que puede volver a atenderse.
if (!digitalRead(inputPin)){ // ver si está pulsado
if (checkButton){ // ¿se debe atender la pulsación?
checkButton = false; // dejar de atender pulsaciones si se atiende una
changeCaps();
}
}
else{
checkButton = true; //se ha soltado el botón, volver a atenderlo
}

Por último, tenemos la función changeCaps(). Esta función se encarga de

guardar en la EEPROM el valor del estado en el que se escribirán las letras en
pantalla:
/** Cambia el valor del byte 0 de la EEPROM negándolo **/
void changeCaps(){
boolean value = EEPROM.read(0); //lee el valor de la EEPROM
EEPROM.write(0,!value); //salva el valor en la EEPROM
}

En el cuerpo principal del sketch, realizamos una lectura del valor almacenado Figura 11.2. Tarjetas SD.
en la EEPROM para conocer si el mensaje se debe mostrar en mayúsculas o
minúsculas y la lectura se produce en cada iteración. Este método no es el más Aun existiendo una serie de protocolos a seguir, cabe la posibilidad de que nos
ortodoxo para un programa real, pero sí para este caso didáctico; en el caso real, encontremos con tarjetas que no son compatibles con nuestros lectores. Esto se
podríamos leerlo solamente en el setup() y luego mantenerlo en una variable debe a que en muchas ocasiones, los fabricantes van más rápido que la evolución
y, eso sí, guardarlo del mismo modo que en este caso. de estos estándares, lo que provoca que no dé tiempo a definir las características
que deben seguir los nuevos modelos. Los lectores nuevos son capaces de leer
Si se trabajara con datos que ocupen más de un byte, se debe tener cuidado a la
todo tipo de tarjetas, desde la fecha en la que se fabricó el lector hacia atrás. El
hora de salvar y recuperar, que se haga en el mismo orden en el que están alma-
problema puede venir si tenemos un lector de tarjetas antiguo y una tarjeta SD
cenados, y lo mismo pasa con las cadenas de texto, que son una sucesión de
actual. Esto puede provocar problemas de compatibilidad entre ambos, como
bytes. No obstante, si uno no se siente cómodo trabajando byte a byte, hay que
puede ser que no interprete bien su contenido o que no lea toda la capacidad
recordar que se puede echar mano a las librerías extendidas.
de la tarjeta.
Las tarjetas existen en diversos tamaños, es por ello por lo que se han creado una
Memorias SD serie de adaptadores preparados para las tarjetas más pequeñas, de tal forma
que puedan ser leídas en los lectores de tarjetas grandes sin ningún problema.
Estas memorias son muy conocidas por encontrarse en teléfonos móviles y De aquí en adelante, nos referiremos a todas estas tarjetas como tarjetas SD o
cámaras fotográficas, entre otros dispositivos electrónicos. Con el tiempo, han simplemente SD, abarcando tanto las SD estándar como las miniSD y las microSD.
ido aumentando su capacidad a la vez que iban reduciendo su tamaño. Debido a El lector será quien decida con qué tipo de tarjeta quiere trabajar dependiendo
la gran demanda y a la cantidad de nuevos fabricantes que salieron al mercado, de su disponibilidad de tarjeta y lector, ya que la programación y el montaje
fue necesario generar una serie de especificaciones que debían cumplir todas electrónico no dependen del modelo seleccionado.

252 Capítulo 11 Memorias 253

 Una vez que sabemos cómo se conectará nuestro módulo con la protoboard y el
led, vamos a realizar la programación:
void setup()
{ pinMode(2, OUTPUT); }

void loop()
{ digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
delay(1000);
}

Como se puede comprobar, el código es el mismo que el utilizado para hacer

parpadear un led cada segundo del principio del libro. En la función setup()
se configura el pin GPIO2 como salida. En la función loop() se enciende y se
Figura 13.18. Conexiones físicas esp‑01 con led y regulador 5 V a 3,3 V.
apaga cada segundo el led al que hemos conectado el módulo.
Según se puede ver en el esquemático, el módulo WiFi se conectará a 3,3 voltios Para introducir este sketch en el módulo esp‑01, nos dirigimos al esquemático de
con sus pines VCC y CH_PD, a tierra con su pin GND y al ánodo del led con su conexiones de la figura 13.14.
pin GPIO2. El resto de pines quedarán libres, sin conexión. La placa proporcio- El ordenador reconocerá el módulo de la misma forma que reconoce la placa
nará 5 voltios a la línea a la que está conectado. Esta línea se conectará con el pin Arduino UNO cuando se conecta. Además, veremos cómo se enciende un
derecho del regulador y la línea de tierra se conectará al pin izquierdo. El pin pequeño led rojo en el módulo WiFi, lo que indica que recibe voltaje.
central tendrá la salida ya convertida a 3,3 voltios Hacemos clic en el botón Verificar para comprobar que la programación está
Nuestra placa de Arduino es capaz de proporcionar tanto 3,3 voltios, como 5 voltios. correcta y posteriormente al botón Subir. Se comenzará a cargar el programa en
Esto quiere decir que, a pesar de haber utilizado en este caso un regulador de el módulo, viendo en el IDE de Arduino una serie de puntos que irán avanzando
voltaje de 5 a 3,3 voltios, podríamos haber utilizado directamente el pin de salida mientras se programa. A la vez que esta línea de puntos naranja va avanzando,
de 3,3 voltios que tiene nuestra placa y nos ahorraríamos el uso del regulador, un led azul del esp‑01 parpadeará al mismo tiempo, indicando que el micropro-
como se ve en la figura 13.19. cesador está almacenando el sketch.
Una vez se ha completado la programación, debemos desconectar el pin GPIO0
de la toma de tierra para poder verlo funcionar. Es muy común no acordarse de
que lo tenemos todavía conectado, por lo que creeremos que hemos hecho algo
mal en los pasos, así que lo primero que debemos hacer es comprobar que hemos
realizado este paso antes de comprobar otro tipo de errores. Una vez desconectado
el pin GPIO0, realizamos las conexiones de las figuras 13.18 o 13.19 y veremos
cómo nuestro led comenzará a parpadear.
Ya estamos familiarizados con los conceptos básicos del uso de los comandos
del esp‑01. En el siguiente ejercicio, enviaremos y recibiremos órdenes mediante
WiFi. Para ello, haremos un ejemplo de conexión con un terminal. En este caso,
utilizaremos el terminal Putty, que puede ser descargado desde http://www.putty.
org/. Se trata de un simple terminal, como el que hemos utilizado anteriormente
del entorno de Arduino, pero esta vez vamos a usar un terminal que sea externo
Figura 13.19. Conexiones físicas esp­‑01 con led sin regulador. a nuestro IDE. En este ejercicio, enviaremos texto en ambas direcciones.

292 Capítulo 13 Internet de las cosas 293

Arduino Práctico. Edición 2022

Manual Imprescindible

Este libro te permitirá dar forma y vida a tus propios proyectos de Arduino desde el inicio y sin
necesidad de tener conocimientos previos en programación. Sin un rango de edad específico,
describe desde las nociones básicas necesarias para poder crear tu primer proyecto, hasta
desarrollos más avanzados para aquellos que quieran subir de nivel en la creación de sus ideas. Ya
seas alguien que quiere comenzar en este mundo, o que quiere refrescar sus conocimientos, este
libro te permitirá llevar a la realidad tus pensamientos e ideas dentro del mundo de la tecnología.
Su formato paso a paso, su lenguaje comprensible y la inclusión de imágenes de los prototipos te
ayudarán a no tener dudas ni bloqueos durante el desarrollo de tus proyectos.
Incluye imágenes, códigos fuente y descripciones de cómo se han realizado los diferentes proyectos,
facilitando al máximo su claridad y compresión, realizados con el entorno de programación del
propio fabricante, el entorno Arduino IDE, cuyo funcionamiento se explica con gran detalle,
haciendo uso de los ejemplos proporcionados por la plataforma y ampliando algunos de ellos para
aprender a realizar fantásticas creaciones más allá de nuestra imaginación.

2311369
I S B N 978-84-415-4498-7

788441 544987

MULTIMEDIA www.anayamultimedia.es
9