Aplicaciones de IoT

Mtro. Wilber Peñaloza Mendoza

Módulo ESP8266 ESP-01

Universidad Tecnológica de la Selva

División de Tecnologías de la Información y Comunicación
Enero - Abril de 2021
 Índice de Contenido
¿Qué es el ESP8266?......................................................................................................................................................... 1
¿Qué es ESP-01? ............................................................................................................................................................... 3
La placa ESP-01 ............................................................................................................................................................. 3
Pines del ESP-01. .......................................................................................................................................................... 4
Opciones para alimentar el ESP-01 .............................................................................................................................. 5
Opción 1: a través de un Arduino UNO ................................................................................................................... 5
Opción 2: a través de un adaptador USB-Serie ....................................................................................................... 5
Opción 3: fuente de alimentación de 3.3 V y 5 V .................................................................................................... 6
Conexión y configuración del ESP-01 con Arduino.......................................................................................................... 7
Formas de conexión: configuración y uso ................................................................................................................... 7
Uso del ESP8266 con comandos AT (Ejercicio 1.1) ...................................................................................................... 9
Primeras pruebas en modo servidor (Ejercicio 1.2) .................................................................................................. 11
Comunicación con ESP01 por puerto virtual ............................................................................................................. 13
Enviar datos directamente en navegador (Ejercicio 1.3) ...................................................................................... 13
Enviar datos desde una página con dos botones (Ejercicio 1.4) ........................................................................... 15
Enviar datos desde una página con un checkbox (Ejercicio 1.5) .......................................................................... 16
Programación del ESP-01 ............................................................................................................................................... 19
Conexión y nuevo firmware ....................................................................................................................................... 19
Cargar un sketch al módulo ESP01 ............................................................................................................................ 21
Conectarse a una red WIFI con credenciales en el código (Ejercicio 2) ................................................................ 21
Conectar a redes con WifiManager (Ejercicio 3) ....................................................................................................... 24
CRUD a Firebase desde ESP01 (ESP8266) ...................................................................................................................... 28
Conectar e insertar datos a Firebase desde ESP01 (Ejercicio 4) ............................................................................... 28
Actualizar datos en Firebase desde ESP8266 ............................................................................................................ 32
Eliminar datos en Firebase desde ESP8266 ............................................................................................................... 32
Recuperar datos de Firebase con ESP8266 ................................................................................................................ 33
Ejercicio de CRUD básico desde SETUP() (Ejercicio 5) ............................................................................................... 34
Ejercicio de CRUD con datos recibidos desde Arduino por el puerto Serial (Ejercicio 6) ........................................ 36
Comunicación serial entre Arduino y ESP01 (Ejercicio 7) ......................................................................................... 42
Marca Temporal en Firebase (ejercicio 8) ................................................................................................................. 47
Act. U3.2-P1-Conexión Arduino+ESP01+firebase .......................................................................................................... 49

i
 ¿Qué es el ESP8266?
El ESP8266 es un chip de bajo costo WiFi con un stack TCP/IP completo y un microcontrolador, fabricado por Espressif,
una empresa afincada en Shanghái, China.

Figura 1 Logo de la empresa Espressif

El primer chip se hace conocido en los mercados alrededor de agosto de 2014 con el módulo ESP-01, desarrollado por
la empresa AI-Thinker. Este pequeño módulo permite a otros microcontroladores conectarse a una red inalámbrica
WiFi y realizar conexiones simples con TCP/IP usando comandos al estilo Hayes. La compañía Hayes Communications
desarrolló un lenguaje que prácticamente se convirtió en estándar abierto de comandos para configurar y
parametrizar módems. Los caracteres “AT”, que preceden a todos los comandos, significan “Atención”, e hicieron que
se conociera también a este conjunto de comandos como comandos AT.

Antes del ESP8266, las opciones disponibles para conectar un Arduino a Wifi (como el Wifi Shield) eran
prohibitivamente caras. La aparición del ESP8266 supuso una pequeña revolución al ser el primer dispositivo
realmente barato que proporcionaba conectividad WiFi.

Figura 2 Arduino WiFi shield 101 Figura 3 Conexión de Shields a Arduino

En realidad, el ESP8266 es mucho más que un módulo Wifi para Arduino. Es un microcontrolador completo, con mucha
más potencia que la mayoría de modelos de Arduino. De hecho, es uno de los principales "competidores" a los que se
enfrenta Arduino.

EL ESP8266 no tiene ROM y usa una ROM externa SPI y soporta hasta 16MB.

Características:

 32-bit RISC CPU: Tensilica Xtensa LX106 running at 80 MHz*

 64 KiB of instruction RAM, 96 KiB of data RAM
Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 1 de 51
  External QSPI flash – 512 KiB to 4 MiB* (up to 16 MiB is supported)
 IEEE 802.11 b/g/n Wi-Fi
 Integrated TR switch, balun, LNA, power amplifier and matching network
 WEP or WPA/WPA2 authentication, or open networks
 16 GPIO pins
 SPI, I²C,
 I²S interfaces with DMA (sharing pins with GPIO)
 UART on dedicated pins, plus a transmit-only UART can be enabled on GPIO2
 1 port 10-bit ADC

Figura 4 ESP8266 pin out

Para los makers que utilizan Arduino significó una alternativa a los shields WiFi por una pequeña fracción de su precio,
por lo que se hizo muy popular. Unos meses después, gracias a la presión de la comunidad que se formó a su alrededor,
Espressif liberó una API para desarrollar directamente sobre su microcontrolador, permitiendo utilizarlo de forma
independiente.

Otro grupo de desarrolladores implementó un intérprete del lenguaje de programación LUA en una placa de desarrollo
con ESP8266 diseñada por ellos mismos. En este caso la capacidad de la memoria flash es de 4 MB. Al conjunto de
placa más intérprete LUA lo llamaron NodeMCU.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 2 de 51

Durante el año 2015, uno de los miembros de la comunidad de desarrollo del ESP8266, Ivan Grokhotkov, adaptó el
API de Espressif para integrarlo en el entorno de Arduino. Así los makers pudieron utilizar las librerías y el conocimiento
acumulado con el uso de Arduino para programar el ESP8266.

Figura 5 Modelos de las placas ESP

¿Qué es ESP-01?

Como se mencionó en el título anterior, ESP-01 fue la primera placa en la que se implementó en chip ESP8266, la cual
además se ser pequeña, de muy bajo costo y ser controlado, por default, con comandos AT a través del puerto serial
(Este tipo de comunicación nos permitirá hacer un puente entre Arduino y el ESP8266 consiguiendo que un Arduino
UNO se conecte a una red WiFi.), tiene las siguientes características.

La placa ESP-01

La placa es relativamente pequeña apenas 14.3 mm de ancho por 23.8 mm de alto y tiene únicamente de 8 pines,
aunque la disposición de estos impide que se pueda conectar directamente en un protoboard.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 3 de 51

 Figura 6 Componentes externos de ESP-01

 ESP8266 es el microcontrolador del módulo ESP-01.

 Pines donde conectaremos la alimentación, sensores y transmisión de programa.
 BG25Q80A es la memoria flash donde residen los programas o sketchs. El ESP8266 no dispone de este tipo de
memoria y por eso es un chip aparte.
 LEDs que nos informan de si está encendido o no y de la transmisión de datos (Tx y Rx).
 La antena WiFi para conectarse a una red/Internet.

Pines del ESP-01.

El ESP-01 tiene 8 pines, cada uno de ellos está pensado para una tarea concreta. Esta es una de las limitaciones de esta
placa.

Figura 7 Pin out ESP-01

1. GND es la toma de tierra.

2. GPIO2 es una entrada-salida de propósito general. Es el pin digital número 2.
3. GPIO0 es una entrada-salida de propósito general. Es el pin digital número 0. También se usa como FLASH
para cambiar el Firmware.
4. RXD es el pin por donde se van a recibir los datos del puerto serie. Trabaja a 3.3 V. También se puede utilizar
como pin digital GPIO3: sería el número 3.
5. TXD es el pin por donde se van a transmitir los datos del puerto serie. Trabaja a 3.3 V. También se puede
utilizar como pin digital GPIO: sería el número 1.
6. CH_PD pin para apagar y encender el ESP-01: si lo ponemos a 0 V (LOW) se apaga, y a 3.3 V (HIGH) se enciende.
7. RESET pin para resetear el ESP-01: si lo ponemos a 0 V (LOW) se resetea.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 4 de 51

 8. Vcc es por donde alimentamos el ESP-01. Funciona a 3.3 V y admite un máximo de 3.6 V. La corriente
suministrada debe ser mayor que 200 mA.

Como puedes comprobar, no tiene ningún pin analógico y solo 4 pines digitales GPIO0, GPIO2, RXD (GPIO3) y TXD
(GPIO1). Estos dos últimos funcionan como pines I/O siempre y cuando el programa que carguemos a la placa no los
utilice, por ejemplo, para mostrar información a través del monitor serie.

El ESP-01 soporta la comunicación I2C: si nuestros sensores se comunican mediante este protocolo no tendremos
problema y, con tan solo dos pines de nuestro ESP-01, podremos comunicarnos con decenas de sensores.

Por último, con respecto a los pines digitales o GPIO, es importante recalcar que funcionan a 3.3 V, es decir, el estado
alto (HIGH) serán 3.3 V. Los pines RXD y TXD cuando funcionan para comunicar mediante puerto serie también utilizan
este voltaje. Luego veremos cómo resolver esto si lo conectamos a un Arduino UNO para programarlo.

Opciones para alimentar el ESP-01

Antes de hacer nada, tenemos que alimentar el ESP-01: funciona a una tensión de 3.3V y admite un máximo de 3.6V.
Se recomienda una intensidad mayor de 200 mA debido a que cuando está transmitiendo a través de WiFi puede
alcanzar picos de consumo de más de 200 mA.

Existen diferentes posibilidades para alimentar el ESP-01. Vamos a ver las ventajas e inconvenientes que presentan
cada una de estas posibilidades.

Opción 1: a través de un Arduino UNO

Arduino UNO tiene dos pines de alimentación dentro del bloque destinado a alimentar sensores y actuadores: puede
suministrar 5 V y 3.3 V. Seguramente estés pensando en alimentar el ESP-01 con el pin de 3.3 V (en el rango de
operación del ESP8266) pero, aunque efectivamente estamos dentro del rango de voltaje, el inconveniente es que
este pin puede suministrar un máximo de 50 mA.

Esto supone que en ocasiones puede quedarse corto, sobre todo cuando estamos haciendo un uso intensivo de la
parte WiFi.

Por lo tanto, alimentar un ESP-01 basado en el ESP8266 con un Arduino UNO no es una buena opción. Puedes hacerlo
y probablemente te funcionará en muchos casos, pero llegará un punto en que deje de hacerlo.

Opción 2: a través de un adaptador USB-Serie

Con un adaptador USB-Serie (también llamados FTDI o TTL), podemos programar un ESP8266 y también alimentarlo.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 5 de 51

 Figura 8 convertidores USB a TTL

En el mercado existen multitud de adaptadores de este tipo. Lo importante es conocer la corriente que puede
suministrar cada uno de ellos. Lo típico es que no lleguen al mínimo requerido por el ESP-01 así que, generalmente,
tampoco es una buena opción: la intensidad que suelen suministrar estos componentes varía entre los 50 y los 120
mA.

Opción 3: fuente de alimentación de 3.3 V y 5 V

Quizás la mejor opción que tengamos para alimentar un ESP8266 sea una fuente de alimentación de este estilo:
suministra 3.3 V y/o 5 V lo que supone una ventaja ya que muchos de los sensores y componentes que vamos a utilizar
necesitan 5V, como por ejemplo el sensor de temperatura LM35 o el sensor de ultrasonidos.

Figura 9 Fuente de alimentación MB102 de YwRobot.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 6 de 51

 Conexión y configuración del ESP-01 con Arduino
Formas de conexión: configuración y uso

El ESP01 monta la versión más sencilla del ESP8266. Aun así, sigue siendo un microcontrolador de 32bits a 80 Mhz,
con 512kB o 1MB de memoria según modelo. Dispone de 2 pines GPIO, SPI, I2C y UART.

En cuanto a comunicación Wifi, el ESP01 tiene comunicación integrada 802.11 b/g/n, incluidos modos Wi-Fi Direct
(P2P) y soft-Ap. Incluye una pila de TCP/IP completa, lo que libera de la mayor parte del trabajo de comunicación al
microcontrolador.

Antes de comenzar con la conexión del módulo ESP-01 con Arduino debemos considerar los siguiente:

 La alimentación del ESP-01 es a una tensión de 3.3V. En ningún caso puede alimentarse a una tensión superior
a 3.6V o dañaremos el módulo.
 El consumo del módulo puede sobrepasar los 200mA, sobre todo durante la conexión y arranques. Sin
embargo, el regulador de voltaje de 3.3V de Arduino sólo puede proporcionar 50mA (150mA en algunos
modelos), lo cual es insuficiente para alimentar el ESP01.
 Por tanto, necesitaremos alimentar el ESP01 con una fuente externa de 3.3V. De lo contrario
experimentaremos continuos cortes y cuelgues durante su funcionamiento, que además pueden reducir la
vida útil del ESP01.
 Lo anterior puede resolverse conectando una alimentación externa a la placa Arduino o si tiene si están a su
alcances un convertidor USB TTL o en el mejor de los casos una fuente externa como la mostrada en el título
anterior.
 La comunicación con el módulo se realiza mediante puerto serie. A diferencia de la alimentación del módulo,
que en ningún caso debe exceder los 3.6V, existe un amplio debate sobre si los pines RX y TX son tolerantes a
5V (Es decir, si pueden conectarse directamente a un sistema a un 5V). Lo recomendable, por seguridad es
colocar un divisor de voltaje con una resistencia de 1K y 2K respectivamente (ver Figura 10 )
 La comunicación serial con el módulo ESP-01 puede ser por hardware, es decir, utilizando lo pines 0 (RX) y 1
(TX) de la placa Arduino, pero esto evitará que se pueda programar Arduino, dado que también usa el puerto
seria para comunicarse con la Pc o laptop, por tanto, cada vez que se quiera programar Arduino tendría que
desconectarse el modulo WiFi del puerto serial.
 La comunicación serial también puede hacerse por software utilizando la librería “SoftwareSerial.h” con la
cual puedes seleccionar cualquier puerto digital para establecer la comunicación con el módulo WiFi. No
obstante, tener en cuenta que esto supone una carga de procesado importante para Arduino.
 ESP-01 puede configurarse a 9600, 19200, 38400, 74880, 115200, 230400, 460800 y 921600. Por defecto
suelen venir, según fabricante, a 9600 o 115200.

Figura 10 conexión Puerto Serie Hardware. R1 = 10K, R2 = 1K y R3 = 2K

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 7 de 51

En la Figura 10 se ilustra el diagrama de conexión entre Arduino y ESP-01 a través del puerto serie por Hardware
utilizando UNICAMENTE a Arduino como intermediario o pasarela, es decir, solo se usa el puerto serial para conectar
el modulo a la PC/laptop para configurarlo. Es recomendable quitar el microcontrolador de Arduino para evitar que se
dañe y en el caso de que no se pueda quitar, realizar un puente entre los pines GND y RESET.

 El TX del Arduino conectado al TX del ESP-01

 El RX del Arduino conectado a la entrada del divisor de tensión
 La salida del divisor de tensión al RX del ESP-01
 Se hace un puente entre el pin GND y el pin RESET en el Arduino UNO (esto aísla al procesador de los pines
GPIO, convirtiéndolo en una pasarela)
 Conectamos todas las GND entre sí
o GND de Arduino
o GND del ESP-01
o La tierra del divisor de tensión
o GND de la fuente de alimentación (en caso de usarla)
 El pin CH_PD del ESP-01 a 3.3 V con una resistencia de 10 KΩ en serie.

Figura 11 Conexión de ESP-01 por Puerto serial por software, Tx->pin2, RX->pin3

Para calcular divisiones de voltajes para otros circuitos t recomiendo este sitio:
https://www.digikey.com.mx/es/resources/conversion-calculators/conversion-calculator-voltage-divider

Para calcular resistencias en Serie y Paralelo te recomiendo este sitio:

https://www.digikey.com.mx/es/resources/conversion-calculators/conversion-calculator-parallel-and-series-resistor

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 8 de 51

Uso del ESP8266 con comandos AT (Ejercicio 1.1)

Una vez que se ha conectado el modulo Wifi con Arduino o con el convertidor USB TTL, lo primero es verificar su
configuración base, es decir, la velocidad de comunicación serial, el modo de funcionamiento (estación, Access Point,
ambos), entre otras. Para ello es necesario echar un vistazo a los comandos AT disponibles.

En la tabla anterior se describen algunos de los comandos AT disponibles para este módulo. Ahora sigues estos pasos
para configurarlo:

1. Una vez realizada las conexiones como se indica en la Figura 10. Verifica el puerto COM al que se conectó
Arduino en el Administrador de dispositivos, para el caso de que tengas varios puertos COM habilidades
(Figura 12)
2. Abre el IDE de Arduino, selecciona el modelo de la placa que estés usando y selecciona el puerto COM asignado
a dicha placa. (Figura 13)
3. Abre el monitor serial desde Herramientas > monitor serial o pulsando sobre el ícono con forma de lupa
en la esquina superior derecha.
4. Una vez abierto el monitor serial, selecciona en la parte inferior de este la opción “Ambos NL & CR” (New Line
and Car return) y 115200 baudios en el segundo combobox. (115200 baudios en la velocidad de transferencia
por default en el módulo ESP01 )
5. Desconecta y vuelve a conectar el pin 6 CH_PD del módulo wifi para reiniciarlo y veras una serie de caracteres
en el monitor serial terminando con la palabra ready indicando que esta lista el módulo. (Figura 14)
6. Escribe los caracteres AT (en mayúsculas) en el monitor serial y pulsa ENTER o el botón [enviar] debes obtener
un OK como respuesta indicando que el módulo está funcionando correctamente, en caso de obtener una
respuesta diferente o no obtener respuesta verifica las configuraciones del paso 4. (Figura 15)
7. Consulta la versión del firmware con el comando AT+GMR (Figura 16)
8. Consulta el modo actual del módulo con AT+CWMODE?, se pueden establecer tres modos 1=cliente, 2=Access
Point y 3=ambos. El modo cliente permite conectar al módulo a una red existente, el modo AP permite crear
una red y que se conecten otros dispositivos. (Figura 17)

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 9 de 51

 9. Cambia al modo cliente con AT+CWMODE=1 (Figura 18)
10. Realiza un escaneo de las redes wifi con AT+CWLAP (Figura 19)
11. Verifica si actualmente está conectado a una red wifi con AT+CWJAP? (Figura 20)
12. Conecta el módulo a una de las redes detectadas indicando el nombre de la red y la contraseña con
AT+CWJAP=”nombreRedWifi”,”contraseña” (Figura 21) y verifica nuevamente si está conectado a alguna red
con AT+CWJAP? (Figura 22)
13. Consulta la IP asignada al módulo con AT+CIFSR (Figura 23)
14. Verifica la comunicación con el módulo haciendo un ping desde el cmd a la IP asignada. (Figura 24)
15. Listo, el módulo está configurado, siempre que reinicie se conectará automáticamente. (Figura 25)

Figura 12 Puerto COM de la placa Arduino Figura 13 Seleccionar Placa y Puerto en el IDE Arduino

Figura 14 conexión Serial con ESP01 Figura 15 Verificar comunicación con ESP01 con comandos AT

Figura 16 Consultar la versión del firmware Figura 17 consultar el modo actual, 2:Access Point

Figura 18 Cambiar al modo cliente (estación) Figura 19 Consultar los AP detectados (redes wifi)

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 10 de

51
 Figura 20 Verificar si está conectada una red wifi (AP) Figura 21 Conectarse a una red wifi

Figura 22 Verificar nuevamente si está conectada a una red Figura 23 Consultar la IP asignada al módulo

Figura 24 Verificar la comunicación con el modulo desde CMD Figura 25 al reiniciar el módulo se conecta automáticamente

Primeras pruebas en modo servidor (Ejercicio 1.2)

Bien, el módulo ya está conectado y funcionando, pero para poder enviar y recibir datos se necesita de un servicio que
atienda las peticiones de envío y recepción de datos. Para ello este módulo también permite crear un servidor TCP
(servidor web) ejecutando los siguientes pasos:

1. Primero cambia el modo a ambos, es decir, cliente y AP, con el comendo AT+CWMODE=3 y posteriormente
verifica que se realizó el cambio con AT+CWMODE? (Figura 26)
2. Indica que acepte múltiples conexiones con AT+CIPMUX=1, y finalmente levanta el servidor TCP con el
comando AT+CIPSERVER=1,80 (1 significa activado y 80 es el puerto a usar) (Figura 27)
3. Comprueba que la IP no haya cambiado con el comando AT+CIFSR, notarás que ajora cambien se ha asignado
una IP al AP (Figura 28)
4. Abre el navegador y escribe la dirección IP del módulo (Figura 29) y observa el monitor serial que muestra el
encabezado de una petición GET al servidor web (Figura 30). Presta atención a la línea +IPD,1,431:GET /
HTTP/1.1, el valor 1 indica el ID de la conexión o petición recibida y el 431 indican la longitud de la cadena
recibida/enviada, en este caso se recibieron 431 caracteres. NOTESE que al inicio aparece el ID de la petición
con la palabra CONNECT y al final aparece nuevamente el ID con la palabra CLOSED, todas las conexiones
deben cerrarse después de enviar o no una respuesta
5. Nuevamente, desde el navegador coloca una diagonal después de la IP y escribe algún mensaje SIN ESPACIOS.
En la figura 31 se envía la cadena “holaMundoESP01” (Figura 31) y puedes ver en el monitor serial que se
recibe el mensaje y el número de caracteres incrementó a 445 ya que el mensaje tiene 12 caracteres. (Figura
32)
Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 11 de
51
 Figura 26 Cambiar el modo de operación a 3 = Ambos Figura 27 Permitir múltiples conexiones y levantar servicio TCP

Figura 28 verificar IP asignada al módulo Figura 29 IP del módulo en el navegador web

Figura 30 Cadera recibida al acceder al servidor del ESP01

Figura 31 Enviar mensaje por GET al servidor del ESP01

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 12 de

51
 Figura 32 Mensaje recibido desde el navegador

Comunicación con ESP01 por puerto virtual

Enviar datos directamente en navegador (Ejercicio 1.3)
Ahora que has visto como configura el modulo para recibir datos desde el navegador, solo resta establecer la
comunicación con Arduino, ya que hasta el momento solo se ha usado el puerto serial por hardware de este último
para establecer comunicación con la computadora.

Cabe recordar que mientras se esté usando los pines 0 RX y 1TX de Arduino para conectar el módulo wifi no se
podrá acceder al microcontrolador de Arduino, para cargar un sketch será necesario desconectar el modulo wifi y una
vez cargado conectarlo nuevamente para que Arduino haga use de él para enviar y recibir datos, pero intercambiando
los pines, es decir: RX->TX y TX-> RX. También es importante recordar que mientras se usen estos pines de Arduino
no se podrá establecer comunicación Serial con la computadora. Por lo que si deseas utilizar el monitor serial al
mismo tiempo debes crear un puerto Serial por software usando alguna de las librerías disponibles (SoftwareSerial.h).

Para poder mostrar los que se está enviando y recibiendo en el monitor serial es necesario utilizar un puerto Serial
virtual, y se recomienda cambiar los baudios a 9600 ya que los puertos virtuales no son muy compatibles con 115200
baudios. Para cambiarlos ejecuta el comando AT+UART_DEF=9600,8,1,0,0 (si marca error la primera vez inténtalo
nuevamente hasta obtener un OK) y posteriormente cambia este valor en el monitor serial e introduce AT para
verificar que el modulo ya “responde” a esa velocidad. (Figura 33)

Figura 33 Prueba de cambio de velocidad de salida

Ya todo listo, crea un sketch con el siguiente código:

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 13 de

51
 Primeramente, se debe importar la libraría
<SoftwareSerial.h> la cual permitirá crear puertos
seriales virtuales o por software con el fin de utilizar
cualquiera de los pines digitales y así dejar libre el
puerto serial por hardware que es el que se usa para
conectar la placa con la computadora y acceder al
monitor serial. En la línea 4 se crea el puerto virtual a
través de una instancia de la clase SoftwareSerial,
indicando los puertos que se usaran para dicho fin (el
primer parámetro es RX y el segundo TX de Arduino,
pero deben conectar cruzados con el módulo ESP01).
Ver Figura 11 para la conexión del módulo.

En la línea 8 se inicializa el puerto serial por hardware

a 9600 baudios y en la línea 10 se inicializa el puerto
serial por software para comunicar a Arduino con el
módulo ESP01, también a 9600 baudios (este valor
debe ser previamente configurado en el ESP01, sino los
has hecho, debes cambiar este valor a 115200).

En la línea 16 se verifica que hay algo en el puerto serial

físico y mientras haya algo se leerá el contenido y
almacenará en la variable cadena y se enviará al
módulo ESP01 por el puerto virtual esto permitirá
CONFIGURAR el módulo desde el monitor serial o a
través de líneas de código.

En la línea 21 se hace el proceso inverso, se verifica que haya algo en el puerto virtual, es decir, que el módulo WIFI
hay recibido algo, se lee y almacena en la variable cadena, y se imprime en el serial físico para que sea visible en el
monitor serial. En la línea 24 se busca la posición de la cadena “Led=0” en caso de encontrarse devolverá la posición,
y obviamente será mayor que cero (puedes usar también la función Serial.find(“Led=0”) para leer directamente del
buffer) en caso de encontrar la cadena se apagará el led del pin 13. En la línea 27 se repite el proceso anterior, pero
para la cadena “Led=1” en caso de encontrarla se encenderá el led.

Verifica que tus conexiones concuerden con la Figura 11, verifica que hayas seleccionado la placa y el puerto en el
IDE de Arduino, carga el código a la placa y abre el monitor serial.

Debes obtener un mensaje como el mostrado en la Figura 34, al igual que en la Figura 14 al encenderse el módulo
muestra una serie de caracteres ilegibles y finaliza con ready, todos estos mensajes los envía al módulo a Arduino por
el puerto virtual y este a su vez a la computadora por el puerto físico. Introduce el comando AT+CIFSR para mostrar
las direcciones IP asignadas al módulo. Aquí hay comunicación en las dos direcciones el comando se envía desde la
computadora a Arduino a través del puerto físico y este a su vez lo reenvía por el puerto virtual al módulo el cual
contesta mostrando los datos solicitados.

Accede al navegador y escribe la dirección IP de la estación o cliente como se indica en la Figura 35. Nota que en el
monitor serial no se recibe la solicitud GET, esto significa que el servidor web no está levantado (el servidor se apaga
cuando se reinicia el módulo, por lo que es recomendable colocar alimentación externa al módulo WIFI). Levanta el
servidor ejecutando los comandos AT+CIPMUX=1 y AT+CIPSERVER=1,80 como se muestra en la Figura 36.

Refresca el navegador y verifica en el monitor serial que has recibido la petición GET al servidor del ESP01, se pasa
toda la cadena recibida al Arduino y este busca la subcadena Led=0, de no encontrarla busca Led=1; en este caso se
encontró la cadena Led=1 por tanto se ENCIENDE el LED. Ver Figura 37. Cambie el valor en el navegador por Led=0 y
verifica que se APAGUE el LED.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 14 de

51
 Figura 34 Datos enviados por el módulo ESP01 Figura 35 Enviar petición al servidor web del módulo ESP01

Figura 36 Levantar servidor web ESP01 Figura 37 Petición al servidor TCP del ESP01

Enviar datos desde una página con dos botones (Ejercicio 1.4)

Codifica una pequeña interface web para controlar el encendido y apagado del botón, con dos botones o con un
checkbox, ejecútala desde el servidor web que prefieras (en este caso se usará Apache) y verifica su correcto
funcionamiento.

Figura 38 Vista de la página para control de led

En la línea 10 se incluye o importa la librería jquey (se descargó y colocó en el mismo directorio que el archivo html)
para hacer uso de sus funciones, cabe mencionar que no es la única forma de hacerlo, haciendo uso del método ready
del documento (página) define una función que al pulsar algún botón se obtenga su ID (1 para el botón encender y 0

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 15 de

51
para el botón apagar) y se haga una petición GET al servidor del ESP01 enviando la cadena compuesta por la palabra
Led y el valor del ID del botón pulsado, “Led=0” o “Led=1”. El aspecto de la página se muestra en la Figura 38.

Enviar datos desde una página con un checkbox (Ejercicio 1.5)

Otra opción con la cual pueden evitarse validaciones en el sketch por pulsar varias veces consecutivas el mismo botón
de encendido o pagado, es usar un checkbox, el cual al tener solo dos estados no habrá problema al pulsarlo
consecutivamente. Ver Figura 39.

Figura 39 control de led con checkbox

Bien, como ya se mencionó en párrafos anteriores cada vez que se reinicia el módulo wifi se detiene el servidor TCP,
por lo que debe levantarse nuevamente, para ello se realizarán algunos ajustes al sketch para que haga las
configuraciones automáticamente.

Se agregaron dos variables conexionID y pos, la primera

para almacenar el ID de la conexión que realiza la petición
GET y así poderla cerrar después de leer los datos. En pos
se almacena la posición de dicho valor dentro de la cadena
recibida.

En las líneas 15, 16 y 17 se invoca la función enviarDatos(),

la cual será codificada a partir de la línea 40, esta función
recibe dos parámetros, el primero es el comando AT a
enviar al módulo wifi, y el segundo el tiempo de retardo o
espera (recuerda que debes evitar usar delay())

Se eliminaron las líneas que reenviaban las instrucciones

escritas en el monitor serial ya que se enviaran desde el
código con la función descrita anteriormente.

En la línea 21 se verifica si hay algo en el puerto virtual y en caso de haberlo se almacena el contenido en la variable
cadena, se imprime únicamente a modo de depuración (pude eliminarse esa línea); en la línea 24, se busca la cadena
“+IPD,” la cual es el inicio del encabezado http, si se encuentra la posición del prime carácter por lo que sumamos 5
espacios para obtener la posición del ID de la conexión actual. En la línea 26 se extrae el ID de la conexión actual

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 16 de

51
usando el método substring() de la clase String. En la línea 35 se invoca al método enviarDatos() pasando como
parámetro el comando AT concatenando con el ID de la conexión actual para cerrarla.

Finalmente a partir de la línea 40 se codifica el método enviarDatos(), el cual recibe dos parámetros, el primero un
string con el comendo AT a ejecutar, y el segundo el tiempo de espera o retardo. En la línea 41 se envía el comando
AT por el puerto virtual al módulo wifi; en la línea 42 se captura el tiempo actual de la placa Arduino y en la línea 44
se crea un bucle vacío que para generar el retardo; en la línea 45 se lee la respuesta del módulo wifi a ejecución del
comando AT ejecutado.

Cargan el sketch a la placa Arduino y verifica en el monitor serial que aparecen las respuestas a la ejecución de los
comandos AT de las líneas 15, 16 y 17. Recarga el navegador, pulsa el checkbox para encender el led y verifica en el
monitor serial que se recibe la petición GET y se ejecuta el comando AT para cerrar la conexión. Ver Figura 40 y figura
41.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 17 de

51
 Figura 40 Petición GET para encender LED

Figura 41 Petición GET para apagar LED

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 18 de

51
 Programación del ESP-01
Conexión y nuevo firmware

Como ya se comentó en reiteradas ocasiones en los títulos anteriores el módulo ESP01 contiene un microcontrolador
ESP8266 el cual es más potente que el ATmega328 de Arduino UNO, tanto en velocidad como en capacidad de
almacenamiento y a que cuenta con memoria externa, pero como también ya se mencionó el firmware que trae
precargado solo permite configurarlo con comandos AT, por lo es necesario cambiar el firmware.

Para que el módulo pueda ser programado directamente desde el IDE de Arduino utilizando el lenguaje C/C++ primero
debe “flashearse” y cargar un nuevo firmware que permita compilar e interpretar dichas instrucciones, para ello
conecta nuevamente el modulo como se indica en la Figura 42, nótese que el pin GPIO0 (pin 3) del módulo se conecta
a GND para cargar el nuevo firmware y también para cargar los sketches.

Figura 42 Conexión de GPIO0 a GND para cargar nuevo firmware y sketchs

Una vez realizada las conexiones, ejecuta el archivo ESP8266Flasher-x86-v0.9.2.3.exe, verás que automáticamente
detecta el puerto de la placa y únicamente resta pulsar el botón azul o pulsa la letra F; veras la barra azul que empieza
a avanzar hasta llenarse, el proceso finaliza cuando aparece el check verde en la esquina inferior izquierda de la
ventana; en caso de que el proceso falle, inténtalo nuevamente hasta tener éxito. Como en la Figura 43.

Figura 43 Flasher del ESP01

El siguiente paso es descarga el controlador de tarjetas que incluyen el ESP8266, para ello:
1. Abre el IDE de Arduino, pulsa en Archivo > Preferencias, en la ventana que se despliega ubica la casilla Gestor
de URLs Adicionales de Tarjetas y pega la siguiente URL para descargar los drivers y librerías disponibles para
las tarjetas con ESP8266: http://arduino.esp8266.com/stable/package_esp8266com_index.json
Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 19 de
51
 Figura 44 Gestor de URLs Adicionales de Tarjetas

2. Dirígete al Herramientas > Placa > Gestor de tarjetas… y teclea ESP8266 en la caja de búsqueda, selecciona
la que dice esp8266 by ESP8266 Community y pulsar el botón [instalar] y una vez que se instale pulsa el botón
[cerrar].

Figura 45 Gestor de tarjetas ESP8266

3. Digite a Herramientas > Placa > Generic ESP8266 Module y selecciona el puerto al que esté conectada la
placa Arduino.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 20 de

51
 Figura 46 Seleccionar Modulo y puerto para cargar sketch
Cargar un sketch al módulo ESP01
Conectarse a una red WIFI con credenciales en el código (Ejercicio 2)

Una vez cargado el nuevo firmware e instalado el gestor de tarjetas con ESP8266, es momento de escribir un sketch
utilizando las librerías que estas disponen como es el casado de <ESP8266WiFi.h>.

Antes de explicar el primer sketch, te recomiendo dar una lectura rápida a la documentación de esa librería en:
https://esp8266-arduino-spanish.readthedocs.io/es/latest/esp8266wifi/readme.html

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 21 de

51
En la línea 1 se incluye la librería <ESP8266WiFi.h> la cual contiene los métodos para conectarse a una red wifi,
consultar el estado de la conexión, obtener el SSID, la dirección IP, la dirección MAC, entre otros datos de la conexión.
En las líneas 3 y 4 define el nombre de tu red wifi y la contraseña respectivamente. En las líneas 5 y 6 se definen dos
variables de tipo byte (este tipo de dato puede almacenar un valor entero de 0 hasta 255), contador, para registrar el
número de intentos de conexión realizados y max_intentos, para establecer el número de intentos permitidos, esto
con el fin de no entrar en un ciclo infinito, al no poderse conectar a la red wifi indicada.

Nótese que toda la configuración de la conexión se realiza en método setup, ya que solo debe hacerse una vez al inicio
del sketch (el control de reconexiones puede validarse en el método loop) para poder ver los mensajes en el monitor
serial, al igual que en Arduino se inicializa el puerto serial físico (UART) del módulo y se puede configurar velocidad de
comunicación que se desee, aunque normalmente trabaja 115200 baudios, pero sin problema se puede establecer
9600 si se establecerá una comunicación con Arduino.

En la línea 12 se inicializa la conexión wifi haciendo usa del método estático begin() de la clase WiFi, este método
recibe como parámetros el nombre de la red wifi y la contraseña. En la línea 13 se define un bucle WHILE que se
ejecutará mientras se cumplan dos condiciones, la primera condición es que no se haya conectado a la red, esto se
puede saber invocando el método status() de la clase WiFi, y comparando el código devuelto con “diferente de” o “no
es igual a” WL_CONNECTED, el cual es el código devuelto cuando el módulo se ha conectado exitosamente a la red
wifi indicada; y la segunda condición es que el número de intentos sea menor a 50, mientras se cumplan estas dos
condiciones se incrementará el contador de intentos, se realizará una pausa de 50 milisegundos (NOTA: el ESP8266
no se detiene con los delays como lo hace el ATMega328 de Arduino, sino que la conexión wifi se gestiona en segundo
plano ) y se imprimirá un punto en el monitor serial, esto solo con fines demostrativos, realmente no es necesario,
bien podría hacerse parpadear un led o mostrar un mensaje en un LCD para no depender del monitor serial cual el
prototipo ya esté en funcionamiento.

Cuando el módulo se conecte a la red wifi o se terminen los 50 intentos se saldrá del bucle WHILE. En la línea 18 se
compara si el al salir del bucle WHILE el número de intentos es menor al máximo establecido, si ese es el caso, significa
que logró conectarse. En la línea 21 se obtiene el nombre de la red a la que está conectado con el método SSID(); en
la línea 23 se obtiene la dirección IP del módulo con el método localIP(); y en la línea 25 se obtiene la dirección MAC
del módulo en modo estación o cliente con el método macAddress().

Verifica que esté seleccionada la tarjeta y el puerto, carga el sketch al módulo; durante el proceso de cargar el sketch
se desplegarán mensajes como los mostrados en la Figura 47, verifica que se muestre el 100%.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 22 de

51
Figura 47 Cargar el sketch al módulo ESP01

Desconecta el pin GPIO0 de GND y reinicia el módulo desconectando y volviendo a conectar el pin CH_PD. Al momento
de reiniciar el módulo aparecerán los caracteres desconocidos, un salto de línea y enseguida un punto por cada
interacción del bucle WHILE, en la Figura 48 se muestra el resultado cuando la no se pudo conectar a la red wifi, y en
la figura 49 cuando se logra una conexión exitosa mostrando el SSID, IP y MAC.

Figura 48 Mensaje de Error de conexión Figura 49 Conexión exitosa, muestra SSID, IP y MAC

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 23 de

51
El método WiFi.status(), devuelve los siguientes códigos para describir lo que está sucediendo con la conexión WiFi:

0 : WL_IDLE_STATUS, cuando WiFi está en proceso de cambio de estado.

1 : WL_NO_SSID_AVAIL, en caso de que no se pueda alcanzar el SSID configurado.
3 : WL_CONNECTED, después de establecida una conexión exitosa.
4 : WL_CONNECT_FAILED, si la contraseña es incorrecta.
6 : WL_DISCONNECTED, si el módulo no está configurado en modo estación.

Es una buena práctica mostrar y verificar la información devuelta por las funciones. El desarrollo de aplicaciones y la
resolución de problemas serán así más fáciles.

Conectar a redes con WifiManager (Ejercicio 3)

Como te habrás dado cuenta en el sketch anterior se han limitado el número de intentos a 50, para evitar que se cicle
infinitamente al no poder conectarse, pero en algunos casos será necesario que siga intentando hasta que logre
conectarse a la red. El nombre de la red wifi y la contraseña se definen en el código lo cual no es muy práctico cuando
el módulo se cambia de lugar o se desea conectar a otra red wifi.

Para dar solución a estos dos casos, se utilizará una librería llamada WiFiManager, la cual al no poderse conectar se
auto configura como Access Point (AP) y crea una red wifi con el nombre que se indique en el código y lanza un
servidor web para que el usuario pueda conectarse desde el navegador e indicar a que red debe conectarse el módulo,
introduciendo la contraseña de esta red desde la interface web.

Para agregar esta librería dirígete a Herramientas > Administrar bibliotecas y en la caja de búsqueda escribe
“wifimanager”, selecciona la que dice WiFiManager by tzapu,tablatronix, pulsa el botón [Instalar] y al finalizar la
instalación pulsa el botón [cerrar]

Figura 50 Instalación de WiFiManager

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 24 de

51
 Lo primero es importar o incluir algunas
librearías que son necesarias para gestionar la
conexión de a las redes wifi, es importante
que se coloquen en este orden ya que la
librería <WiFiManager.h> hace uso de ellas y
si se importan después de esta generará
ERROR.

En esta ocasión utilizaremos el monitor serial

a 9600 baudios para demostrar que se puede
decir otra velocidad de transmisión y no solo
115200 baudios.

En la línea 11 se crea una instancia de la clase

WiFiManager a través de la cual se accederán
a los métodos, en la línea 14 se resetean las
configuraciones anteriores que pueda tener
el módulo, es decir la red y contraseña que se
haya almacenado anteriormente, OJO, esta
línea solo debe ejecutarse la primera vez,
después debes comentarla y cargar
nuevamente el sketch, de lo contrario cada vez que se reinicie la tarjeta borrará las configuraciones anteriores y
tendrás que introducir el nombre de la red y la contraseña.

En la línea 17 se gestiona la conexión AUTOMÁTICA a la red que se haya registrado la última vez, es decir, a la que se
conectó recientemente, en caso de no poder conectarse, porque la red ya no exista o porque cambió de contraseña,
el módulo cambiará su configuración a modo Access Point y creará una red con el nombre indicado como parámetro,
opcionalmente puedes indicar una contraseña como segundo parámetro. Finalmente, cuando la se logra conectar
mostrará el mensaje “Conexión Exitosa!” en la línea 19.

Para cargar el sketch al módulo, primero verifica que esté conectado el pin GPIO0 a GND y el pin RESET de Arduino
también esté a GND para no dañar el microcontrolador. Verifica que esté seleccionado el puerto y la placa “Generic
ESP8266 Module”, finalmente pulsa el botón [subir] del IDE Arduino. Espera que cargue por completo y se muestre el
100% en la consola del IDE. En caso de marcar algún ERROR, intenta nuevamente hasta tener éxito.

Abre el monitor serial, desconecta el pin GPIO0 y resetea el módulo ESP01 desconectando y volviendo a conectar el
pin CH_PD. Al reiniciarse el módulo notarás en el monitor serial un serie de caracteres sin sentido, eso es normal al
encender el módulo, en seguida se ejecuta el método resetSettings() borrando las credenciales anteriores (SSID y
password), en seguida se ejecuta el método autoConnect(), al no encontrar credenciales almacenadas y no poderse
conectar inicia la configuración del portal (portal cautivo), se deshabilita el modo estación (cliente) y se habilita el
modo Access Point (AP) creando una red wifi con el nombre indicado como parámetro, se ejecuta el método SoftAP
mostrando un diagnóstico de la red creada; se muestra la IP del AP, se inicia un servidor DNS y un servidor web, se
escanean las redes existentes en el lugar para mostrarse en el portal, y finalmente se queda a la espera de clientes
que se conecten al AP. Ver Figura 51.

Abre el gestor de redes y conéctate a la red creada por el módulo ESP01; al conectarte se abrirá el navegador en el
sitio www.msftconnecttest.com el cual redireccionará al portal cautivo creado mostrando una página con tres botones
[Configure WiFi] para mostrar las redes wifi disponibles, [Info] para mostrar información sobre la el módulo y [exit]
para salir. Ver Figura 52.

Pulsa el botón [configure WiFi], se listarán todas las redes detectadas, selecciona una (a la que tengas acceso) dando
clic sobre ella e introduciendo la contraseña (Ver Figura 53), finalmente pulsa en el botón [save], en el monitor serial
se mostrará el proceso de guardado de las credenciales y la conexión a la red seleccionada, ver Figura 54.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 25 de

51
 Figura 51 Proceso de conexión del módulo ESP01

Figura 52 portal cautivo de configuración de wifi

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 26 de

51
 Figura 53 Seleccionar red wifi e introducir contraseña

Figura 54 Guardar credenciales de red wifi

Bien ahora ya tienes dos opciones para conectar tu módulo ESP01 a una red wifi, ¿cuál debes usar? La que gustes, la
que más convenga a tus necesidades.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 27 de

51
CRUD a Firebase desde ESP01 (ESP8266)

Conectar e insertar datos a Firebase desde ESP01 (Ejercicio 4)

Para acceder a la base de datos en Firebase desde el módulo ESP01, es necesario tener creado un proyecto en firebase
(retoma alguno de los proyectos creados en actividades anteriores), copia la dirección URL de la base de datos Raltime
Database, y también la clave secreta de la base de datos, como se muestra en la Figura 55 y Figura 56 respectivamente.

Instala la librería de Firebase para el ESP8266 desde el IDE de Arduino, para ello digite a Herramientas > Administrador
de bibliotecas, y en la caja de búsqueda escribe firebase, selecciona Firebase ESP8266 client by Mobizt y pulsa el
botón [instalar], al finalizar la instalación pulsa el botón [cerrar]. Ver Figura 57.

Figura 55 URL de Raltime Database del proyecto

Figura 56 Obtener clave secreta para acceso a la BD

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 28 de
51
 Figura 57 Instalar librería Firebase ESP8266 Client

Para consultar la documentación y ejemplos de esta librería consulta el repositorio de GitHub en el siguiente enlace
https://github.com/mobizt/Firebase-ESP8266

Aunque las colecciones y documentos se pueden crear desde el código con ayuda de las funciones de la librería, se
creó una estructura base desde la consola de firebase. Se creó la colección ESP8266Test, una subcolección por cada
sensor y la subcolección Registros para almacenar el historial de lecturas de los sensores y/o actuadores.

Para este ejercicio se requieren dos

librerías ya que se retoma la primera
forma de conexión wifi, es decir,
especificando el nombre (ssid) y
contraseña de la red (línea 4 y línea 5
respectivamente) en la línea 6 de
indica la dirección URL de la base de
datos y en la línea 7 la clave de
autenticación (clave secreta o huella
digital).

En la línea 9 se crea una instancia de la

clase FirebaseData para el control y
encapsulamiento de los datos a enviar
a la BD, es como el objeto de conexión.

En la línea 10 se crea una instancia de

la clase FirebaseJson, para crear una estructura JSON para enviar varios campos en una sola variable. En la línea 12 se
almacena la ruta de la colección en la que se almacenarán los datos. De la línea 15 a la línea 26 se gestiona la conexión
Wifi la cual ya fue explicada en los ejercicios anteriores.

En la línea 28 se inicializa la conexión con la base de datos con el método begin() y recibiendo como parámetros la
URL y la huella digital de la base de datos. En la línea 29 se gestiona la reconexión a la red wifi en cado de que se
desconecte. En la línea 30 se crea un bucle FOR con 5 iteraciones para insertar 5 registros en la base de datos. En la
línea 32 y línea 33 se agregan los campos al objeto JSON usando el método add() y dos parámetros que son la clave
y el valor. En la línea 36 se envían los datos a la base de datos con el método pushJSON() y pasando como parámetros
Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 29 de
51
el objeto de conexión, la ruta y el objeto JSON. El método pushJSON genera un ID automático para cada registro. Se
verifica que se haya insertado correctamente el registro y se imprime en el monitor serial la ruta y el ID del registro
insertado. En caso de no haberse insertado correctamente se imprime en el monitor serial la razón del error.
Se agrega una pausa de 5 segundos y finalmente se limpia el archivo JSON borrando todo su contenido.

Figura 58 estructura inicial y registros insertados

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 30 de

51
 Figura 59 Ruta e Ids de los registros insertados

Para almacenar datos en un nodo específico en Firebase RTDB, use estas funciones:

set, setInt, setFloat, setDouble, setBool, setString, setJSON, setArray, setBlob y setFile.

Las funciones anteriores devuelven un valor booleano que indica el éxito de la operación, que será verdadera si las
siguientes condiciones coinciden.

 El servidor devuelve el estado HTTP 200

 Los tipos de datos coincidieron entre la solicitud y la respuesta.

Como habrás notada cada función inserta un tipo de dato específico desde los datos primitivos hasta objetos JSON,
imágenes y archivos, estas funciones CREAN nodos o campos en las rutas indicadas en caso de que no existan en la
base de datos y en caso de que ya existan ACTUALIZAN (realmente lo sobrescribe) los datos de dicho nodo o campo.
Todos estos métodos reciben al menos tres parámetros: el objeto de conexión de tipo FirebaseData, la ruta del nodo
o campo y el valor, este último puede ser un dato primitivo (int, float, double, String) o un objeto de tipo JSON, una
imagen o un archivo según sea el método invocado.

Firebase.setString(fdbo, "/IoT/Registros/sensor", "DHT11");

Firebase.setInt(fdbo, "/IoT/Registros/humedad", 31);
Firebase.setBool(fdbo, "/IoT/Registros/estado", false);
Firebase.setFloat(fdbo, "/IoT/Registros/temperatura", 30.5);
Firebase.setDouble(fdbo, "/IoT/Registros/distancia", 12.2530);
Firebase.setJSON(fdbo, "/IoT/Registros", datos);

Ahora si lo que se desea es insertar registros con un identificador automático usa las siguientes funciones:

Para agregar datos nuevos a un nodo específico en Firebase RTDB, use estas funciones de inserción.

push, pushInt, pushFloat, pushDouble, pushBool, pushString, pushJSON, pushArray, pushBlob y pushFile.

Estas funciones devuelven un valor booleano que indica el éxito de la operación. El Id de un nuevo nodo adjunto se
puede determinar a partir de fbdo.pushName.

La marca de tiempo del servidor (fecha, hora completa, región, etc) se puede agregar a la base de datos a través de
Firebase.pushTimestamp.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 31 de

51
FirebaseJson datosNuevos;

datosNuevos.set("idSendor",1);
datosNuevos.set("valor",28.5);
datosNuevos.set("fecha", “2021-03-16”);
datosNuevos.set("hora", “16:35:10”);

if (Firebase.pushJSON(fbdo, "/IoT/temperatura/", datosNuevos)) {

Serial.println(fbdo.dataPath() + "/"+ fbdo.pushName()); //imprime la ruta e ID del registro
} else {
Serial.println(fbdo.errorReason()); //imprime el error que haya ocurrido
}

Actualizar datos en Firebase desde ESP8266

Como se comentó en el título anterior las funciones set permiten agregar (CREAR) y actualizar (SOBREESCRIBIR) nodos
o campos, pero también esta librería de Firebase dispone de otras funciones específicamente para “parchear” o
actualizar datos nuevos o existentes en la ruta de base de datos indicada. Estas funciones, updateNode y
updateNodeSilent están disponibles y funcionan con el objeto JSON (solo el objeto FirebaseJson).

Si alguna clave (nombre del campo, recuerda que en JSON se indica CLAVE:VALOR) proporcionada en una ruta de base
de datos definida en el objeto JSON no existe, se creará una nueva clave, es decir, un nuevo campo con el valor
indicado.

El servidor devuelve un JSON con los datos que se actualizaron correctamente. La devolución un JSON con muchos
datos podría ser lenta por la conexión que se tenga, en su lugar se debe utilizar la función updateNodeSilent para
guardar los datos de la red.

El siguiente ejemplo mostró cómo parchear datos en "/ test".

FirebaseJson datosActualizados;

datosActualizados.set("valor",30.5);
datosActualizados.set("fecha", “2021-03-16”);
datosActualizados.set("hora", “16:40:15”);

if (Firebase.updateNode(fbdo, "/IoT/temperatura/", datosActualizados)) {

Serial.println(fbdo.dataPath()); //imprime la ruta del nodo
Serial.println(fbdo.dataType()); //imprime el tipo de datos
Serial.println(fbdo.jsonString()); //imprime el contenido JSON retornado
} else {
Serial.println(fbdo.errorReason()); //imprime el error que haya ocurrido
}

Eliminar datos en Firebase desde ESP8266

Para eliminar un registro o nodo invoca al método deleteNode() de la clase Firebase y pasando como parámetros el
objeto de conexión y la ruta del nodo a eliminar.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 32 de

51
Firebase.deleteNode(fbdo, "/IoT/Registros/sensor");

Recuperar datos de Firebase con ESP8266

Los datos en un nodo o campo específico en Firebase RTDB se pueden leer a través de estas funciones de obtención
(get).

get, getInt, getFloat, getDouble, getBool, getString, getJSON, getArray, getBlob, getFile.

Estas funciones devuelven un valor booleano que indica el éxito de la operación, que será verdadera si se cumplen
las condiciones siguientes:

 El servidor devuelve el estado HTTP 200

 Los tipos de datos coincidieron entre la solicitud y la respuesta.

Los valores de cada campo (CLAVE:VALOR) de la base de datos se puede leer o acceder a través de las siguientes
funciones del objeto de datos de Firebase.

 fbdo.intData
 fbdo.floatData
 fbdo.doubleData
 fbdo.boolData
 fbdo.stringData
 fbdo.jsonString
 fbdo.jsonObject
 fbdo.jsonObjectPtr
 fbdo.jsonArray
 fbdo.jsonArrayPtr
 fbdo.jsonData (para mantener la estructura del resultado obtenido)
 fbdo.blobData

Cuando se utiliza alguna de estas funciones para obtener datos de nodos o campos cuyo tipo no coincide con el tipo
de datos en la base de datos, entonces se retornará un elemento vacío (cadena, objeto o matriz). El tipo de dato
retornado se puede determinar mediante fbdo.getDataType.

El siguiente ejemplo muestra cómo leer un valor entero:

if (Firebase.getInt(fbdo, "/IoT/temperatura/idSensor")) { //obtiene un dato entero

if (fbdo.dataType() == "int") { //si el tipo de dato recuperado es entero es entero
Serial.println(fbdo.intData()); //imprime el valor recuperado como un entero.
}
} else {
Serial.println(fbdo.errorReason()); //imprime la razón por la que no se recuperó el dato
}

Si se tiene la certeza del tipo de dato a recuperar no es obligatorio hacer las validaciones, pero nunca está de más
realizarlas para evitar errores.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 33 de

51
Ejercicio de CRUD básico desde SETUP() (Ejercicio 5)

En el siguiente sketch se aplican las funciones para insertar, actualizar y recuperar datos; se toma como base sketch
anterior por lo que solo se explicarán las líneas agregadas. De la línea 1 a la línea 29 es exactamente igual al anterior
por lo que se omitirán esas líneas.

De la línea 31 a la línea 44 son iguales al ejercicio anterior con la diferencia de que se cambió el número de iteraciones
del ciclo FOR para que inserta solo tres registros y se modificaron los datos de objeto JSON, solo por fines
demostrativos. En la línea 46 se ACTUALIZA el campo “valor” del nodo Temperatura utilizando el método setFloat(),
ya que la temperatura es un valor decimal. Este campo se actualizará siempre que se inserte un nuevo registro de
temperatura, y este campo será el mostrado en las interfaces de las aplicaciones. En caso de que se actualice
correctamente el campo se retornará TRUE y se imprimirá un mensaje con la ruta del campo. En la línea 49 se realiza
el mimo proceso, pero para el campo valor del nodo Humedad, dado que este campo almacena un valor entero se
emplea el método setInt().

En la línea 54 se recupera el valor almacenado en el campo “valor” del nodo Humedad, al ser de tipo entero se emplea
el método getInt(), de no ocurrir algún error en la recuperación de dato se valida que este sea de tipo entero con el
Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 34 de
51
método dataType(), en caso de coincidir se imprime un mensaje con el valor recuperado, el método intData()
convierte el dato a entero. En la línea 60 se realiza el mimo proceso para el nodo Temperatura, pero este al ser decimal
se usa el método getFloat() para recuperarlo y floatData() para convertirlo.

Figura 60 Datos insertados, actualizados y recuperados de RTDB

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 35 de

51
 Figura 61 Mensajes impresos durante el proceso de ejecución

Ejercicio de CRUD con datos recibidos desde Arduino por el puerto Serial (Ejercicio 6)

Bien, en el ejercicio anterior se demostró cómo realizar el CRUD básico (bueno faltó eliminar, pero eso no se utilizará
desde el módulo WIFI), el cual se ejecutó una solo vez desde el método setup(), pero para un proyecto de monitoreo
y control se necesita que se ejecute tantas veces como datos sean recibidos por el puerto serial de la módulo ESP01,
por lo que el CRUD debe colocarse o invocarse desde el método loop().

Como ya se comentado en reiteradas ocasiones, antes de codificar debe analizarse y comprenderse el problema a
resolver, y posteriormente diseñar un algoritmo para establecer el flujo de los pasos, es de vital importancia establecer
las reglas de comunicación entre la placa de Arduino y el módulo ESP-01. En este caso las lecturas de los sensores y
el estado de los actuadores conectados a la placa de Arduino se enviarán al módulo WiFi por el puerto serial con una
sintaxis “CLAVE=VALOR”, donde la CLAVE será el ID del sensor y/ actuador registrado previamente en RTDB , se usará
el signo IGUAL (=) en lugar de los “dos puntos” ya que estos últimos se usan en los mensajes que también son enviados
al puerto serial como resultado de las consultas e inserciones, y el VALOR es la lectura o estado del componente.

Para este ejercicio se toma como

base el ejercicio anterior por lo
que la mayoría de código es
similar, solo se cambia la lógica
de programa, es decir, el orden
en que se ejecutan las
instrucciones y las condiciones
establecidas. En la línea 12 se
declaran las variables
estadoActualBomba y
estadoLecturaBomba, ambas de
tipo byte, ya que solo
almacenarán un CERO o un UNO,
la primera variable almacena el
estado inicial de la bomba de
riego al encenderse el modulo
WIFI, y en la segunda los valores leídos posteriormente de la base de datos cada 5 segundos. En la línea 13 se declaran
las variables posActualServo y posLecturaServo las cuales también son de tipo byte ya que almacenaran los valores
del servomotor los cuales van de 0 a 180, por lo que es suficiente ya que byte almacena hasta 255.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 36 de

51
En la línea 14 se define las variables clave, pos y valor, también de tipo byte, para almacenar el ID del sensor, la
posición del signo “=” dentro de la cadena recibida, y el valor leído del sensor o actuador respectivamente. En la línea
16 y línea 17 se definen las variables tiempo_1 y tiempo_2 , ambas de tipo unsigned long para almacenar el tiempo
en el que se ejecuta cada uno de los dos métodos para leer el estado de los actuadores servomotor y bomba de riego
y finalmente en la línea 18 se declara la contante retardo de tipo unsigned int (entero sin signo que permite
almacenar un valor máximo de 65,535 ) para almacenar el tiempo en milisegundos en que se consultar el estado de
los actuadores en la base de datos.

Las líneas para conectarse la red wifi se colocaron dentro del método conectarWifi() el cual se invoca en la línea 23 y
se declara a partir de la línea 148. En la línea 28 se establece el tiempo de espera para la lectura de datos en la BD y
en la línea 32 se establece el tamaño y el tiempo de espera para la escritura en la Base de datos. En la línea 35 y línea
43 se extrae se consultan los estados actuales de los actuadores al momento de encender el modulo WIFI con el fin
de asignarlo a las variables estadoActualBomba y posActualServo respectivamente esto con el fin de comparar las
siguientes consultas de los estados y de ser diferentes significaría que han cambiado el estado desde las aplicaciones
WEB o MÓVIL, por lo que se notificará a Arduino a través del puerto serial utilizando la sintaxis previamente
establecida, para que actualice físicamente el estado del actuador. En caso de ocurrir algún error al realizar las
consultas a la base de datos, se ejecutar el método causaError() definido en la línea 117.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 37 de

51
 En el método loop() se agrega un
condición para verificar si se ha
recibo algo por el puerto serial
desde Arduino (línea 54) y en
caso de haber algo se lee y se
pasa como parámetro al
método controlPeticiones(), el
cual de declarar en la línea 67.
En la línea 57 y línea 61 se
verifica si ya han transcurrido los
5 segundos desde las última
lectura del estado de los
actuadores utilizando el método
millis(), esto también se puede
hacer con la librería Ticker, en
caso de haber trascurrido el
tiempo se invocan a los métodos
estadoServoMotor() y
estadoBombaRiego()
respectivamente.

En la línea 67 se define el método controlPeticiones(), el cual recibe como parámetro la cadena enviada por el puerto
serial desde Arduino. Primero se verifica que la cadena contenga el signo IGUAL, sino la contiene significa que es un
mensaje de depuración, en caso de contenerlo significa que es una instrucción, pero si la contiene, ya que previamente
se establecieron las reglas de comunicación entre ambas placas, las cuales consisten básicamente en enviar las
instrucciones con una estructura “CLAVE=VALOR”, donde la clave indica el ID del sensor que envía el dato y el valor
es la lectura obtenida de dicho sensor o el nuevo estado del actuador.

En caso de que la cadena si contenga el signo igual se extra la posición de este y se almacena en la variable pos para
usarla como delimitador para separar la cadena en dos partes, la primera parte se extrae desde la posición [0] hasta
[pos], se convierte a número entero y se almacena en la variable clave. Si la clave es igual a 2, se extrae el resto de la
cadena y se convierte a FLOTANTE ya que la clave dos corresponde al sensor de temperatura y esta tienen valores
decimales, si la clave no es igual a dos el resto de la cadena se convierte a entero (estado servo, bomba y humedad
son enteros).

En la línea 77 se define una estructura de control SWITCH para ejecutar las acciones correspondientes a cada clave
recibida, en las líneas 79, 85, 92, 99 se agregan los datos al objeto FirebaseJson con el método add(clave,valor); en las
líneas 80, 86, 93 y 100 se insertan los datos con el método pushJSON() y pasando como parámetros del objeto de
conexión, la ruta y el objeto Json que contiene los datos, sino ocurre algún error al insertar se ejecutará el método
resultadoInsertar(), el cual imprimirá la ruta y el ID del registro; en caso de ocurrir algún error se ejecutará el método
causaError() para imprimir la causa de este. En las líneas 81, 87, 94 y 101 se limpia el contenido del objeto FirebseJson
con el método clear(). Finalmente, en las líneas 82, 89, 96 y 103 se actualiza el campo valor de cada sensor o actuador
a fin de mostrar siempre la última lectura o estado de estos.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 38 de

51
Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 39 de
51
 En la línea 121 se define el método
estadoServoMotor(), en el cual en cual
se realiza una consulta para obtener el
valor del campo ”valor” del nodo o
colección ServoMotor, dado que este
campo siempre tendrá el ultimo
estado de este actuador.

Como el dato es numérico entero se

obtiene con el método getInt(), si no
ocurre algún error durante la
recuperación del dato en la línea 123
se verifica si el dato recuperado es de
tipo entero con el método dataType(),
esto no es estrictamente necesario si
se tiene la certeza del tipo de dato
almacenado en cada campo.

Se extra el dato convertido a un valor

numérico con el método intData() y se
almacena en la variable
posLecturaServo (línea 124), se
compara si este valor es diferente al
valor almacenado en la variable posActualServo consultado anteriormente (línea 125), en caso de ser diferentes
significa que se ha cambiado el estado del actuador, se actualiza este valor en la variable posActualServo (línea 126)y
se envía la notificación a Arduino por el puerto serial para realizar el cambio físicamente en el actuador.

En la línea 134 se define el método estadoBombaRiego()

el cual funciona exactamente igual que el método
estadoServoMotor().

En la línea 148 se define el método conectarWifi() en el

cual se colocan las mismas instrucciones que se tenían en
el método setup(), únicamente se colocaron en un nuevo
método para mantener el código limpio y ordenado.

Una vez codificado el sketch, cárgalo al módulo wifi, desconecta el pin GPIO0, abre el monitor serial y reinicia el
módulo, al encenderse el módulo verás en el monitor serial algo parecido a lo mostrado en la Figura 62, en la cual se
listan los mensajes enviados a través del puerto serial. De arriba hacia abajo los mensajes son los siguientes: 1->
caracteres al encender el modulo, 2-> mensaje indicando que el módulo inicia la conexión con la red wifi, 3-> imprime
un punto por cada intento de conexión, 4-> cuando logra conectase muestra el nombre de la red, 5-> muestra la IP
asignada al módulo por el DHCP de router, 6-> estado actual de la bomba, 7-> estado actual del servomotor, 8, 10, 12
y 14->ruta e Id del registro insertado, para obtener estos resultados introduce en la caja de entrada el monitor serial
las cadenas con el formato CLAVE=VALOR (1=35) , 9, 11, 13 y 15->Se actualiza el campo “valor” de los sensores y
actuadores con su última lectura o estado. En la Figura 63 se muestran los cambios en RTDB.

8->1=35
10->2=33.33
12->3=90
14->4=1

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 40 de

51
 1=35
1
2

3
4
5
6
7
8
9
10
11
12
13
14
15

Figura 62 Mensajes enviados al puerto serial

Figura 63 Inserción a Registros y actualización del campo "valor"

Ahora se demuestra la lectura de los actuadores, los cuales se monitorearán para detectar cambios en la base de datos
realizados a través de las aplicaciones web o móvil, es decir, si desde estas se ha encendidito la bomba o cambiado la
posición del servomotor. La lectura de estos campos se realizará cada 5 segundos.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 41 de

51
Desde la consola web de RTDB se modifica el valor de la Bomba de su estado actual (1) a cero (0), también modifica la
posición del servo de su estado actual (90) a 120, cambia nuevamente el estado de la Bomba a UNO (1) y el servo a
180. En la figura ____ se muestran los cambios realizados a los actuadores.

Figura 64 Lectura del estado del actuadores desde RTDB

Comunicación serial entre Arduino y ESP01 (Ejercicio 7)

Ya se ha explicado como conectar el módulo ESP01 usando Arduino UNO como puente para configurarlo con
comandos AT (Ejercicio 1.1), también se explicó cómo crear un puerto serial virtual usando otros pines que no sean
el pin RX<-0 y TX->1 (UART o serial por hardware) para monitorear todo lo que se envía y recibe entre ambas placas
usando la librería <SoftwareSerial.h> (Ejercicio 1.3), como conectarse a una red wifi (Ejercicio 2), y a realizar el crud
básico recibiendo los datos de los sensores por el puerto serial desde Arduino (Ejercicio 6), ahora describiremos el
sketch que se cargará en Arduino y que realizará la lectura de los sensores y el control de los actuadores enviando
dichos datos por el puerto serial al modulo ESP01.

Para realizar esto deben tomarse en cuenta algunos requerimientos:

 Las reglas de comunicación entre las dos placas, es decir, la sintaxis las instrucciones enviadas y recibidas.
 Si se desea ver dichas instrucciones y otros mensajes de depuración en el monitor serial, ya que de esta
decisión dependerá la conexión física de estas, y la creación de un puerto serial virtual.
 Si se desea ver las instrucciones y mensajes de depuración en el monitor serial: usar el diagrama de conexión
de la Figura 11, y crear un puerto serial virtual con <SoftwareSerial.h> (esto es recomendable cuando aún se
está desarrollando y/o codificando la solución)
 Si no se desea ver las instrucciones y los mensajes de depuración: usar el diagrama de conexión de la Figura
10. No es necesario crea un puerto serial virtual. (esto es recomendable cuando la solución IoT ya se ha
terminado y se va a implementar)

Para este caso como aún se está en desarrollo se mostrarán las instrucciones y mensajes de depuración en el monitor
serial, por tanto, se empleará el diagrama de la figura 11 y se creará un puerto serial virtual, para ello se retomarán el
Ejercicio 1.3. Para este ejemplo se consideran los sensores de temperatura (LM35), humedad (FC-28) y los actuadores
Servomotor y bomba de riego.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 42 de

51
 Se importan las librearías <SoftwareSerial.h> para
crear un puerto serial virtual; <Servo.h> para
controlar los servomotores y <Ticker.h> para
programar tareas asíncronas, es decir, indicar el
tiempo cada cuando se ejecutarán (en
milisegundos).

En la línea 6 se crear una instancia de la clase

SoftwareSerial y se indican los pines que se usaran
como emisor y receptor espSerial(RX,TX), recuerda
que para establecer la comunicación con el módulo
deben conectase los pines cruzados, es decir, RX-
>TX y TX->RX. En la línea 7 se crea una instancia de
la clase Servo.

De la línea 9 a la línea 12 de definen los constantes

de tipo byte para cada uno de los pines a utilizar por
los sensores analógicos (A0 y A1) y los actuadores.
De la línea 13 a la línea 15 se definen las variables
para almacenar las lecturas de los sensores, el
estado de los actuadores y las variables para separar
las instrucciones enviadas por ESP01 en puerto
serial.

En la línea 17 y línea 18 se inicializan los métodos

que serán gestionados como tareas asíncronas por
las instancias de Ticker en la línea 20 y línea 21
invocados cada 5 y 8 segundos respectivamente.

En el método setup() se inicializan el puerto serial

físico de Arduino (línea 24) a través del cual se
conectará la computadora para visualizar con el
monitor serial las instrucciones y mensajes de
debug enviados y recibidos entre el ESP01 y
Arduino. En la línea 25 se inicializa el puerto serial virtual a través del cual se enviarán y recibirán las instrucciones
con el ESP01. De indica el modo de operación de los pines utilizados, se asocia la instancia del Servomotor con el pin
correspondiente, se inicializa la posición en cero grados, y finalmente si inician las tareas asíncronas para
leerTemperatura() y leerHumedad().

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 43 de

51
 En el método loop() se verifica si hay
algo en el puerto serial virtual (línea
38) en caso de haberlo, se lee todo
el contenido y se pasa como
parámetro al método
controlPeticiones() el cual se define
en la línea 46 para que verifique que
instrucciones se está enviando.

En la línea 48 verifica si la cadena

recibida contiene el carácter “=”, en
caso de que no entonces solo es un
mensaje de depuración y se
imprime en el monitor serial en la
línea 64, pero en caso de contenerlo
significa que es una instrucción
enviada por el ESP01, por tanto, se obtiene la posición de este carácter y se almacena en la variable pos para utilizarse
como índice al separar la cadena en dos partes, la primera será la clave y la segunda el valor.

En la línea 52 se define una estructura de control SWITCH la cual recibe como parámetro la clave (en este caso la clave
es el idSensor) para ejecutar alguno de los casos (case) que contiene. Para este ejercicio solo se tiene dos actuadores
(servomotor con id=3 y bomba con id=4) que podrán ser controlados desde una página web y/o App móvil, por tanto,
solo se tienen dos casos en el switch; en el case 3 se invoca al método controlServo() el cual recibe como parámetros
el número de servo (este método se puede usar para controlar varios servos) y la nueva posición de este. En el case
4 se invoca al método controlarRiego() el cual recibe como parámetro el nuevo estado de este.

En la línea 67 se define el método

leerTemperatura() en el cual se
obtiene el valor devuelto por el sensor
analógico (línea 68) y se convierte a
grados Centígrados (línea 69), se
compara el valor obtenido con el valor
actual (línea 70), en caso ser iguales no
se hacen cambios, pero en caso de ser
diferentes la nueva lectura pasa a ser la
actual (línea 71) y se envía al módulo
ESP01 por el puerto serial virtual con la
sintaxis CLAVE=VALOR (“2=35.5”),
también se envía al monitor serial para
poder visualizarlo.

El mismo proceso se sigue en el método leerHumedad(), con la diferencia que aquí no se aplica una formula ya que la
humedad se representa en porcentaje se utiliza la función map() para escalar los calores obtenidos (0-1024) en el
puerto analógico aun valor porcentual de 0% a 100% (línea 79).

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 44 de

51
 En la línea 87 se define el método
controlarServo() el cual, como ya se
comentó en su invocación, recibe
dos parámetros, número de servo
y la nueva posición; en la línea 88 se
verifica si el numero servo enviado
es el UNO (de hecho solo hay uno en
este ejercicio, pero el método
podría gestionar más servos), en
caso de serlo se compara la nueva
posición con la actual (línea 89), en
caso de ser iguales no se realiza el
cambio, pero de ser diferentes se
mueve el servo a la nueva posición
(línea 90) y se asigna la nueva
posición a la variable
posActualServo (línea 91); se envía
la instrucción por el puerto serial
virtual (línea 92) y al monitor serial
(línea 93).

Finalmente, en la línea 99 se define el método controlarRiego() en cual recibe el estado del riego (0 para apagar y 1
para encender), se compara el valor del estado con CERO y que el estado actual sea diferente de CERO (no se puede
apagar algo que ya está apagado), en caso de no cumplirse las dos condiciones se verifica si estado es igual a UNO y
que es estado actual sea diferente de UNO. En cualquiera de los dos casos se cambia el estado de la bomba de riego
el nuevo estado guarda en la variable estadoActualRiego y se envía la instrucción al ESP01 por el puerto serial virtual
y al monitor serial.

A continuación, una descripción de los senadores utilizados para aplicar las formas y/o mapeos para obtener un valor
comprensible por el usuario final y acorde a la magnitud física que se está midiendo (Temperatura en grados
centígrados y humedad en porcentaje).

El FC-28 se distribuye con una placa de medición estándar que permite obtener la medición como valor analógico o
como una salida digital, activada cuando la humedad supera un cierto umbral. Los valores analógicos obtenidos van
desde 0 sumergido en agua (100% humedad), a 1023 en el aire (o en un suelo muy seco, 0% humedad). Un suelo
ligeramente húmero daría valores típicos de 600-700. Un suelo seco tendrá valores de 800-1023. La salida digital
dispara cuando el valor de humedad supera un cierto umbral, que ajustamos mediante el potenciómetro. Por tanto,
obtendremos una señal LOW cuando el suelo no está húmedo, y HIGH cuando la humedad supera el valor de consigna.

Figura 65 Relación entre % de humedad y valor de salida del sensor

Las entradas analógicas (A0-A5) devuelven valores entre 0 y 1023, o sea, 1024 valores. Esto quiere decir que si en el
pin tenemos 0V nos dará 0 y si tenemos 5V o 3.3V nos dará 1023, así de sencillo. Por lo tanto, si queremos saber que
voltaje tenemos en la entrada analógica solo debemos de multiplicar por 5/1024 (0.0048V de precisión). El LM35 en
un sensor de temperatura analógico cuya característica particular es que 1°C equivale a 10mV (0.01V), solo divide el
valor de voltaje obtenido antes entre 0.01 y nos dará la temperatura.
Temperatura = (valor * 5 / 1024) / 0.01 = valor * 5 * 100 / 1024 = valor * 500/1024

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 45 de

51
 Figura 66 inserción de registros desde Arduino y lectura de estados de actuadores

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 46 de

51
Marca Temporal en Firebase (ejercicio 8)

Una marca temporal, conocida también como registro de tiempo, cronomarcador, sello de tiempo o timestamp, es
una secuencia de caracteres que denotan la hora y fecha (o alguna de ellas) en la/s que ocurrió determinado evento.
Esta información suele presentarse en un formato consistente, lo que permite la fácil comparación entre dos
diferentes registros y el seguimiento de avances en el tiempo; la práctica de grabar marcas temporales de forma
consistente a lo largo de la información actual se llama timestamping. Las marcas generalmente se utilizan en el
seguimiento de eventos; a cada evento se le asigna una marca temporal. En los sistemas de archivos, la marca temporal
puede hacer referencia a la hora y fecha de creación, acceso o modificación de un archivo determinado.

Tiempo universal en Unix, un timestamp UNIX es el número de segundos desde 00:00:00 UTC (Tiempo Universal
Coordinado, un intermedio entre la versión en inglés Coordinated Universal Time CUT y la versión en francés Temps
Universel Coordonné TUC) del 1 de enero de 1970 (UNIX Epoch) hasta el momento en que se crea la marca temporal,
es usado también en Linux y en sistemas de Base de Datos como MySQL o DB2. Dicho UNIX timestamp es de amplio
uso para ordenación y seguimiento de información en aplicaciones distribuidas y aplicaciones dinámicas

Firebase dispone de funciones setTimestamp() y pushTimestamp() para insertar las marcas de tiempo en
milisegundos, lo cual es un numero de 13 dígitos, y para recuperar las marcas de tiempo se pueden emplear las
funciones getDouble() para recuperarlo en milisegundos o getInt() para recupero en segundos (10 dígitos), todo
dependerá que tan proceso se necesita que sea el valor para hacer operaciones.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 47 de

51
Se retoma el sketch del ejercicio 6 y se agrega la línea 78, en la cual usando el método setTimestamp() y pasando
como parámetros el objeto de conexión de tipo FirebaseData y la ruta del nuevo nodo
(“/ESP8266Test/marcaTiempo”) se inserta la marca de tiempo

Figura 67 inserción de registros con marca de tiempo

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 48 de

51
Act. U3.2-P1-Conexión Arduino+ESP01+firebase

Descripción de la actividad.

Una vez que hayas revisado la guía y realizado los ejercicios de demostración, retoma el sketch del equipo de
integradora (el bueno) y los materiales (físicos), conecta el módulo ESP01 y realiza lo siguiente:

1. Accede a Firebase con tu cuenta de Google y crea un proyecto, configura las reglas de seguridad para que terceros
puedan leer y escribir. Puedes retomar el proyecto de la actividad anterior.

2. Crea una base de datos Realtime database, agrega una colección (directorio) con el nombre de tu proyecto de
integradora (procura que sea una o dos palabras sin espacios) y agrega las subcolecciones que consideres
necesarias basándote en el modelo de la base de datos para tu proyecto de base de datos.

3. Codifica un sketch para el módulo ESP01, que haga lo siguiente:

a) Conectarse por el puerto serial con la tarjeta Arduino para que puedan enviar y recibir mensajes entre ellos.
b) Conectarse a la red wifi por cualquiera de los dos métodos descritos (SSID+passwod o WiFiManager)
c) Conectarse a Firebase con la URL de RealTime Database y la clave secreta de autenticación.
d) Las lecturas de los sensores conectados a Arduino serán enviados al Módulo ESP01 por el puerto serial
e) El módulo ESP01 recibirá los datos enviados por Arduino y los enviará a Firebase
f) El módulo ESP01 leerá los datos de actuadores (y umbrales, en caso de tenerlos) desde Firebase y los enviará
a Arduino por el puerto serial par que este los asigne a las variables y/o actuadores.

4. Realiza un reporte que contenga:

a. Captura del diagrama electrónico diseñado algún software afín (Fritzing, Tinkercad, circuito.io, etc)
b. Fotografía legible del circuito electrónico físico ordenando los cables para que se identifiquen las conexiones
(se recomienda usar cable UTP para conectar los componentes o cables jumper cortos)
c. Captura de la estructura FINAL de la base de datos en Realtime database (sin registros, solo la estructura)
d. Explicación del Script cargado al módulo WIFI (ESP01 o NodeMCU) con las funciones para conectarse a la
red wifi, insertar, actualizar y recuperar datos de Firebase.
e. Pruebas de funcionalidad: Realiza un plan de pruebas (tabla a cuatro columnas como en la actividad anterior)
mostrando una fotografía del circuito y/o capturas que evidencien el correcto funcionamiento. Incluir
pruebas para lo siguiente:
i. El módulo se conecta a la red WIFI (puede ser en el monitor serial, en pantalla LCD o con leds)
ii. Las lecturas de cada sensor se envían de Arduino al ESP01 por el puerto serial (monitor serial)
iii. El módulo ESP01 lee los datos enviados por Arduino y los inserta en la BD. (monitor serial y Firebase)
iv. Repite los pasos 2 y 3 para cada sensor de tu proyecto.
v. Activación del actuador cuando se hayan cumplido las condiciones establecidas en el umbral (captura
circuito, serial, y firebase)
vi. Repite el paso anterior con cada una de las condiciones establecidas para cada uno de los actuadores
del tu proyecto.
5. Exporta tu base de datos a un archivo JSON.

Forma de entrega:
Crea un directorio y coloca dentro el sketch de Arduino y el sketch del ESP01, el reporte PDF y el archivo JSON de la
base de datos empleada para esta actividad con los registros que se hayan insertado.

Mtro. Wilber Peñaloza Mendoza Aplicaciones de IoT Página 49 de

51