creaciÓn de un sistema domÓtico basado en …tauja.ujaen.es/bitstream/10953.1/9578/1/tfg antonio...

Escu

ela

Polit

écn

ica S

up

eri

or

de J

aé

n

UNIVERSIDAD DE JAÉN

Trabajo Fin de Grado

CREACIÓN DE UN SISTEMA

DOMÓTICO BASADO EN

ARQUITECTURA ARDUINO-GALILEO

Alumno: Antonio Castaño Blanco Tutor: Antonio Abarca Álvarez Dpto: Ingeniería Electrónica y Automática

Junio, 2018

Universidad de Jaén

Escuela Politécnica Superior de Jaén

Don Antonio Abarca Álvarez , tutor del Proyecto Fin de Carrera titulado: Creación de

un sistema domótico basado en arquitectura Arduino-Galileo, que presenta Antonio

Castaño Blanco, autoriza su presentación para defensa y evaluación en la Escuela

Politécnica Superior de Jaén.

Jaén, Junio de 2018

El alumno: El tutor:

Antonio Castaño Blanco Antonio Abarca Álvarez

Antonio Castaño Blanco Creación de un sistema domótico basado en arquitectura Arduino Galileo

Escuela Politécnica Superior de Jaén 2

Contenido 1. Introducción: ................................................................................................................... 4

2. Objetivo del proyecto: ..................................................................................................... 6

3. Material utilizado ............................................................................................................ 7

3.1. Estudio de parámetros a controlar en una instancia doméstica ............................... 7

3.1.1. Temperatura y humedad .................................................................................. 8

3.1.2. Movimiento .......................................................................................................... 9

3.1.3. Detección de humo y gas ................................................................................10

3.1.4. Nivel de luz .....................................................................................................11

3.1.5. Control de lluvia ..............................................................................................12

3.2. Material adicional ...................................................................................................13

3.2.1. Elementos de salida ........................................................................................13

3.3.1. ZigBee ............................................................................................................14

3.3.2. Z-Wave ...........................................................................................................14

3.3.3. Bluetooth Low Energy .....................................................................................14

3.3.4. WiFi .................................................................................................................15

3.4. ESP32 ....................................................................................................................15

3.4.1. Modo sleep .....................................................................................................16

4. Entorno de programación ..............................................................................................18

4.1. Software del microcontrolador: Arduino IDE ...........................................................18

4.1.1. Instalación de Arduino IDE para la placa ESP32 .............................................18

4.2. Aumento de los parámetros que definen la memoria en el ESP32 .........................20

5. Desarrollo del IOT .........................................................................................................22

5.1. Prestaciones ..........................................................................................................22

5.1.1. Acceso ............................................................................................................22

5.1.2. Canales ...........................................................................................................23

5.2. APPs ......................................................................................................................27

5.3. Talkbacks ...............................................................................................................28

5.3.1. Lampara ON/OFF ...........................................................................................29

5.3.2. Control de temperature ...................................................................................30

5.3.3. Seguridad ........................................................................................................31

5.3.4. Modo Calefacción/Aire ....................................................................................32

5.4. Inconvenientes de Thingspeak ...............................................................................32

6. Programación en Arduino IDE .......................................................................................34

6.1.1. Modo de funcionamiento activo-pasivo ...........................................................34

6.1.2. Modo de seguridad .........................................................................................35



6.2. Realimentación y dinámica end-to-end ..................................................................35

6.2.1. Modo activo-pasivo .........................................................................................35

6.2.2. Modo de seguridad .........................................................................................36

7. Aplicación móvil ............................................................................................................37

7.1. Herramientas..........................................................................................................38

7.1.1. De conectividad ...............................................................................................38

7.1.2. Sensores .........................................................................................................38

7.1.3. Sociales ..........................................................................................................38

7.1.4. De almacenamiento: .......................................................................................38

7.2. Funcionamiento ......................................................................................................38

7.2.1. Bloque de monitorización y seguridad .............................................................38

7.2.2. Bloque Modo activo .........................................................................................40

8. Presupuesto ..................................................................................................................42

9. Conclusión ....................................................................................................................43

10. Anexos: Códigos y Datasheets ..................................................................................44

10.1. Código Arduino ...................................................................................................44

10.2. Programación de bloques Thunkable ..................................................................64

Bloques comunes .............................................................................................................64

10.3. ESP32 DATASHEET ..........................................................................................74

10.4. HC-SR501 PIR Motion detector ..........................................................................89

10.5. Rain Sensor Module ...........................................................................................93

10.6. TSL2561 Luminosity Sensor ...............................................................................94

10.7. DHT 11 ...............................................................................................................95

Bibliografía ...........................................................................................................................98



1. Introducción:

Al escuchar la palabra domótica, todo el mundo asocia el término a un concepto,

más o menos verosímil. Pero, ¿Qué es realmente la domótica? Muy amplia y

variopinta ha sido la visión de la domótica desde hace más de cincuenta años, tanto

en el imaginario de la ficción como en la industria. Desde casas ultra inteligentes

portadoras de desmesurada inteligencia, pasando por robots mayordomos súper

sónicos, hasta apartamentos con más botones y palancas que una nave espacial. El

futuro no tenía límites.

¿Cuánto se ha aproximado la realidad a dicho imaginario? Vivimos en la era de

la Tecnología, de la comunicación, y a día de hoy, pocos avances han influido de

forma tan contundente sobre la sociedad en que vivimos como internet. Gracias (o en

consecuencia) a internet, somos capaces de comunicarnos a kilómetros de distancia

en cuestión de segundos.

Y al igual que lo hacemos los seres humanos, el internet de las cosas propone

que también lo hagan todo tipo de objetos. El internet de las cosas, concepto cuyo

origen se remonta a 2009, persigue la idea de conectar todo tipo de objetos a internet,

otorgando a cada uno de ellos una identidad (ID) e información asociada. Además,

persigue la interconexión de dichos objetos sin intervención humana. Son muchos los

avances que esta tecnología supone, desde el campo de la salud, hasta el medio

ambiente.

El desarrollo de la domótica en los últimos años va, en gran medida,

acompañado del internet de las cosas, ya que recolectando la información necesaria

de una vivienda, se produce una optimización de la automatización del sistema,

logrando así un aumento significativo en la calidad de vida de las personas. Ha sido

tal el impacto, que en los últimos meses, empresas de la importancia de Google y

Amazon, han lanzado su propio Smart Hub, dispositivo capaz de intercomunicar

diferentes objetos en una red domótica.

En este proyecto se estudiarán los parámetros a controlar en una instalación

domótica. Además, se diseñará e implementará un sistema de adquisición de datos

capaz de tomar las medidas propicias para controlar dichos parámetros para asó



establecer un sistema de comunicación inalámbrica, que nos permita tanto la

monitorización como la interacción con el entorno doméstico.



2. Objetivo del proyecto:

El objetivo de este proyecto es la creación de un sistema domótico basado en la

arquitectura Arduino, desarrollando un sistema de adquisición de datos a través de

una serie de sensores, que se adecúe a las necesidades que una casa pueda

presentar, y el correspondiente mecanismo de control que se requiera, así como

desarrollar un sistema de seguridad en consecuencia a la instalación. Para ello, se

hará uso del principio del end-to-end, arquitectura que establece una conexión que

comienza en los sensores y acaba en la aplicación móvil.

Con este proyecto, se espera obtener como resultado un aumento en el ahorro

energético, una mejoría en cuanto al confort del usuario y a la seguridad de la vivienda.

Se pretende establecer un sistema de control en que el usuario interaccione con

el entorno tanto de forma directa (reconocimiento de presencia, reconocimiento de

palmada), como de forma indirecta a través de una aplicación desarrollada en Android

(perfectamente extensible a IOS), de forma que se obtenga una arquitectura

centralizada de nuestro sistema, con la que controlar los diferentes parámetros de una

casa y poder monitorizar el estado de esta desde la distancia.

Para ello se habrá de diseñar un software a partir del microcontrolador escogido,

capaz de recabar información a través de los sensores, y de mandar y recibir datos a

través de dos redes inalámbricas: WiFi y Bluetooth Low Energy. Será también

necesaria la creación de una aplicación en el entorno de Android, que se comunique

con el microcontrolador y de un servidor que almacene los datos adquiridos por los

sensores.



3. Material utilizado

3.1. Estudio de parámetros a controlar en una instancia

doméstica

Para poder realizar el diseño del sistema de adquisición de datos, se han de

tener claro los parámetros que se busca controlar

A la hora de controlar una instancia doméstica, se han de tener en cuenta las

necesidades básicas, además de conocer las necesidades específicas del usuario a

quien la instalación va dirigida, pudiendo variar el diseño considerablemente en

función de la edad, condiciones de vida, o de las incapacidades específicas que los

usuarios puedan tener, logrando un acabado óptimo que se ciña a su entorno tanto

como sea posible.

Además, es indispensable establecer un sistema transversal, que sea capaz de

aunar versatilidad y personalización y que permita ser transformado y actualizado

según lo haga la vivienda o los avances tecnológicos.

La accesibilidad será otro de los objetivos a cubrir a la hora de diseñar nuestro

proyecto. Es importante que el entorno que desarrollemos sea intuitivo para todo el

mundo, independientemente del grado de familiarización que el usuario tenga con las

nuevas tecnologías. Si bien es cierto que se requiere un mínimo manejo que se da

por sentado y se escapa de las competencias del ingeniero en cuestión, como es el

saber utilizar un dispositivo móvil.

A la hora de llevar a cabo este proyecto, se han tenido en cuenta los parámetros

básicos, estando además el diseño limitado por el presupuesto del que se dispone.

El sistema domótico a diseñar, será capaz de controlar los siguientes

componentes:

Temperatura y humedad

Detector de movimiento

Detección de humos

Detector de inundaciones



Nivel de luz

Ilustración 3.1. Ejemplo sistema de adquisición de datos de una vivienda domotizada

A continuación se detallarán los citados parámetros, así como los componentes

utilizados para realizar la adquisición de datos.

3.1.1. Temperatura y humedad

Conocer la temperatura y humedad de la estancia a domotizar, permitirá la

climatización automática de la vivienda, de forma que cuando se exceda o no se

alcancen las condiciones deseadas por el usuario, se activen los dispositivos

pertinentes para lograrlo (calefacción, aire acondicionado, humidificador, etc.).

Sensor utilizado: DHT11

Para establecer el control de temperatura y humedad, se dispone de un sensor

DHT 11. El DHT 11 es un sensor digital que, alimentado por una señal continua de 5

Voltios, proporciona a la salida la señal calibrada de temperatura y humedad. Este

sensor está compuesto por un sensor de humedad resistivo, y un sensor NTC,

integrados en una PCB que contiene una resistencia de 100K encargada de linealizar

la medida.



Es capaz de tomar 1 muestra por segundo, su rango de temperaturas oscila entre

0 y 50, y puede medir una humedad relativa entre el 20% y el 80%. Estas

características hacen del DHT11 un sensor de capacidades muy limitadas respecto a

otros sensores NTC. Sin embargo, en relación al cometido que tendrá asociado, y su

bajo precio, se adecúa a las necesidades del proyecto.

Ilustración 3.2. Sensor DHT11

3.1.2. Movimiento

Es un parámetro que engloba los tres propósitos principales de la domótica:

Ahorro energético, confort, y seguridad. Con el control de movimiento es posible

reconocer la presencia de una persona, por ejemplo, al caminar por un pasillo, y

encender una luz mientras que la persona se encuentre en el pasillo.

La detección de movimiento puede, además, servir como método de seguridad

sustitutivo de la videovigilancia cuando el presupuesto sea limitado (como es el caso).

De forma que, cuando se detecte movimiento, el microcontrolador mande un aviso al

usuario mediante la aplicación del móvil.



Sensor utilizado: HC-SR501

El sensor encargado de la detección de movimiento será el HC-SR501. Es

sensor se compone del sensor pasivo de infrarojos (PIR) LHI778 y el BISS0001

encargado de la forma en que el movimiento es detectado.

Rango de detección: Aproximadamente 120 grados y 7 metros de profundidad.

Ilustración 3.3. Sensor PIR

3.1.3. Detección de humo y gas

Otro de los parámetros destinados exclusivamente al ámbito de la seguridad.

Con la detección de humo, el micro controlador mandará un aviso a la APP para avisar

a los usuarios del posible accidente doméstico, de igual forma viviendas donde se

utilice Gas Natural, Butano, o Propano, resulta indispensable un sensor capaz de

detectar posibles escapes de gas.

No mandará información de forma activa, tan solo cuando detecte un escape de

humo o gas.



Sensor utilizado: MQ-2

El sensor MQ2 es capaz de detectar CO, CH4 y LPG, así como humo se trata

de un sensor de alta sensibilidad, ajustable mediante un potenciómetro. Además, tiene

una vida útil relativamente larga y es de bajo coste.

Ilustración 3.4. Sensor MQ-2

3.1.4. Nivel de luz

El control del nivel de luz, empleado para acondicionar de forma automática la

luz de un área en función de la luz exterior recibida y las necesidades del usuario

(modo estudio, modo siesta, etc.).

Sensor utilizado: TSL2561

Transforma la luz recibida a una señal digital. Está compuesto por un fotodiodo

de banda ancha (visible e infraroja) y un fotodiodo de respuesta.

Ilustración 3.5. Sensor DHT11



3.1.5. Control de lluvia

En una vivienda pueden existir elementos que se deterioren con la lluvia, tales

como toldos. Una buena forma de evitar dicho deterioro es el de recoger o “esconder”

dichos elementos cuando llueva.

Sensor utilizado: Raindrop Module

El “Módulo de gota de lluvia” + Relé permite activar un motor que recoja el toldo

cuando el sensor detecta gotas de lluvia. El sensor actuará como un interruptor,

activándose cuando detecte lluvia, además de tener la capacidad de medir con qué

intensidad llueve. Una vez el interruptor se active, el relé pasará de NC (pin

normalmente cerrado) a NO (pin normalmente abierto) procediendo a la recogida del

toldo.

Ilustración 3.6. Módulo sensor de gotas de agua



3.2. Material adicional

Para llegar establecer la comunicación entre los sensores y el usuario (end-to-

end), además de los citados sensores se habrán de utilizar otros elementos básicos.

3.2.1. Elementos de salida

Serán los sustitutos de los dispositivos que en una vivienda doméstica se

controlarían. El uso de estos, en lugar de los reales viene justificado por el factor

económico que supone adquirir dichos dispositivos.

Por ello, se han utilizado leds y relees, que se encargarán de demostrar que la

emisión y transmisión de información en el sistema end-to-end se ha llevado a cabo

con éxito.

3.3. Selección del microcontrolador

Una vez claros cuales son los parámetros a controlar, así como los sensores

utilizados para la adquisición de datos e interacción con el usuario, habrá que escoger

un microcontrolador que se ciña a los objetivos y con envergadura suficiente como

para integrar los sensores escogidos.

Para ello, se han tenido en cuenta las características físicas y técnicas de varios

chips del mercado. Una unidad basada en el Internet de las cosas ha de integrar un

microcontrolador y un módulo de comunicaciones inalámbricas. Además, ha de ser de

pequeño tamaño y peso. Una de las claves en la elección es tener claro el tipo de

comunicación inalámbrica que se desea emplear.

Existen varios métodos para la emisión y recepción de datos de forma

inalámbrica, algunos de los más utilizados son WiFi, Zigbee, Bluetooth Le. El uso de

una u otra red inalámbrica repercutirá tanto en la instalación como en el

funcionamiento de la instalación.



3.3.1. ZigBee

ZigBee está diseñado para la comunicación inalámbrica a corto rango y

velocidad de transmisión de datos moderada. Sin embargo, la comunicación de

ZigBee con Android e IOS es difícil de implementar.

3.3.2. Z-Wave

Similar a Zigbee, Z Wave es un protocolo inalámbrico diseñado para monitorizar

aplicaciones en ambientes domésticos. Tiene un rango de 30 metros y opera en una

banda de frecuencia de sub-1 GHz, lo que lo hace no sensible a interferencias WiFi.

El gran inconveniente de Z-Wave es que todos los productos que usen la tecnología

Z-Wave han de ser certificados.

3.3.3. Bluetooth Low Energy

Complementario al ZigBee en muchos aspectos es el Bluetooth Low Energy

(BLE). De conexión inalámbrica de corto rango, menor que el de ZingBee (291 metros

frente a 77). Su gran ventaja reside la comunicación del BLE con los dispositivos

electrónicos como teléfono móvil o tablets. Esta modalidad de bluetooth se desarrolla

para el uso de dispositivos portátiles. BLE es capaz de dar soporte a un número

ilimitado de nodos. Actualmente, el uso de BLE como red inalámbrica se encuentra en

auge en el campo de la domótica.

La comunicación BLE no está siempre transmitiendo datos, sino que notifica

periódicamente a los clientes mandando bits de datos.

La conexión Servidor/Cliente se establece mediante el código UUID

(Identificador Único Transversal). Se trata de un código compuesto por 32 dígitos

Hexadecimales, divididos en cinco grupos.

La forma de comunicación que mantendrá el Servidor con el cliente en este

proyecto es la siguiente:



1. Servidor: Espera a que el cliente se conecte. Sólo un cliente puede

conectarse al servidor en un mismo instante de tiempo. Mientras que este

permanezca conectado, el servidor permanecerá invisible en el resto de

los dispositivos.

2. Cliente: Se conecta al servicio. Tanto el cliente como el servidor tienen el

mismo “Service UUID”.

3. Servidor: Se comunica con el cliente mandando una “característica”,

definida por el UUID Característico.

4. Cliente: Responde al servidor.

3.3.4. WiFi

El WiFi es la conexión más extendida hoy en día. Más rápido que ZigBee y BLE.

Es esencial para monitorizar una vivienda a distancia, ya que el dispositivo que se

encargue de monitorizar tan sólo requerirá de conexión a internet. Al tener una

compatibilidad nata con la IP, por lo que no habrá necesidad de comprar una puerta

de enlace a internet, lo que supone un ahorro de dinero importante. (5) En

contraposición, uno de los principales inconvenientes que el WiFi presenta es el alto

consumo de energía que le supondrá al microcontrolador la conexión continua a la red

WiFi.

3.4. ESP32

Dentro de los chips integrados que ofrece el mercado hoy en día, una de las

opciones más completas es el ESP32. Los principales motivos por los que se ha

elegido el ESP32 frente a otros chips son las siguientes:

Pequeño tamaño (25.5 x 18.0 x 2.8mm)

Bajo coste

Integración de módulo WiFi y Bluetooth



Ilustración 3.7. Diagrama de pines del ESP32

Hoy en día, ESP32 es el único sistema de bajo consumo que integra WiFi y

Bluetooth a un precio tan asequible. Aunando ambas comunicaciones inalámbricas,

permite tanto la monitorización a distancia como el envío y recepción directa de datos

(sin necesidad de un servidor que ralentice el proceso ni de la utilización de módulos

externos), por lo que se convierte en la opción ideal para el proyecto.

3.4.1. Modo sleep

Una de las características que más sobresalen en el ESP32 es el sleep mode.

El ESP32 tiene integrados dos tipos procesadores: El procesador principal, Xtensa 32,

y el procesador ULP (Ultra Low Processing), especialmente diseñado para el sleep

mode. Estos procesadores, permiten al chip cambiar de Power Modes (modo de

energía) según convenga.

Tipos de Power modes:

Modo activo: El chip recibe, transmite, y escucha.

Modo modem-sleep: La CPU está operacional, sin embargo las bandas

base del Bluetooth y del WiFi están desactivadas.



Modo lightsleep: CPU pausada, mientras que las memorias RTC (Real

time clock) y RTC periféricas están en funcionamiento, además del

procesador ULP.

Modo deep-sleep: Tan solo las memorias RTC, RTC periférica y el

procesador ULP están en funcionamiento.

La principal diferencia entre light-sleep y deep-sleep es que mientras que cuando

el chip se despierta del modo light-sleep, retomará por donde se quedó, mientras que

con el deep-sleep, se resetea el chip, comenzando entonces por la función setup().

Además, mientras que el modo light-sleep consume una intensidad de 0,8mA, durante

el deep-sleep tan solo se consume en torno a los µA.

Una vez iniciado el modo deep-sleep, existen varios métodos para despertar al

microcontrolador, los eventos wake-up. De entre estos eventos, en el proyecto se han

utilizado dos tipos:

Timer

External Wakeup (ext1)

Con el Timer se podrá “despertar” al chip tras un tiempo predefinido, mientras

que con el External wakeup(ext1) se podrán designar múltiples entradas que, cuando

se pongan a 1, reactivarán el microcontrolador.

No todos los pines de entrada del ESP32, se pueden configurar como ext1. Para

ello, se habrá de consultar la hoja de datos qué pines tienen la funcionalidad

RTC_GPIO.

En general, el ESP32 está capacitado de realizar proyectos de mayor extensión

que algunos de los microcontroladores más comunes en el mercado como su

predecesor, el ESP8266, el CC32, Xbee, o Arduino.

Como inconveniente al microcontrolador seleccionado, cabe destacar que el

ESP32 es un chip relativamente nuevo, por lo que la documentación y adquisición de

información resulta más complicada que, por ejemplo, en el caso del ESP8266.



4. Entorno de programación

4.1. Software del microcontrolador: Arduino IDE

El software escogido para desarrollar el programa es Arduino IDE. Arduino IDE

es un entorno Open Source basado en el Processing

Es uno de los entornos de programación más utilizados en el mundo del DIY (do

it yourself) debido a la gran cantidad de librerías disponibles, creadas por los propios

usuarios. Además, presenta una estética intuitiva, facilitando así el uso para

principiantes.

Sin embargo, una de las principales faltas encontradas a la hora de realizar el

proyecto es la carencia de una herramienta de depuración potente. La única forma de

“depurar” el programa es el uso de Serial.print() para buscar los posibles fallos que el

programa pueda contener, convirtiendo el proceso de depuración en una tarea de

acierto y error bastante engorrosa e imprecisa.

Otra de las carencias del software Arduino IDE es la disposición de herramientas

como IntelliSense (de Visual Studio) que nos permita ver los objetos que tiene una

clase como los parámetros de entrada requeridos. Herramienta que ha resultado casi

indispensable a la hora de utilizar clases de librerías cuya información es de difícil

acceso.

4.1.1. Instalación de Arduino IDE para la placa ESP32

Al no ser el ESP32 un producto oficial de la empresa Arduino, habrá que

descargar e instalar un software adicional que permita al Arduino IDE reconocer el

ESP32.

1. Descargar el último instalador de Windows de arduino.cc

2. Descargar e instalar el ejecutable GIT de git-scm.com

3. Arrancar GIT GUI



Ilustración 4.1 Instalación Arduino IDE para ESP32 (1)

1. Seleccionar “Open Existing Repostery”

2. Dirección del “Sketchbook directory”:

C:/Users/[YOUR_USER_NAME]/Documents/Arduino

3. Clic en “Clone”

4. Abre la carpeta:

5. [ARDUINO_SKETCHBOOK_DIR]/hardware/espressif/esp32/tools

6. Abre el archive get.exe

7. Conecta la placa ESP32 y los drivers se instalarán automáticamente

8. Una vez instalados los drivers, habrá que abrir Arduino IDE y seleccionar

Herramientas/Placa:”ESP32 Dev Module”





Arduino IDE está listo para utilizar la placa ESP32.

4.2. Aumento de los parámetros que definen la memoria en el

ESP32

Como ya ha sido mencionado anteriormente, uno de los inconvenientes del

ESP32 es su aún temprano tiempo de vida. Debido a ello, al intentar combinar las

librerías de comunicación WiFi y BLE, no será posible ejecutar el programa. Esto se

debe a que, la librería BLE por sí sola ocupa un 85% de la memoria de programa.

Como solución a éste problema, se propone modificar la partición de memoria

del ESP32, de forma que el chip destine más memoria al programa.

Para ello habrá que acceder a la siguiente dirección:



hardware/espressif/esp32/tools/partitions/default.csv

Abrir el archive y cambiar los parámetros por los siguientes:

# Name, Type, SubType, Offset, Size, Flags

nvs, data, nvs, 0x9000, 0x5000,

otadata, data, ota, 0xe000, 0x2000,

app0, app, ota_0, 0x10000, 0x190000,

app1, app, ota_1, 0x1A0000,0x190000,

eeprom, data, 0x99, 0x330000,0x1000,

spiffs, data, spiffs, 0x331000,0x0CF000,

Además, se aumentará el tamaño máximo de la placa, asignado en la siguiente

dirección: hardware/espressif/esp32/boards.txt

Habrá que buscar la placa esp32 y reemplazar el máximun size por el siguiente:

esp32thing.upload.maximum_size=1638400

Una vez realizados estos cambios, se podrán utilizar WiFi y BLE al mismo

tiempo.



5. Desarrollo del IOT

El Internet de las cosas (Internet of things) se refiere a dotar de representación

a los objetos del entorno digital mediante la asignación de IDs únicos, y de la conexión

de dichos objetos a la red. Mediante el Internet de las cosas, dichos objetos son

capaces de transferir datos de forma automática sin la necesidad de la interacción

humana en el proceso. Es decir, de máquina a máquina (M2M). El internet de las

cosas ha supuesto un gran avance en la domótica, sin embargo, el uso que se le da

hoy en día no es más que un atisbo de lo que llegará a suponer en un futuro.

Para conectar un objeto al IoT es necesario tener conexión a internet para

mandar y recibir datos a un servidor(o red de servidores, también conocida como

nube). En este proyecto, se ha establecido la conexión al servidor a través de WiFi.

El servidor elegido para mandar comunicar el microcontrolador con el IoT ha sido

Thingspeak. Existen muchos otros servidores para este propósito, sin embargo se ha

escogido Thingspeak por ser gratis, por ser Open Source, sus prestaciones y su

simplicidad.

5.1. Prestaciones

Thingspeak está compuesto por los canales y las Apps. Los canales de

Thingspeak almacenan los datos, mientras que las aplicaciones sirven para

transformar y visualizar datos (APP del móvil) o para provocar acciones en función de

los datos recibidos (alertas a Twitter, React, etc.).

5.1.1. Acceso

La transmisión y recepción de datos entre cliente y servidor se lleva a cabo

mediante los HTTP Requests.

HTTP Request, o Protocolo de transferencia de hipertexto (Hypertext Transfer

Protocol), se trata del protocolo de comunicación que utilizan los elementos de

software (clientes servidores, proxies) para comunicarse. El protocolo HTTP sigue el

esquema petición-respuesta entre un servidor.



Existen alrededor de veinte métodos de petición, en éste proyecto se han

implementado principalmente dos de ellos: GET y PUT

GET: Para obtener datos del servidor

PUT: Para actualizar el comando del Talkback.

Por ejemplo, si desde el móvil queremos encender una luz pulsando un botón, al

pulsar el botón la aplicación del móvil mandará un PUT Request con un comando. Al

mismo tiempo, el ESP32 realizará un GET Request, obteniendo el comando que

interpretará como “Encender luz”.

Este tipo de comunicación disminuye el coste de implantación así como facilita

actualización y prolongación de nuestro sistema.

5.1.2. Canales

Cada canal tiene un ID diferente, así como dos API KEYS, una de lectura (Read

API Keys) y otra de escritura (Write API Keys).

Los API Keys, son códigos auto generados, únicos de cada canal. Sirven para

escribir en canales, y para leer datos de canales privados. Las API Keys se usan,

también, en los HTTP Requests.

Para crear un canal habrá que rellenar los siguientes campos:

Channel Name: Nombre del canal

Description: Descripción del canal

Field: Para añadir campos al canal. En estos campos se almacenarán los datos

tomados por el ESP32. Cada canal es capaz de contener hasta ocho campos. En este

caso, se almacenarán los datos de temperatura y humedad, además de almacenar

las interrupciones por avisos de seguridad. Es recomendable no excederse en el uso

de fields, puesto que para subir dos datos a un canal han de pasar 26 segundos.

Metadata: Para incluir información sobre los datos el canal, acepta los

formatos JSON, XML, y CSV.



Latitude, Longitude y Elevation: Campos que especifican latitud, longitud

y elevación sobre el lugar en el que el sistema de adquisición de datos se

encuentra.

Link to External Site: En caso de tener un dominio web que contenga

información sobre el canal.

Video URL: En caso de tener un video de Youtube o Vieo que muestre

información del canal.

Para este proyecto se han utilizado tres cantales: APP, Sensores, y avisos.

APP: Se trata del canal utilizado como intermediario en los PUT Requests

que la aplicación móvil hará. Por ello, no contiene ningún gráfico.

Sensores: Almacenará los datos de la temperatura registrados en la

habitación, tomados por el sensor DHT11.

Avisos: Contiene una gráfica, en ella se almacenan los datos de seguridad

que registra el microcontrolador. Cada vez que el microcontrolador emite

un datos de seguridad, a su vez mandará un cero de forma que la

aplicación móvil tan solo reciba dicha alarma una sola vez. La gráfica

registrará un 1 con la detección de movimiento, un 2 tras detectar humo,

y un 3 tras la pulsación del botón manual que hará que se abandone el

modo de seguridad.

Ilustración 5.1. ThingSpeak: Selección de canal



Accediendo al Private View se observa:

Channel ID: 441717

Author: acb00045

Access: Private

Los últimos datos cargados de los “Fields”

Ilustración 5.2. ThingSpeak: Visualización de canal

Además, en API Keys están registrados los API KEYS del canal:

Read API Key: HEXF5DP0NJZFYGIT

Write API Key: PETLVYI3P8I6QFKG

API Requests: Es posible acceder a los API HTTP Request a través de los enlaces que

proporciona la página.



Ilustración 5.3. ThingSpeak: API Key de canal

Para obtener los últimos valores cargados en los “fields” habrá que usar el HTTP GET a

Channel Feed. Cambiando el valor de “results= ” se obtendrán más valores del campo:

https://api.thingspeak.com/channels/441717/feeds.json?api_key=PETLVYI3P8I6QFKG&results=2

Ilustración 5.4. ThingSpeak: Vista en JSON del canal



5.2. APPs

No contiene fields, si no que se usa para intercambiar “ordenes” entre el ESP32 y la aplicación

del móvil. Este intercambio de datos se realizará a través de la app de Thingspeak Talkback.

La “Private View” tan solo contiene:

Channel ID: 464964

Author: acb00045

Ilustración 5.5. ThingSpeak: Canal APP

De igual modo que antes, accediento a API Keys obtendremos las claves del canal:

Write API Key: CVZNJMLAT3IY2W3D

Read API Key: G3L4ZH0ZJT891DCW

A través del canal APP se puede obtener la localización del dispositivo móvil que se está

comunicando con el ESP32. Para ello habrá que utilizar “Get a Channel Feed”, añadiendo

“&location=true” al final del request:

https://api.thingspeak.com/channels/464964/feeds.json?api_key=G3L4ZH0ZJT891DCW&results=1&location=true



Ilustración 5.6. ThingSpeak: Vista en JSON del canal APP

5.3. Talkbacks

Thingspeak dispone de hasta nueve Apps diferentes. Este proyecto se limita al uso de una

sola App: Talkback.

Talkback ejercerá de intermediario para la emisión y recepción de órdenes entre el ESP32 y

la aplicación del móvil mediante comandos. Cada Request tiene asociado un ID, así como un

API Key. Cada comando tendrá a su vez asociado un “Command ID” que lo distinguirá del

resto de los comandos de un mismo Talkback.

Ilustración 5.7. ThingSpeak: Selección Talkback



5.3.1. Lampara ON/OFF

A través de éste Talkback se encenderá y apagará un LED desde la distancia.

La idea de ésta función es simular la existencia de una presencia en la vivienda que

haga creer a posibles ladrones que hay alguien dentro de casa.

Ilustración 5.8. ThingSpeak: Talkback Lampara ON/OFF

Para obtener el último comando recibido por la aplicación móvil, habrá que

introducir el GET Request en la barra de direcciones:

https://api.thingspeak.com/talkbacks/26890/commands/COMMAND_ID.json?api_key=FUAEMW0Y8LO4N8XL



Ilustración 5.9. ThingSpeak: Vista JSON del Talkback Lampara ON/OFF

5.3.2. Control de temperature

Con éste Talkback será posible establecer la temperatura deseada de la vivienda

a distancia.

Ilustración 5.10. ThingSpeak: Talkback Control de temperature



5.3.3. Seguridad

Hará saber al ESP32 cuando el usuario cambia la aplicación móvil al modo

Seguridad, de forma que se mande un aviso de seguridad dadas unas condiciones

específicas.

Ilustración 5.11. ThingSpeak: Talkback Seguridad

Cuando Command string esté a 1, significará que el modo Seguridad ha sido

activado, mientras que si Command string está 0, el modo Seguridad permanecerá

desactivado.



5.3.4. Modo Calefacción/Aire

Parámetro que definirá el lazo de control, estableciendo el modo calefacción o

aire además de mandar la señal que activará y desactivará el sistema de control.

Ilustración 5.12. ThingSpeak: Talkback Modo Calefacción/Aire

5.4. Inconvenientes de Thingspeak

Como principal inconveniente, cabe señalar que la velocidad de subida de datos

es limitada, por lo que en un programa de tamaño considerable, la ralentización sería

demasiado evidente. Es por ello que en este proyecto, utilizaremos este medio de

comunicación con el fin casi exclusivo de monitorizar (para la interacción directa se ha

empleado bluetooth).

Además, la imposibilidad por parte del ESP32 de realizar PUT Requests al

talkback, dejando como única opción para realizar la realimentación del bucle de



control la subida al servidor de la variable a realimentar a través de un campo de un

canal, realentiza el bucle de control de forma considerable.

5.5. Seguridad

Los canales privados de Thingspeak se comunican con los respectivos clientes

mediante protocolo seguro de transferencia de hipertexto (HTTPS), la versión seguro

de HTTP.

A diferencia del HTTP, su versión segura encripta la comunicación establecida

entre Thingspeak y sus clientes (ESP32 y la App del móvil), mediante el protocolo

SSL(Secure Socket Layer).

El certificado SSL garantiza que, aunque alguien sea capaz de acceder de forma

fraudulenta a la conexión, no sea capaz de desencriptar los datos enviados.



6. Programación en Arduino IDE

A continuación, se explicará el funcionamiento del programa desarrollado, para

después exponer el código utilizado.

El programa consta de dos modos de funcionamiento diferentes, en función de

las necesidades del usuario. Ellos son:

Modo de funcionamiento activo-pasivo

Modo de seguridad

6.1.1. Modo de funcionamiento activo-pasivo

Es el modo por defecto. Cuando esté activo, se activará una interrupción por

timer, que permita el control remoto de un número limitado de dispositivos a través de

WiFi, así como se actualizarán los datos a monitorizar. Mientras que el WiFi esté

desconectado, se podrán mandar peticiones a través del móvil, sin embargo, estas se

ejecutarán tan sólo una vez el WiFi haya sido reactivado. De esta forma se favorece

el ahorro de energía durante este modo. La comunicación BLE permanecerá activa

todo el tiempo, a la espera de que algún dispositivo se conecte. Cabe destacar, que

existe un corto periodo de tiempo durante el cual el WiFi se estará reactivando, motivo

por el que la conexión BLE puede ser levemente ralentizada.

A través de la conexión mediante BLE, el ESP32 mandará la temperatura de

salida (obtenida por un potenciómetro, para facilitar el visibilizado del sistema de

control) y podrá recibir:

La activación y desactivación del sistema de control

Temperatura de referencia

Modo frío o calor

Encendido y apagado de leds, tanto de forma independiente como a la

vez



6.1.2. Modo de seguridad

El modo de seguridad ha sido pensado para cuando el usuario, o bien esté

ausente del núcleo doméstico, o quiera activar las funciones de seguridad del sistema

(por ejemplo, cuando el usuario se vaya a dormir por la noche).

Una vez que el microcontrolador reciba, a través del servidor, que el modo de

seguridad ha sido activado, el chip pasará a modo deep-sleep, de forma que el ESP32

podrá ser despertado por tres motivos:

Por un timer, para así actualizar las variables a monitorear (como

temperatura o humedad).

Porque uno (o varios) de los sensores del ámbito de la seguridad han

detectado una falta, lo que provocará un aviso directo al usuario a través

de un buzzer y de un sms.

Mediante la pulsación de un botón, lo que devolverá al sistema al modo

de funcionamiento activo-pasivo (también posible a través de la app móvil)

6.2. Realimentación y dinámica end-to-end

El método de control a utilizar dependerá del modo de funcionamiento en que

nos encontremos.

6.2.1. Modo activo-pasivo

Se ha dispuesto un sistema de realimentación en bucle cerrado, tanto para el

estado de las luces como para el control de temperatura.

En todo momento ha de haber una realimentación que haga que cada vez que

el estado de un dispositivo cambie por causas ajena a la app (reseteo del

microcontrolador, o cambio de estado manual), el microcontrolador “avise” a la app de

ello de forma que se vea reflejado el cambio.

Esto se debe a que la comunicación mediante Bluetooth Low Energy no dispone

de punto intermedio, si no que se trata de una comunicación directa entre el ESP32 y



el móvil, es por ello que en caso de fallo, o de cambio de estado por causa ajena a

dicha comunicación, será la causa ajena la que prevalezca, teniendo la interfaz gráfica

que adaptarse. Por ejemplo, si apago una de las luces controladas por la app de forma

manual, en la app el switch que controla dicha luz ha de ponerse en modo off. En el

caso de los leds, al no estar vinculados a ningún accionamiento manual, en caso de

reseteo, simplemente habrán de apagarse. Sin embargo, con los relés, la aplicación

sí se adaptará en todo momento al estado del relé, al igual que el relé lo hará al estado

fijado por la app.

6.2.2. Modo de seguridad

En caso de encontrarnos en modo seguridad, el sistema de control cambiará

radicalmente. Debido a que el cometido del modo de seguridad es la monitorización a

distancia, el estado fijado por la aplicación prevalecerá sobre las posibles causas

ajenas que hagan al elemento cambiar de estado. En el modo de seguridad la

comunicación será vía wifi, utilizando un servidor como intermediario (IOT) donde se

almacenará el estado fijado por el usuario mediante la app. En cada ciclo en que el

WiFi esté en activo, el microcontrolador accederá al último dato almacenado en

Thingspeak, dato que permanecerá constante a no ser que desde la aplicación móvil

se ordene lo contrario. Es por ello que en caso de reseteo, la información que el móvil

mandará al ESP32 no se perderá.



7. Aplicación móvil

Para el desarrollo de la interfaz del móvil, se ha recurrido a la plataforma

Thunkable, que utiliza el entorno de programación por bloques MIT App Inventor, pero

ofrece ciertas ventajas respecto del original, como por ejemplo la opción “Thunkable

Live”, que permite simular la aplicación mientras se aplican cambios en ella.

Se ha empleado este entorno en lugar de entornos más puros como Android

Studio, la herramienta de desarrollo oficial de Android, por la intuitividad que esta

herramienta ofrece. Dado que el desarrollo de la aplicación móvil no es un objetivo del

proyecto, sino una herramienta de apoyo al sistema de control y comunicación

establecido, Thunkable se acopla a la perfección a tal finalidad.

Como inconveniente cabe resaltar que, en función de la complejidad que la

aplicación requiera, Thunkable presenta limitaciones, además del desorden que

generan los bloques una vez que la aplicación aumenta su tamaño.

La aplicación está compuesta por dos ventanas, una para cada modo de control.

Aunque en un principio se diseñaron en espacios diferentes, finalmente se unieron en

un mismo espacio, de forma que teoría la aplicación está compuesta de una sola

ventana útil, pero a nivel visual serán distinguibles. Esto se consigue gracias a la

arquitectura de “Agrupamientos” (arrangements) en los que se pueden dividir los

modos de funcionamiento, y la propiedad de hacer dichos agrupamientos visibles o

invisibles a petición del programador.

En función de cómo dispongamos los agrupamientos, el menú adquirirá una

apariencia u otra.



7.1. Herramientas

Thunkable presenta una serie de herramientas que permiten una personalización

de la aplicación, aunque escasas en lo visual, abundantes en el aspecto técnico.

Dentro de las herramientas utilizadas en este proyecto, caben destacar:

7.1.1. De conectividad

Permiten iniciar la conexión con el servidor a través de WiFi o con el dispositivo

directamente con el BLE.

7.1.2. Sensores

Clock: Desempeña una función similar a la de la interrupción por timer.

7.1.3. Sociales

Texting: Permite mandar un sms a un número determinado, dadas unas

condiciones definidas. Herramienta muy útil para mandar los avisos pertinentes

cuando el microcontrolador se encuentre en modo deep-sleep.

7.1.4. De almacenamiento:

Tiny DB: Guarda el estado de las variables que se le asocien.

7.2. Funcionamiento

7.2.1. Bloque de monitorización y seguridad

Una vez abierta la aplicación, se inicializará el bloque de monitorización y

seguridad por defecto. En cuestión de pocos segundos aparecerán los últimos datos

de temperatura y humedad registrados por Thingspeak.



Esta pantalla ofrece el control de temperatura a distancia, a través de WiFi. Para

poder inicializar el proceso de control, se ha de pulsar el botón ON. Una vez pulsado

el botón, se activarán los botones “FRÍO”, “CALOR”, “+”, y “-“.

La acción de control de este método, no es tan inmediata como con BLE, puesto

que para ganar en eficiencia energética se ha de regular el periodo de tiempo de

activación del WiFi.

Además del control de temperatura, también se puede marcar o desmarcar la

casilla “Modo de seguridad”, que pondrá al microcontrolador en modo deep-sleep.

Dichas acciones serán ejecutadas por el ESP32 una vez activada la interrupción

por timer.

Ilustración 7.1. Visualización Pantalla “Monitorización”



7.2.2. Bloque Modo activo

En cuanto el usuario pulse el botón “Monitorización”, de encontrarse disponible

(ya que sólo un cliente puede conectarse al servidor de forma simultánea), se

establecerá la conexión BLE entre el móvil y el ESP32.

Una vez establecida la conexión, se pueden encender y apagar los leds, y

realizar el control de temperatura, similar al del bloque de monitorización pero de

carácter inmediato.

Ilustración 7.2. Visualización Pantalla “Modo Activo”



Existe cierta sincronía entre ambos modos de funcionamiento, de forma que si

no pongo el control de temperatura a OFF en un modo, éste se mantendrá activo en

el otro, ya que no tendría sentido tener que encender un dispositivo que no ha sido

apagado previamente.



8. Presupuesto

A continuación se dará lugar a la elaboración del presupuesto del proyecto. Se

trata de un presupuesto aproximado, ya que el precio de los componentes utilizados

puede oscilar en un rango muy amplio.

8.1. Material

Concepto Cantidad Coste total(€)

ESP32 Development Board 1 6.21

Sensor de Movimiento PIR HC-SR501

1 1.88

Sensor de luminosidad TSL2561

1 5.01

Módulo sensor DHT11 1 5.60

Sensor detector de lluvia 1 10.65

Sensor Gas MQ-2 1 4.99

Kit leds de colores 1 7.53

Potenciómetro giratorio 10k 1 2.26

Subtotal 44.13

Tabla 8.1

8.2. Mano de obra

Tipo de mano de obra

Concepto Cantidad [horas] Coste unitario

[€/h] Coste total [€]

Ingenieril Desarrollo conceptual

70 12.00 840

Ingenieril Programación

de código 250 12.00 3000

Subtotal 3840

Tabla 8.2

8.3. Total

Tipo de coste Coste total [€]

Material 44.13

Mano de obra 3840

TOTAL 3884.13

Tabla 8.3



9. Conclusión

Se puede concluir que se ha logrado establecer un sistema de control end-to-

end que satisface las necesidades básicas de la domótica mencionadas al principio

del proyecto. Gracias a los parámetros de control definidos, se ha diseñado un sistema

de adquisición de datos correcto que ha permitido el diseño e implementación de un

sistema domótico capaz de interactuar de forma activa y pasiva con su entorno,

creando unas dinámicas de control distintas en función del tipo de parámetros que se

han controlado. Se ha garantizado la implementación de un sistema que garantiza el

confort del usuario, así como fomenta la eficiencia energética de la vivienda y

seguridad.

Además, cabe destacar el acierto en la elección de la placa. El ESP32 supone

un gran avance en la domótica “low cost”, y aunque su potencial aún no ha sido

explotado al 100% por sus desarrolladores, ya presenta características realmente

excepcionales. Gracias a la integración de WiFi y Bluetooth en una sola placa, ha sido

posible la elaboración de diferentes lazos de control, en función de las necesidades

del usuario. Además, el uso del modo deep-sleep, que garantiza una eficiencia

energética fuera del alcance de otras placas del mercado de precios similares.

Cabe destacar, la capacidad de extensión que tanto software como hardware

permiten en la vivienda, dejando la puerta abierta a la creación de un sistema más

amplio y completo en dependiente de un mayor presupuesto, que permita costear un

servidor más rápido, además de dispositivos de mayor envergadura a los que incluir

en el lazo de control.



10. Anexos: Códigos y Datasheets

10.1. Código Arduino

A continuación se expone el código escrito para el proyecto, detallando las partes

más relevantes y significativas de forma que se facilite la comprensión de este en

medida de lo posible.

10.1.1. Librerías

Para poder llevar a cabo el proyecto, se han tenido que utilizar librerías

adicionales a las que trae Arduino IDE por defecto. A continuación, se detallan las

librerías utilizadas por el programa:

Librerías destinadas a la conversión de los datos tomados por los sensores a

sus variables correspondientes:

#include "DHT.h"

#include <Adafruit_TSL2561_U.h>

Ambas pertenecen a “Adafruit Unified Sensor Driver”, convertirán el valor de

tensión en grados Celsius y Lux respectivamente.

Se encarga de decodificar y codificar el formato JSON, formato utilizado para

mandar y recibir datos a ThingSpeak en forma de HTTP Requests.

#include <ArduinoJson.h>

Librería WiFi del ESP32 (no confundir con la que trae Arduino de serie)

#include "WiFi.h"

Conjunto de librerías utilizadas que permiten implementar el BLE en ESP32

#include <BLEDevice.h>

#include <BLE2902.h>

#include <BLEServer.h>

#include <BLEUtils.h>

#include "esp_sleep.h"

#include "esp_bt_main.h"



Sube los datos a Thingspeak

#include "ThingSpeak.h"

10.1.2. Defines

Mediante el uso de “#define”, cada vez que aparezca una de las constantes, el

compilador la sustituirá por su valor.

#define POTENCIOMETRO 35

#define GREENLED 27

#define REDLED 12

#define REDLED2 26

#define REDLED3 14

#define REDLED4 25

#define WHITELED 4

#define WHITELED2 13

#define DHTPIN 16

#define DHTTYPE DHT11

#define sensorPIR 32

#define SENSORSONIDO 4

#define SENSORLUZ 22

#define SENSORMQ2 17

#define SCL 21

#define SDA 22

#define BUTTON_PIN_BITMASK 0x700000000 // PINES DE EXTERNAL WAKE UP 32(PIR)

34(PULSADOR) 33(humo)

#define uS_TO_S_FACTOR 1000000 /* Conversion factor for micro seconds to

seconds */

#define TIME_TO_SLEEP 15 /* Time ESP32 will go to sleep (in

seconds) */

10.1.3. Declaración de variables

Para conectar el microcontrolador tanto a la red WiFi como al servidor al que

enviará y del que recibirá datos, se ha de definir:

La red a conectar y su contraseña:

const char* ssid = "vodafoneA4E0";

const char* password = "DCKC2WNAJF292E";

El servidor y cliente, así como el host (thingspeak en este caso) y el puerto:

const int httpPort = 80;

WiFiServer server(httpPort);

WiFiClient client;

const char host[19] = "api.thingspeak.com";

Claves para establecer la emisión y recepción de datos a travésde ThingSpeak:



// Manda a thingspeak temperatura y humedad

const char TempHumChannelApiKey[] = "HEXF5DP0NJZFYGIT";

const char TempHumChannelID[] = "441717";

//recibe ubicación

const String location_channel = "464964";

const String location_apiKey_read = "G3L4ZH0ZJT891DCW";

//Encender apagar LED

const String onoff_talkback_apikey = "FUAEMW0Y8LO4N8XL";

const String onoff_talkback_id = "26890";

const String onoff_talkback_command = "13265648";

//Recibe Temperatura deseada

const String controlremp_apikey = "LEL9XXPEOXAM8BCT";

const String controltemp_command = "12842299";

const String controltemp_id = "26269";

//modo seguridad

const String seguridad_apikey = "GAS46RKXAGEYEGD2";

const String seguridad_command = "13194057";

const String seguridad_id = "26810";

// WRITE KEY DETECTA PIR

const String detectaPIR_apikey = "CVZNJMLAT3IY2W3D";

//Modo de temperatura de control

const String modotemp_apikey = "ZB4BMSXREMA3T2A7";

const String modotemp_command = "13236894";

const String modotemp_id = "26850";

const char host[19] = "api.thingspeak.com";

Declaración de variables requeridas para la emisión y transmisión de datos

mediante el BLE:

BLECharacteristic *pCharacteristic;

bool deviceConnected = false;

float txValue = 0;

std::string rxValue;

String temp_ble;

int ble_modo_control = 0; //1 modo frio 2 modo calor 0 apagado

char ble_recibido;

bool ble_control_temp; // ON: Enciende aire o calefacción

int cinfraTemp = 1; //valor de la temperatura de referencia

Definición de los UUIDs de Servicio y Característica.

#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"

#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"

#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

Clase que pondrá el flag “deviceConnected” dependiendo de si el cliente se

conecta o desconecta del servicio.

class MyServerCallbacks : public BLEServerCallbacks

void onConnect(BLEServer* pServer)

deviceConnected = true;

;

void onDisconnect(BLEServer* pServer)

deviceConnected = false;



;

Clase que se encarga de leer la respuesta del cliente y transcribirla para su

posterior interpretación.

class MyCallbacks : public BLECharacteristicCallbacks

void onWrite(BLECharacteristic *pCharacteristic)

rxValue = pCharacteristic->getValue();

Si recibo un valor:

if (rxValue.length() > 0)

for (int i = 0; i < rxValue.length(); i++)

temp_ble = temp_ble + rxValue[i];

Si el valor recibido es un número, lo paso a int y lo guardo en otra variable ya

que lo recibido ha sido el valor de la temperatura de referencia.

if(temp_ble.toInt()!=0)

cinfraTemp = temp_ble.toInt();

;

Timers para el control de temperatura (DHT y potenciómetro)

//TIMER 0 TOMA DE TEMPERATURA DHT11

hw_timer_t *timer = NULL;

volatile bool flag_sTemp;

void IRAM_ATTR onTimer()

flag_sTemp = true;

//TIMER 1 TOMA DE TEMPERATURA POTENCIOMETRO

hw_timer_t *timer1 = NULL;

volatile bool flag_potenciometro;

void IRAM_ATTR onTimer1()

flag_potenciometro = true;

Resto de variables

int control_temp = 0;

int t,h;

bool flag_seguridad = false;

bool ant_flag_seguridad = true;

int detecta_pir = 0;

unsigned long previousMillis = 0;

const long interval = 8000;

int cinfraTemp = 0;

char ble_recibido;

int ble_modo_control = 0; //1 modo frio 2 modo calor 0 apagado

int wifi_modo_control = 0;//igual

bool inout;

bool temporizador = true; //activa o no el temporizador

bool flag_wifi;



bool led1,led2;

bool ble_control_temp;

bool wifi_control_temp;

int valor_potenciometro=0;

int ant_valor_potenciometro;

int bombillas = 0;

int ant_bombillas = 0;

bool flag_bombillas;

int aire =0;

int ant_aire;

bool flag_reset;

int valor_potenciometro=0;

int bombillas = 0;

int ant_bombillas = 0;

bool flag_bombillas;

bool flag_seguridad = false;

bool ant_flag_seguridad = true;

bool flag_wifi;

Declaración de contructores de los sensores de Temperatura/Humedad y

Luminosidad.

Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT,

12345);

DHT dht(DHTPIN, DHTTYPE);

Constructor y variables del timer que activará el WiFi de forma periódica

10.1.4. Sleep Mode

Se utiliza para reconocer la cause que haga despertar al ESP32 una vez iniciado

el deep sleep.

RTC_DATA_ATTR int bootCount = 0;

void print_wakeup_reason()

esp_sleep_wakeup_cause_t wakeup_reason;

wakeup_reason = esp_sleep_get_wakeup_cause();

Serial.println("");

Serial.println("");

Serial.println("EXT1 Test");

switch (wakeup_reason)

case 1 : Serial.println("Wakeup caused by external signal using

RTC_IO"); break;

case 2 :

Serial.print("Wakeup caused by external signal using RTC_CNTL ");

Serial.println((uint32_t)esp_sleep_get_ext1_wakeup_status(),HEX);

print64(BUTTON_PIN_BITMASK);

Serial.println();



break;

case 3 : Serial.println("Wakeup caused by timer"); break;

case 4 : Serial.println("Wakeup caused by touchpad"); break;

case 5 : Serial.println("Wakeup caused by ULP program"); break;

default : Serial.println("Wakeup was not caused by deep sleep"); break;

void print64(uint64_t number)

for (int i = 0; i < 64; i++)

bool bitt = number & 0x8000000000000000;

Serial.print(bitt);

number = number << 1;

10.1.5. Funciones

Timer: Pone flag_sTemp a true para poder acceder a esa parte del código en el

loop

void IRAM_ATTR onTimer()

flag_sTemp = true;

Conectar a red WiFi:

void WiFiconnect()

WiFi.begin(ssid, password);

Serial.println( WiFi.SSID() );

Serial.println( WiFi.psk() );

while (WiFi.status() != WL_CONNECTED)

delay(500);

Serial.print(".");

Serial.println("CONECTADO!");

Mandar datos a través de BLE

Función que manda la temperatura de salida

void ble_tx_int(int numero_enviar)

int modo = 2;

char modostring[1];

char txString[8]; // PENDIENTE A REDUCIR TAMAÑO

char numString[2];

char bombillasString[1];

dtostrf(numero_enviar, 1, 0, numString);

dtostrf(modo, 1, 0, modostring);

char DataString[10];

sprintf(DataString, "%d,%d",modo, numero_enviar);

pCharacteristic->setValue(DataString);

pCharacteristic->notify(); //manda valor a la app



Función que manda el estado de los leds y del control de temperatura

void ble_tx_string(int bombillas,int aire)

int modo = 1;

char modostring[1];

char aireString[1];

char bombillasString[1];

dtostrf(aire, 1, 0, aireString);

dtostrf(bombillas, 1, 2, bombillasString);

dtostrf(modo, 1, 0, modostring);

char DataString[16];

sprintf(DataString, "%d,%d,%d",modo, bombillas, aire);

pCharacteristic->setValue(DataString);

pCharacteristic->notify(); //manda valor a la app

Recibe datos a través de BLE

Dependiendo de la letra recibida, se indicará la configuración de la aplicación

móvil.

void ble_rx()

if (temp_ble == "A" && ble_recibido != 'A')

//Serial.println("Turning ON!");

led1 = true;

ble_recibido = 'A';

else if (temp_ble == "B" && ble_recibido != 'B')

led1 = false;

ble_recibido = 'B';

else if (temp_ble == "C" && ble_recibido != 'C')

led2 = true;

ble_recibido = 'C';

else if (temp_ble == "D" && ble_recibido != 'D')

led2 = false;

ble_recibido = 'D';

else if (temp_ble == "F" && ble_recibido != 'F')

ble_modo_control=1;

ble_recibido = 'F';

else if (temp_ble == "G" && ble_recibido != 'G')

led1 = true;

led2 = true;

ble_recibido = 'G';

else if (temp_ble == "H" && ble_recibido != 'H')

led1 = false;

led2 = false;

ble_recibido = 'H';



else if (temp_ble == "K" && ble_recibido != 'K')

ble_control_temp = true;

ble_recibido = 'K';

else if (temp_ble == "J" && ble_recibido != 'J')

ble_modo_control=2;

ble_recibido = 'J';

else if (temp_ble == "E" && ble_recibido != 'E')

ble_control_temp = false;

ble_recibido = 'E';

Interrupción por Timer

Para el desarrollo del programa, se han utilizado dos timers, uno que activa la

interrupción cada cinco minutos, y otro que la activa cada 40 segundos, utilizado para

depurar la aplicación y demostrar su funcionamiento

void setTemporizadorInterrupt()

timer = timerBegin(0, 80, true);

timerAttachInterrupt(timer, &onTimer, true); //vincula el timer a la

handling function

//timerAlarmWrite(timer, 300000000, true); //registro la temperatura

cada 5 MINUTOS

timerAlarmWrite(timer, 40000000, true); //40seg

timerAlarmEnable(timer);

temporizador = false; //para que no entre más en la función

Leer sensor de movimiento

Función que dictamina si el sensor PIR ha sido activado. En caso positivo,

compara el tiempo actual “currentMillis” con e pasado “previousMillis”, de forma que

hasta que la diferencia entre ambos no sea mayor que el intervalo marcado en la

declaración de variables, no se apague. Se trata de un método similar a delay(), con

la ventaja de que no mantiene el programa pausado.

void leerPIR()

int PIR = digitalRead(sensorPIR);

unsigned long currentMillis = millis(); // tiempo actual

unsigned long resta = currentMillis - previousMillis;

if(PIR == 1)

digitalWrite(REDLED4,HIGH);

else if (PIR == 0 && resta >= interval)

digitalWrite(REDLED4,LOW);

//flag_PIR = false;



Get talkback request

Para todas las peticiones de tipo get a thingspeak se utilizará esta función.

void getTalkback_Request(String api_key, String talkback_id, String

command)

client.print("GET https://api.thingspeak.com/talkbacks/");

client.print(talkback_id);

client.print("/commands/");

client.print(command);

client.print(".json?api_key=");

client.print(api_key);

client.println(" HTTP/1.0");

client.println("Host: api.thingspeak.com");

client.println("Connection: close");

client.println();

A continuación, se exponen todas las funciones que usan los get Requests.

Todas siguen el mismo patrón. Primero conecta el cliente al servidor. Se asegura de

que el cliente ha sido conectado. Realiza el talkback request llamando a la función

previamente mostrada, y lee toda la información en formato JSON para después

analizarla y tomar los valores requeridos.

Boton Led

Se trata del led asociado a la comunicación WiFi. Devuelvo ON u OFF en función

del estado seleccionado.

void botonLED()

char c;

String json = "";

client = server.available();

if (!client.connect(host, 80))

return;

else

getTalkback_Request(onoff_talkback_apikey, onoff_talkback_id,

onoff_talkback_command);

while (client.connected())

String line = client.readStringUntil('\n');

if (line == "\r")

break; //header recibido

while (client.available())

c = client.read();

json += c;

DynamicJsonBuffer jsonBuffer(1024);

JsonObject& root = jsonBuffer.parseObject(json);



if (root["command_string"] == "ON")

digitalWrite(REDLED, HIGH);

Serial.println("Abrir");

if (root["command_string"] == "OFF")

digitalWrite(REDLED, LOW);

Serial.println("Cerrar");

client.stop();

Control de temperatura

Función que establece el lazo de control de la temperatura, tanto para el WiFi como

para el BLE. Recibe como parámetros de entrada si el lazo de control está activo o

desactivo, si se desea encender la calefacción o el aire,así como las temperaturas de

salida y referencia.

void control_temperatura(int tipo_control,bool onoff, int temp_salida, int

temp_ref)

if(onoff ==false)

digitalWrite(WHITELED,LOW);

digitalWrite(WHITELED2,LOW);

return;

else if(onoff == true)

if(tipo_control ==1)


if(temp_salida > temp_ref)

digitalWrite(WHITELED,HIGH);

//Serial.println("ENCIENDE AIRE ACONDICIONADO");

else if(temp_salida <= temp_ref)


//Serial.println("APAGA AIRE ACONDICIONADO");

if(tipo_control ==2)


if(temp_salida < temp_ref)

digitalWrite(WHITELED2,HIGH);

//Serial.println("ENCIENDE CALEFACCIÓN");

else if(temp_salida >= temp_ref)


//Serial.println("APAGA CALEFACCIÓN");



Control de las luces

Función básica que, en función de los parámetros de entrada encenderá o

apagará el led 1, el led 2, o los dos al mismo tiempo.

void controlIluminacion(bool luz1,bool luz2)

if(luz1==true) //enciende LED1

digitalWrite(REDLED2, HIGH);

else if(luz1==false)//apaga LED1

digitalWrite(REDLED2, LOW);

if(luz2==true)//enciende LED2


else if(luz2==false)//apaga LED2


if(luz1==true && luz2 == true)//enciende LEDS 1 y 2



else if(luz1==false && luz2 == false)//apaga LEDS 1 y 2



Estado de bombillas

Se trata de la función que realiza la realimentación del lazo de control en modo activo-

pasivo explicado anteriormente. Cada vez que entre, dará a la variable bombillas un

valor u otro en función de las luces que se encuentren en ese momento encendidas.

Para optimizar el programa, se usará la variable ant_bombillas de modo que si

ant_bombillas es igual a bombillas, no se mande información con respecto a dicha

variable al móvil.

void estado_bombillas()

ant_bombillas = bombillas;

if ((digitalRead(REDLED2) == HIGH) && (digitalRead(REDLED3) == HIGH))

//AC

bombillas = 1;

else if ((digitalRead(REDLED2) == HIGH) && (digitalRead(REDLED3) ==

LOW))

//AD

bombillas = 2;

else if((digitalRead(REDLED2) == LOW) && (digitalRead(REDLED3) ==

LOW))

//BD

bombillas = 3;

else if ((digitalRead(REDLED2) == LOW) && (digitalRead(REDLED3) ==

HIGH))

//BC

bombillas = 4;



Estado control aire

Análogo a estado bombillas

void estado_controlAire() //va

ant_aire = aire;

if(digitalRead(GREENLED)==HIGH)

aire = 1;

if(digitalRead(WHITELED) ==HIGH)

aire = 2;

else if(digitalRead(WHITELED2) ==HIGH)

aire =3;

else if(digitalRead(GREENLED)==LOW)

aire = 4;

10.1.6. Funciones asociadas al WiFi

A continuación se exponen las funciones asociadas a la emisión y recepción de

datos a través de WiFi

Temperatura WiFi:

Devuelve la temperature de referencia con la que se pretende climatizar la

estancia

int wifi_temperatura()

int temperatura = -200;

char c;

String json = "";


if (!client.connect(host, httpPort))

Serial.println("connection failed");

return -200;

else

getTalkback_Request(controlremp_apikey, controltemp_id,

controltemp_command);



if (line == "\r")



c = client.read();

json += c;

//Serial.println(json);



DynamicJsonBuffer jsonBuffer(3 * 1024);


temperatura = root["command_string"];

client.stop();

return temperatura;

Modo de control de temperatura:

Establece si se ha activado la calefacción (2), o el aire acondicionado (1)

void modo_control_temp()

char c;

String json = "";



return;

else

getTalkback_Request(modotemp_apikey, modotemp_id, modotemp_command);



if (line == "\r")



c = client.read();

json += c;



if (root["command_string"] == "1")

wifi_modo_control = 1;


wifi_modo_control = 2;

client.stop();

Subir datos de temperatura y humedad a Thingspeak:

void tempYHum_TP(String apikey)

int h = dht.readHumidity();

// Read temperature as Celsius (the default)

t = dht.readTemperature();

if(t<100) // asegura que no suba al servidor un valor inverosímil

ThingSpeak.begin(client);

ThingSpeak.setField(1, String(t));

ThingSpeak.setField(2, String(h));

ThingSpeak.writeFields(441717, "HEXF5DP0NJZFYGIT");

client.stop();



Control de temperatura WiFi ON/OFF:

Función que devuelve un 1 si se ha activado el control de temperature y un 0 si

se encuentra incactivo.

bool wifi_control_temp_onoff()

char c;

String json = "";



Serial.println("Problema conexión cliente en

wifi_control_temp_onoff().");

else

getTalkback_Request(modotemp_apikey, modotemp_id,

modoaireonoff_command);



if (line == "\r")



c = client.read();

json += c;




wifi_control_temp = false;


wifi_control_temp = true;

client.stop();

Modo seguridad:

Devolverá true en caso de haber activado el modo seguridad o false en caso de

no hacerlo.

bool modo_seguridad()

char c;

String json = "";



return false;

else

getTalkback_Request(seguridad_apikey, seguridad_id, seguridad_command);





if (line == "\r")



c = client.read();

json += c;



if (root["command_string"] == "FUERA") //MODO SEGURIDAD ON

inout = true;

Serial.println("FUERA");

if (root["command_string"] == "DENTRO") //MODO SEGURIDAD OFF

inout = false;

Serial.println("DENTRO");

client.stop();

return inout;

Serial.print("Valor de inout: ");

Serial.println(inout);

Comunica a la APP:

Una vez activado el modo de seguridad y entrado el ESP32 en sueño profundo,

esta función se encargará de subir a Thingspeak la causa por la que el

microcontrolador fue despertado.

Una vez despertado, se habrán de subir dos datos al servidor de forma

seguida:

Un int que refleje la causa del wakeup

Un 0, puesto que de no mandar un cero tras el otro número, el móvil

recibiría múltiples avisos, pudiendo provocar el colapso de la aplicación

void comunicaAPP(int tipo) //dependiendo del tipo le comunicaré a la app

una cosa u otra

if(detecta_pir == 1)

String apikey = "95JIJ7OR0E7Z5AN7";

Serial.print(" tipo recibido ");

Serial.println(tipo);

detecta_pir = 0;


ThingSpeak.setField(1, tipo);

ThingSpeak.writeFields(522660, "95JIJ7OR0E7Z5AN7");



Este delay se debe a que Thingspeak no es capaz de recibir dos datos a un canal

en menos de 16 segundos.

delay(16000);


ThingSpeak.setField(1, 0);

ThingSpeak.writeFields(522660, "95JIJ7OR0E7Z5AN7");

client.stop();

10.1.7. Set Up

El programa recorrerá la función setup() una sola vez, al arrancar el programa.

Se usa para inicializar variables, interrupciones, y para establecer el motivo causante

de

void setup()

Serial.begin(115200);

Set up del BLE:

// CreA el dispositivo BLE

BLEDevice::init("ESP32 BLE");

// Crea el servidor BLE

BLEServer *pServer = BLEDevice::createServer();

pServer->setCallbacks(new MyServerCallbacks());

// Crea el servicio BLE

BLEService *pService = pServer->createService(SERVICE_UUID);

// Creala característica BLE

pCharacteristic = pService->createCharacteristic(

CHARACTERISTIC_UUID_TX,

BLECharacteristic::PROPERTY_NOTIFY

);

pCharacteristic->addDescriptor(new BLE2902());

BLECharacteristic *pCharacteristic = pService->createCharacteristic(

CHARACTERISTIC_UUID_RX,

BLECharacteristic::PROPERTY_WRITE

);

pCharacteristic->setCallbacks(new MyCallbacks());

// Comienza el servicio

pService->start();

// Comienza “anunciando”

pServer->getAdvertising()->start();

Inicio la conexión Wifi:



WiFiconnect();

Set up de LEDS y Sensores:

pinMode(REDLED4, OUTPUT);

pinMode(REDLED, OUTPUT);



pinMode(WHITELED, OUTPUT);

pinMode(WHITELED2, OUTPUT);

pinMode(sensorPIR,INPUT);

pinMode(SENSORMQ2,INPUT);

pinMode(PULSADOR,INPUT);

flag_sTemp = true; //Asegura que se conecta a WiFi en el primer loop

ble_recibido = ' ';

inout = false;

estado_bombillas(); //leo el estado de las bombillas y lo mando, porque

si se reinicia la placa, las luces seguirán en el estado en el que se

quedaron, pues

//aunque el microcontrolador ha sido reiniciado, el relé sigue en la

misma posición. Sin relé se pondrán las dos en LOW

flag_bombillas = true;

10.1.8. Interrupción por timer de WiFi

timer = timerBegin(0, 80, true);

timerAttachInterrupt(timer, &onTimer, true); //vincula el timer a la

handling function

//timerAlarmWrite(timer, 300000000, true); //registro la temperatura cada

5 MINUTOS

timerAlarmWrite(timer, 20000000, true);

timerAlarmEnable(timer);

Set up sensor TSL2561:

tsl.begin();

if(!tsl.begin())

Serial.print("Ooops, no TSL2561 detected ... Check your wiring or I2C

ADDR!");

while(1);

tsl.enableAutoRange(true); /* Auto-gain ... switches

automatically between 1x and 16x */

tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS); /* fast but

low resolution */



Set up del sleep mode:

Sirve para dar información de qué ha provocado el set up y actuar en

consecuencia así como para definir los wakeup modes.

++bootCount;

Serial.println("Boot number: " + String(bootCount));

//Print the wakeup reason for ESP32

print_wakeup_reason();

//Uso de EXT1

Serial.println(esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,

ESP_EXT1_WAKEUP_ANY_HIGH));

//wakeup por timer

esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);

Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP)

+

" Seconds");

uint64_t wakeupBit = esp_sleep_get_ext1_wakeup_status(); //si el wakeup

sedebe al PIR

if (wakeupBit & GPIO_SEL_32)

Serial.println("MOVIMIENTO DETECTADO!");

comunicaAPP(1);

//detecta_pir = 1;

temporizador = false;

else if (wakeupBit & GPIO_SEL_34)

Serial.println("Salir del modo seguridad");

temporizador = true;

comunicaAPP(2); //Mando a la app del móvil un 2 para que quite el modo

seguridad

else if (wakeupBit & GPIO_SEL_33)

Serial.println("Detectado humo");


comunicaAPP(3); //Mando a la app del móvil un 2 para que quite el modo

seguridad

Set up de realimentación de estado de variables

estado_bombillas(); //leo el estado de las bombillas y lo mando, porque si

se reinicia la placa, las luces seguirán en el estado en el que se

quedaron, pues

//aunque el microcontrolador ha sido reiniciado, el relé sigue en la

misma posición. Sin relé se pondrán las dos en LOW

estado_controlAire();

flag_reset =true;

10.1.9. Loop

leerPIR();

ant_valor_potenciometro = valor_potenciometro;

if(flag_potenciometro==true)

valor_potenciometro = (int)((analogRead(POTENCIOMETRO)/113));

flag_potenciometro = false;



Habrá que regular el campo de medida del potenciómetro, de forma que los

valores obtenidos sean semejantes a los valores de temperatura.

Una vez se establezca conexión BLE entre el cliente y el servidor:

if (deviceConnected) //cuando me conecte al BLE

// ble_tx_string(bombillas,aire,cinfraTemp,valor_potenciometro);

if(ant_aire != aire || bombillas != ant_bombillas ||flag_reset == true)

ble_tx_string(bombillas,aire);

flag_reset = false;

if(valor_potenciometro != ant_valor_potenciometro)

ble_tx_int(valor_potenciometro);

delay(500); // para quela comunicación esp32/app no se sature

ble_rx();

controlIluminacion(led1,led2);

estado_bombillas(); control_temperatura(ble_modo_control,ble_contr

ol_temp,valor_potenciometro,cinfraTemp);

estado_controlAire();

temp_ble =""; //temp ble vuelve a estar vacío.

else if(!deviceConnected)

Con éste else if el programa asegura que no habrá interrupción alguna mientras

que exista comunicación entre el servidor y el cliente

if (flag_sTemp == true) // en la primera iteración del loop, siempre

está a true, siempre comprueba entonces si está activado o no el modo

seguridad

WiFiconnect();

tempYHum_TP(TempHumChannelApiKey);

botonLED();

control_temp = wifi_temperatura();

modo_control_temp();

wifi_control_temp_onoff();

control_temperatura(wifi_modo_control,wifi_control_temp

,txValue,control_temp);

flag_seguridad = modo_seguridad();

if(flag_seguridad == false && flag_seguridad != ant_flag_seguridad)


ant_flag_seguridad = flag_seguridad;

Una vez se ha accedido a todas las funciones de monitorización, se vuelve a

desactivar el WiFi para favorecer el ahorro de energía

WiFi.disconnect();

server.end();

flag_sTemp = false;



if (flag_seguridad ==true) //Está fuera de if (flag_sTemp == true)

porque una vez ponga el modo de seguridad no dependo de la interrupción por

timer de flag_sTemp

Serial.println("Going to sleep now");

Se ha de desactivar el Bluetooth por completo antes de que el controlador “se vaya a dormir” para asegurar su correcta desactivación. esp_bluedroid_disable();

esp_bluedroid_deinit();

btStop();

esp_deep_sleep_start();

else if(flag_seguridad == false && temporizador == true)

//temporizador=true;

setTemporizadorInterrupt();



10.2. Programación de bloques Thunkable

Bloques comunes

Cuando se inicializa la pantalla, se pone el modo BLE invisible, además de

desactivar los botones del sistema de control (a la espera de ser activados) y se llame

a lamemoria Tiny_DB1 para marcar o desmarcar la casilla de seguridad, dependiendo

de su estado la última vez que se usó la aplicación.

Ilustración 9.1. Thunkable diagrama de bloques 1

Cada vez que se cumple el intervalo designado, en función del modo asignado,

o bien la aplicación buscará información con el servicio BLE establecido, o se leerá el

canal thingspeak para actualizar los valores de temperatura y humedad almacenados

en el canal.




En función del modo de control seleccionado, se activarán unos parámetros y se

desactivarán otros, para así formar la pantalla de dicho modo.




Botones comunes a los dos modos. Cada uno de los modos establece un protocolo de emisión

de datos diferente.






Variables globales de la aplicación




Bloques exclusivos del modo BLE:

Una vez recibo datos del servidor (ESP32) en función de lo recibido distingo de

si se trata del valor de la temperatura de salida (su rango oscila entre 18 y 30 grados)

o valores numéricos entre 1 y 4, que representan el estado de los dos switches de

temperatura. De esta forma se realiza la realimentación entre el ESP32 y la app.




Bloque que mandan a la placa el estado de los interruptores deseado.


Bloque que da respuesta al posible fallo de conexión mediante BLE entre

servidor y cliente.




Bloques de configuración de la conexión BLE. Desde la conexión automática en

caso de encontrar el servidor, hasta la respuesta del programa cuando se haya

conectado al servidor o cuando se desconecte de él.




Bloques de la pantalla de seguridad:

Se trata de la pantalla por defecto, una vez arrancada la app.

Bloque de seguridad. Cuando recibe los avisos provocados por el evento

“wakeup” del ESP32, la aplicación mandará un mensaje de alarma al propio usuario,

independientemente de si la app está abierta o no.




Envía un PUT Request que indicará al ESP32 si el modo seguridad ha sido o no

activado.




Bloques que mandan PUT Request y que analizan el archivo JSON que contiene

la temperatura y humedad del canal de Thingspeak.




10.3. ESP32 DATASHEET

Overview

ESP32-WROOM-32 (ESP-WROOM-32) is a powerful, generic Wi-Fi+BT+BLE

MCU module that targets a wide variety of applications, ranging from low-power sensor

networks to the most demanding tasks, such as voice encoding, music streaming and

MP3 decoding.

At the core of this module is the ESP32-D0WDQ6 chip*. The chip embedded is

designed to be scalable and adaptive. There are two CPU cores that can be individually

controlled, and the clock frequency is adjustable from 80 MHz to 240 MHz. The user

may also power off the CPU and make use of the low-power co-processor to constantly

monitor the peripherals for changes or crossing of thresholds. ESP32 integrates a rich

set of peripherals, ranging from capacitive touch sensors, Hall sensors, SD card

interface, Ethernet, high-speed SPI, UART, I2S and I2C.

The integration of Bluetooth, Bluetooth LE and Wi-Fi ensures that a wide range

of applications can be targeted, and that the module is future proof: using Wi-Fi allows

a large physical range and direct connection to the internet through a Wi-Fi router,

while using Bluetooth allows the user to conveniently connect to the phone or

broadcast low energy beacons for its detection. The sleep current of the ESP32 chip

is less than 5 µA, making it suitable for battery powered and wearable electronics

applications. ESP32 supports a data rate of up to 150 Mbps, and 20.5 dBm output

power at the antenna to ensure the widest physical range. As such the chip does offer

industry-leading specifications and the best performance for electronic integration,

range, power consumption, and connectivity.

The operating system chosen for ESP32 is freeRTOS with LwIP; TLS 1.2 with

hardware acceleration is built in as well. Secure (encrypted) over the air (OTA) upgrade

is also supported, so that developers can continually upgrade their products even after

their release.

Table 1 provides the specifications of ESP32-WROOM-32 (ESP-WROOM-32).

Categories Items Specifications



Categories Items Specifications

Hardware

Module interface

SD card, UART, SPI, SDIO, I2C, LED PWM, Motor

PWM, I2S, IR

GPIO, capacitive touch sensor, ADC, DAC

On-chip sensor Hall sensor, temperature sensor

On-board clock 40 MHz crystal

Operating voltage/Power supply 2.7 ~ 3.6V

Operating current Average: 80 mA

Minimum current delivered by

power supply 500 mA

Operating temperature range -40°C ~ +85°C

Ambient temperature range Normal temperature

Package size 18±0.2 mm x 25.5±0.2 mm x 3.1±0.15 mm

Software

Wi-Fi mode Station/SoftAP/SoftAP+Station/P2P

Wi-Fi Security WPA/WPA2/WPA2-Enterprise/WPS

Encryption AES/RSA/ECC/SHA

Firmware upgrade UART Download / OTA (download and write firmware

via network or host)

Software development Supports Cloud Server Development / SDK for cus-

tom firmware development

Network protocols IPv4, IPv6, SSL, TCP/UDP/HTTP/FTP/MQTT

User configuration AT instruction set, cloud server, Android/iOS app

Table 1: ESP32-WROOM-32 (ESP-WROOM-32) Specifications

Certification

RF certification FCC/CE/IC/TELEC/KCC/SRRC/NCC

Wi-Fi certification Wi-Fi Alliance

Bluetooth certification BQB

Green certification RoHS/REACH

Wi-Fi

Protocols

802.11 b/g/n (802.11n up to 150 Mbps)

A-MPDU and A-MSDU aggregation and 0.4 µs guard

interval support

Frequency range 2.4 GHz ~ 2.5 GHz

Bluetooth

Protocols Bluetooth v4.2 BR/EDR and BLE specification

Radio

NZIF receiver with -97 dBm sensitivity

Class-1, class-2 and class-3 transmitter

AFH

Audio CVSD and SBC



3V3

EN

IO26

IO4 GN

D

IO1

3

SD

2

SD

3

CM

D

CL

K

SD

0

SD

1

IO1

5

IO2

1. Pin Definitions

1.1 Pin Layout

1 38

2 37

3 36

4 35

5 34

6 33

7 32

8 31

9 30

10 29

11 28

12 27

13 26

14 25

Figure 1: ESP32-WROOM-32 (ESP-WROOM-32) Pin layout

1.2 Pin Description

ESP32-WROOM-32 (ESP-WROOM-32) has 38 pins. See pin definitions in Table

2.

Name No. Type Function

GND 1 P Ground

3V3 2 P Power supply.

EN 3 I Chip-enable signal. Active high.

SENSOR_VP 4 I GPIO36, SENSOR_VP, ADC_H, ADC1_CH0, RTC_GPIO0

SENSOR_VN 5 I GPIO39, SENSOR_VN, ADC1_CH3, ADC_H, RTC_GPIO3

IO34 6 I GPIO34, ADC1_CH6, RTC_GPIO4

IO35 7 I GPIO35, ADC1_CH7, RTC_GPIO5

IO32 8 I/O GPIO32, XTAL_32K_P (32.768 kHz crystal oscillator input), ADC1_CH4,

TOUCH9, RTC_GPIO9

IO33 9 I/O GPIO33, XTAL_32K_N (32.768 kHz crystal oscillator output), ADC1_CH5,

TOUCH8, RTC_GPIO8

IO25 10 I/O GPIO25, DAC_1, ADC2_CH8, RTC_GPIO6, EMAC_RXD0

15

16

17

18

19

20

21

22

23

24



IO26 11 I/O GPIO26, DAC_2, ADC2_CH9, RTC_GPIO7, EMAC_RXD1

IO27 12 I/O GPIO27, ADC2_CH7, TOUCH7, RTC_GPIO17, EMAC_RX_DV

Name No. Type Function

IO14 13 I/O GPIO14, ADC2_CH6, TOUCH6, RTC_GPIO16, MTMS, HSPICLK,

HS2_CLK, SD_CLK, EMAC_TXD2

IO12 14 I/O GPIO12, ADC2_CH5, TOUCH5, RTC_GPIO15, MTDI, HSPIQ,

HS2_DATA2, SD_DATA2, EMAC_TXD3

GND 15 P Ground

IO13 16 I/O GPIO13, ADC2_CH4, TOUCH4, RTC_GPIO14, MTCK, HSPID,

HS2_DATA3, SD_DATA3, EMAC_RX_ER

SHD/SD2* 17 I/O GPIO9, SD_DATA2, SPIHD, HS1_DATA2, U1RXD

SWP/SD3* 18 I/O GPIO10, SD_DATA3, SPIWP, HS1_DATA3, U1TXD

SCS/CMD* 19 I/O GPIO11, SD_CMD, SPICS0, HS1_CMD, U1RTS

SCK/CLK* 20 I/O GPIO6, SD_CLK, SPICLK, HS1_CLK, U1CTS

SDO/SD0* 21 I/O GPIO7, SD_DATA0, SPIQ, HS1_DATA0, U2RTS

SDI/SD1* 22 I/O GPIO8, SD_DATA1, SPID, HS1_DATA1, U2CTS

IO15 23 I/O GPIO15, ADC2_CH3, TOUCH3, MTDO, HSPICS0, RTC_GPIO13,

HS2_CMD, SD_CMD, EMAC_RXD3

IO2 24 I/O GPIO2, ADC2_CH2, TOUCH2, RTC_GPIO12, HSPIWP, HS2_DATA0,

SD_DATA0

IO0 25 I/O GPIO0, ADC2_CH1, TOUCH1, RTC_GPIO11, CLK_OUT1,

EMAC_TX_CLK

IO4 26 I/O GPIO4, ADC2_CH0, TOUCH0, RTC_GPIO10, HSPIHD, HS2_DATA1,

SD_DATA1, EMAC_TX_ER

IO16 27 I/O GPIO16, HS1_DATA4, U2RXD, EMAC_CLK_OUT

IO17 28 I/O GPIO17, HS1_DATA5, U2TXD, EMAC_CLK_OUT_180

IO5 29 I/O GPIO5, VSPICS0, HS1_DATA6, EMAC_RX_CLK

IO18 30 I/O GPIO18, VSPICLK, HS1_DATA7

IO19 31 I/O GPIO19, VSPIQ, U0CTS, EMAC_TXD0

NC 32 - -

IO21 33 I/O GPIO21, VSPIHD, EMAC_TX_EN

RXD0 34 I/O GPIO3, U0RXD, CLK_OUT2

TXD0 35 I/O GPIO1, U0TXD, CLK_OUT3, EMAC_RXD2

IO22 36 I/O GPIO22, VSPIWP, U0RTS, EMAC_TXD1

IO23 37 I/O GPIO23, VSPID, HS1_STROBE

GND 38 P Ground

1.3 Strapping Pins

ESP32 has five strapping pins, which can be seen in Chapter 6 Schematics:



MTDI

GPIO0

GPIO2

MTDO

GPIO5

Software can read the value of these five bits from the register

”GPIO_STRAPPING”.

During the chip’s system reset (power-on reset, RTC watchdog reset and

brownout reset), the latches of the strapping pins sample the voltage level as strapping

bits of ”0” or ”1”, and hold these bits until the chip is powered down or shut down. The

strapping bits configure the device boot mode, the operating voltage of VDD_SDIO

and other system initial settings.

Each strapping pin is connected with its internal pull-up/pull-down during the chip

reset. Consequently, if a strapping pin is unconnected or the connected external

circuit is high-impendence, the internal weak pull-up/pull-down will determine the

default input level of the strapping pins.

To change the strapping bit values, users can apply the external pull-down/pull-

up resistances, or apply the host MCU’s GPIOs to control the voltage level of these

pins when powering on ESP32.

After reset, the strapping pins work as the normal functions pins.

Refer to Table 3 for detailed boot modes’ configuration by strapping pins.

Table 3: Strapping Pins

Voltage of Internal LDO

(VDD_SDIO)

Pin Default 3.3V 1.8V

MTDI Pull-down 0 1

Booting Mode

Pin Default SPI Boot Download Boot

GPIO0 Pull-up 1 0

GPIO2 Pull-down Don’t-care 0

Debugging Log Printed on U0TXD During Booting?



Pin Default U0TXD Toggling U0TXD

Silent

MTDO Pull-up 1 0

Timing of SDIO Slave

Pin Default Falling-edge

Inp

ut

Falling-edge

Output

Falling-edge

Inp

ut

Rising-edge Output

Rising-edge

Inp

ut

Falling-edge

Output

Rising-edge

Inpu

t

Rising-edge Output

MTDO Pull-up 0 0 1 1

GPIO5 Pull-up 0 1 0 1

2. Functional Description

This chapter describes the modules and functions integrated in ESP32-WROOM-

32 (ESP-WROOM-32).

2.1 CPU and Internal Memory

ESP32-D0WDQ6 contains two low-power Xtensa® 32-bit LX6 microprocessors. The

internal memory includes:

448 kB of ROM for booting and core functions.

520 kB (8 kB RTC FAST Memory included) of on-chip SRAM for data and

instruction.

8 kB of SRAM in RTC, which is called RTC FAST Memory and can be used for

data storage; it is accessed by the main CPU during RTC Boot from the Deep-

sleep mode.

8 kB of SRAM in RTC, which is called RTC SLOW Memory and can be accessed by

the co-processor during the Deep-sleep mode.

1 kbit of eFuse, of which 320 bits are used for the system (MAC address and chip

configuration) and the remaining 704 bits are reserved for customer applications,

including Flash-Encryption and Chip-ID.

2.2 External Flash and SRAM

ESP32 supports up to four 16-MB of external QSPI flash and SRAM with

hardware encryption based on AES to protect developers’ programs and data.



ESP32 can access the external QSPI flash and SRAM through high-speed

caches.

Up to 16 MB of external flash are memory-mapped onto the CPU code

space, supporting 8, 16 and 32-bit access. Code execution is supported.

Up to 8 MB of external flash/SRAM are memory-mapped onto the CPU

data space, supporting 8, 16 and 32-bit access. Data-read is supported on

the flash and SRAM. Data-write is supported on the SRAM.

ESP32-WROOM-32 (ESP-WROOM-32) integrates 4 MB of external SPI flash.

The 4-MB SPI flash can be memory- mapped onto the CPU code space, supporting 8,

16 and 32-bit access. Code execution is supported. The integrated SPI flash is

connected to GPIO6, GPIO7, GPIO8, GPIO9, GPIO10 and GPIO11. These six pins

cannot be used as regular GPIO.

2.3 Crystal Oscillators

The ESP32 Wi-Fi/BT firmware can only support 40 MHz crystal oscillator for now

2.4 RTC and Low-Power Management

With the use of advanced power management technologies, ESP32 can

switch between different power modes.

Power modes

Active mode: The chip radio is powered on. The chip can receive, transmit,

or listen.

Modem-sleep mode: The CPU is operational and the clock is configurable.

The Wi-Fi/Bluetooth base- band and radio are disabled.

Light-sleep mode: The CPU is paused. The RTC memory and RTC

peripherals, as well as the ULP co-processor are running. Any wake-up

events (MAC, host, RTC timer, or external interrupts) will wake up the chip.

Deep-sleep mode: Only the RTC memory and RTC peripherals are

powered on. Wi-Fi and Bluetooth connection data are stored in the RTC

memory. The ULP co-processor can work.



Hibernation mode: The internal 8-MHz oscillator and ULP co-processor

are disabled. The RTC recovery memory is powered down. Only one RTC

timer on the slow clock and some RTC GPIOs are active. The RTC timer

or the RTC GPIOs can wake up the chip from the Hibernation mode.

The power consumption varies with different power modes/sleep patterns and

work statuses of functional modules. Please see Table 4 for details.

Table 4: Power Consumption by Power Modes

Power mode Description Power consumption

Active (RF

working)

Wi-Fi TX packet 14 dBm ~ 19.5 dBm Please refer to ESP32 Datasheet. Wi-Fi / BT TX packet 0 dBm

Wi-Fi / BT RX and listening

Association sleep pattern (by Light-sleep) 1 mA ~ 4 mA @DTIM3

Modem-sleep

The CPU is powered on.

Max speed 240 MHz: 30 mA ~ 50

mA

Normal speed 80 MHz: 20 mA ~ 25

mA

Slow speed 2 MHz: 2 mA ~ 4 mA

Light-sleep - 0.8 mA

Deep-sleep

The ULP co-processor is powered on. 150 µA

ULP sensor-monitored pattern 100 µA @1% duty

RTC timer + RTC memory 10 µA

Hibernation RTC timer only 5 µA

Power off CHIP_PU is set to low level, the chip is powered

off

0.1 µA

3. Electrical Characteristics

3.1 Absolute Maximum Ratings

Table 5: Absolute Maximum Ratings Parameter Symbol Min Typ Max Unit

Note:

The specifications in this chapter have been tested under the following general condition: VDD = 3.3V, TA = 27°C, unless otherwise

specified.

http://espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf



Power supply VDD 2.7 3.3 3.6 V

Minimum current delivered by

power supply IV DD 0.5 - - A

Input low voltage VIL -0.3 - 0.25×VIO1

V

Input high voltage VIH 0.75×VIO1

- VIO1+0.3 V

Input leakage current IIL - - 50 nA

Input pin capacitance Cpad - - 2 pF

Output low voltage VOL - - 0.1×VIO1

V

Output high voltage VOH 0.8×VIO1

- - V

Maximum output drive capability IM AX - - 40 mA

Storage temperature range TST R -40 - 85 °C

Operating temperature range TOP R -40 - 85 °C

3.2 Wi-Fi Radio

Table 6: Wi-Fi Radio Characteristics

Description Min Typical Max Unit

Input frequency 2412 - 2484 MHz

Input reflection - - -10 dB

Tx power

Output power of PA for 72.2 Mbps 13 14 15 dBm

Output power of PA for 11b mode 19.5 20 20.5 dBm

Sensitivity

DSSS, 1 Mbps - -98 - dBm

CCK, 11 Mbps - -91 - dBm

OFDM, 6 Mbps - -93 - dBm

OFDM, 54 Mbps - -75 - dBm

HT20, MCS0 - -93 - dBm

HT20, MCS7 - -73 - dBm

Description Min Typical Max Unit

HT40, MCS0 - -90 - dBm

HT40, MCS7 - -70 - dBm

MCS32 - -89 - dBm

Adjacent channel rejection

OFDM, 6 Mbps - 37 - dB

OFDM, 54 Mbps - 21 - dB

HT20, MCS0 - 37 - dB



HT20, MCS7 - 20 - dB

3.3 BLE Radio

5.3.1 Receiver

Table 7: Receiver Characteristics — BLE

Parameter Conditions Min Typ Max Unit

Sensitivity @30.8% PER - - -97 - dBm

Maximum received signal @30.8% PER - 0 - - dBm

Co-channel C/I - - +10 - dB

Adjacent channel selectivity C/I

F = F0 + 1 MHz - -5 - dB

F = F0 - 1 MHz - -5 - dB

F = F0 + 2 MHz - -25 - dB

F = F0 - 2 MHz - -35 - dB

F = F0 + 3 MHz - -25 - dB

F = F0 - 3 MHz - -45 - dB

Out-of-band blocking performance

30 MHz ~ 2000 MHz -10 - - dBm

2000 MHz ~ 2400 MHz -27 - - dBm

2500 MHz ~ 3000 MHz -27 - - dBm

3000 MHz ~ 12.5 GHz -10 - - dBm

Intermodulation - -36 - - dBm

5.3.2 Transmitter

Table 8: Transmitter Characteristics — BLE


RF transmit power - - 0 - dBm

Gain control step - - ±3 - dBm

RF power control range - -12 - +12 dBm


Adjacent channel transmit power

F = F0 + 1 MHz - -14.6 - dBm

F = F0 - 1 MHz - -12.7 - dBm

F = F0 + 2 MHz - -44.3 - dBm

F = F0 - 2 MHz - -38.7 - dBm

F = F0 + 3 MHz - -49.2 - dBm

F = F0 - 3 MHz - -44.7 - dBm

F = F0 + > 3 MHz

F = F0 - > 3 MHz

-

-

-50

-50

-

-

dBm

dBm



∆ f 1avg - - - 265 kHz

∆ f 2max - 247 - - kHz

∆ f 2avg/∆ f 1avg - - -0.92 - -

ICFT - - -10 - kHz

Drift rate - - 0.7 - kHz/50 µs

Drift - - 2 - kHz

5.4 Reflow Profile

0 50 100 150 200 250

Preheating zone — Temp.: 150 ~ 200 Time: 60 ~ 120s Ramp-up rate: 0.3 ~ 0.8/s

Time

(sec.)

50

25

100

Cooling zone

Reflow zone

Preheating zone

217

200

250

Peak Temp.

Tem

pera

ture

(

)

3V3 EN

SENSOR_VP

IO34

TXD0RXD0

IO5

IO4IO0

39

38

37

36

35

34

33

4. Peripheral Schematics

Figure 4: ESP32-WROOM-32 (ESP-WROOM-32) Peripheral Schematics

Figure 5: Discharge Circuit for VDD33 Rail

Note:

Soldering Pad 39 to the Ground of the base board is not necessary for a satisfactory thermal performance. If users do want to solder it,

they need to ensure that the correct quantity of soldering paste is applied.

GND GND GND

VCC

1

1K(1%)

GND 100K(1%) R2

R1 Bulk CAP

ESP Module

Q1

C1

VDD33 SW1

CAP Added

By User. Discharge Circuit

D1

15

16

17

18

19

20

21

22

23

24

GN

D2

IO13

SD

2

SD

3

CM

D

CL

K

SD

0

SD

1

IO15

IO2

SD

2

SD

3

CM

D

CLK

SD

0

SD

1

IO

2

1

2

3

2

1

MTMS MTDI MTCK MTDO

1 2 3 4



Figure 6: Reset Circuit

Note:

When battery is used as the power supply for ESP32 series of chips and modules, a supply voltage supervisor is recommended to avoid

boot failure due to low voltage. Users are recommended to pull CHIP_PU low if the power supply for ESP32 is below 2.3V.


10.4. HC-SR501 PIR Motion detector

Product Discription

HC-SR501 is based on infrared technology, automatic control module, using Germany imported

LHI778 probe design, high sensitivity, high reliability, ultra-low-voltage operating mode, widely used in

various auto-sensing electrical equipment, especially for battery-powered automatic controlled

products.

Specification:

Voltage: 5V – 20V

Power Consumption: 65mA

TTL output: 3.3V, 0V

Delay time: Adjustable (.3->5min)

Lock time: 0.2 sec

Trigger methods: L – disable repeat trigger, H enable repeat trigger

Sensing range: less than 120 degree, within 7 meters

Temperature: – 15 ~ +70

Dimension: 32*24 mm, distance between screw 28mm, M2, Lens dimension in diameter:

23mm

Application: Automatically sensing light for Floor, bathroom, basement, porch, warehouse,

Garage, etc, ventilator, alarm, etc.

Adjustment:

Adjust the distance potentiometer clockwise rotation, increased sensing distance (about 7

meters), on the contrary, the sensing distance decreases (about 3 meters).

Adjust the delay potentiometer clockwise rotation sensor the delay lengthened (300S), on the

contrary, shorten the induction delay (5S).


1 working voltage range :DC 4.5-20V 2 Quiescent Current :50uA

3 high output level 3.3 V / Low 0V

Trigger L trigger can not be repeated / H repeated trigger

circuit board dimensions :32 * 24 mm

maximum 110 ° angle sensor

maximum sensing distance

maximum 110 ° angle sensor

Product Type HC--SR501 Body Sensor Module

Operating Voltage Range 5-20VDC

Quiescent Current <50uA

Level output High 3.3 V /Low 0V

Trigger L can not be repeated trigger/H can be repeated trigger(Default repeated trigger)

Delay time 5-300S( adjustable) Range (approximately .3Sec -5Min)

Block time 2.5S(default)Can be made a range(0.xx to tens of seconds


Board Dimensions 32mm*24mm

Angle Sensor <110 ° cone angle

Operation Temp. -15-+70 degrees

Lens size sensor Diameter:23mm(Default)

10.4.1. MQ-2 Semiconductor Sensor for Combustible Gas

Sensitive material of MQ-2 gas sensor is SnO2, which with lower conductivity in clean air. When

the target combustible gas exist, The sensor’s conductivity is more higher along with the gas

concentration rising. Please use simple electrocircuit, Convert change of conductivity to correspond

output signal of gas concentration.

MQ-2 gas sensor has high sensitity to LPG, Propane and Hydrogen, also could be used to

Methane and other combustible steam, it is with low cost and suitable for different application.

Technical Data Basic test loop

T

Vc VRL

RL VH

GND

Model No.

MQ-2

Sensor Type Semiconductor

Standard Encapsulation Bakelite (Black Bakelite)

Detection Gas Combustible gas and

smoke

Concentration 300-10000ppm

( Combustible gas)

Circuit

Loop Voltage Vc ≤24V DC

Heater

Voltage

VH 5.0V±0.2V ACorDC

Load

Resistance

RL

Adjustable

Character

Heater

Resistance

RH 31Ω±3Ω（Room Tem.）

Heater

consumption

PH

≤900mW

Sensing

Resistance

Rs 2KΩ-20KΩ(in 2000ppm C3H8 )

Sensitivity

S Rs(in air)/Rs(1000ppm

isobutane)≥5

Slope α ≤0.6(R5000ppm/R3000ppm

CH4)

Condition

Tem. Humidity 20±2；65%±5%RH

Standard test

circuit

Vc:5.0V±0.1V；

VH: 5.0V±0.1V

Preheat time Over 48 hours


Sensitivity Characteristics

Influence of Temperature/Humidity

Fig1

Fig2


10.5. Rain Sensor Module

Pin Configuration

VCC: 5V DC

GND: ground

DO: high/low output

AO: analog output

Specifications

Adopts high quality of RF-04 double sided material.

Area: 5cm x 4cm nickel plate on side

Anti-oxidation, anti-conductivity, with long use time

Comparator output signal clean waveform is good, driving ability, over 15mA

Potentiometer adjust the sensitivity

Working voltage 5V

Output format: Digital switching output (0 and 1) and analog voltage output

AO

With bolt holes for easy installation

Small board PCB size: 3.2cm x 1.4cm

Uses a wide voltage LM393 comparator


10.6. TSL2561 Luminosity Sensor

The TSL2561 luminosity sensor is an advanced digital light sensor, ideal for use in

a wide range of light situations. Compared to low cost CdS cells, this sensor is more

precise, allowing for exact Lux calculations and can be configured for different gain/timing

ranges to detect light ranges from up to 0.1 - 40,000+ Lux on the fly. The best part of this

sensor is that it contains both infrared and full spectrum diodes! That means you can

seperately measure infrared, full-spectrum or human-visible light. Most sensors can only

detect one or the other, which does not accurately represent what human eyes see (since

we cannot perceive the IR light that is detected by most photo diodes).

Approximates Human eye Response

Precisely Measures Illuminance in Diverse Lighting Conditions

Dynamic range (Lux): 0.1 to 40,000 Lux

Voltage range: 2.7-3.6V

Interface: I2C


10.7. DHT 11

Product Overview

DHT11 digital temperature and humidity sensor is a composite Sensor contains a

calibrated digital signal output of the temperature and humidity. Application of a dedicated

digital modules collection technology and the temperature and humidity sensing

technology, to ensure that the product has high reliability and excellent long-term stability.

The sensor includes a resistive sense of wet components and an NTC temperature

measurement devices, and connected with a high-performance 8-bit microcontroller.

2、Applications

HVAC, dehumidifier, testing and inspection equipment, consumer goods,

automotive, automatic control, data loggers, weather stations, home appliances, humidity

regulator, medical and other humidity measurement and control.

3、Features

Low cost, long-term stability, relative humidity and temperature measurement,

excellent quality, fast response, strong anti-interference ability, long distance signal

transmission, digital signal output, and precise calibration.


4、Dimensions (unit: mm)

Relative humidity

Resolution: 16Bit

Repeatability: ±1% RH

Accuracy: At 25 ±5% RH

Interchangeability: fully interchangeable

Response time: 1 / e (63%) of 25 6s

1m / s air 6s

Hysteresis: <± 0.3% RH

Long-term stability: <± 0.5% RH / yr in

Temperature

Resolution: 16Bit

Repeatability: ±0.2

Range: At 25 ±2

Response time: 1 / e (63%) 10S

Electrical Characteristics

Power supply: DC 3.5～5.5V

Supply Current: measurement 0.3mA standby 60μ A

Sampling period: more than 2 seconds


Pin Description

1, the VDD power supply 3.5～5.5V DC

2 DATA serial data, a single bus

3, NC, empty pin

4, GND ground, the negative power

Bibliografía A. Z. Alkar and U. Buhur. (2017). An Internet Based Wireless Home Automation System for

Multifunctional Devices

A. Maier, A. Sharp, Y. Vagapov (2009). Comparative Analysis and Practical Implementation

of the ESP32 Microcontroller Module for the Internet of Things

N. Kolban, Kolban’s Book on ESP32, USA: Leanpub, 2017.

C. Gomez, J. Paradells (2010). Wireless Home Automation Networks: A Survey of

Architectures and Technologies

A. ElShafee, K. Alaa Hamed (2012). Design and Implementation of a WiFi Based Home

Automation System

Oleh Horyachyy (2017). Comparison of Wireless Communication Technologies used in a

Smart Home: Analysis of wireless sensor node based on Arduino in home automation

scenario

«Librerías ESP32 para Arduino » https://github.com/espressif/arduino-esp32

« BLE + Arduino » https://www.hackster.io/botletics/esp32-ble-android-arduino-ide-awesome-

81c67d

«ESP32 Sleep Modes» http://esp-idf.readthedocs.io/

«Arduino» https://www.arduino.cc/

«ThingSpeak» https://thingspeak.com/

«Thunkable» https://thunkable.com/