Monitorización inteligente del hogar con Alexa

Componentes y suministros

	Arduino UNO	×	1
	Espressif ESP8266 ESP-01	×	1
	Sensor DHT11 de temperatura y humedad (4 pines)	×	1
	ControlEverything.com Controlador de relé de 4 canales para I2C	×	1
	Sensor de obstáculos IR	×	1
	Cámara	×	1
	Cables jumper (genéricos)	×	1

Aplicaciones y servicios en línea

	Arduino IDE
	Amazon Alexa Alexa Skills Kit
	Amazon Alexa echosim.io
	API ThingSpeak
	Backendless
	Pushingbox

Sobre este proyecto

Introducción:

En el mundo actual la gente pasa más tiempo en el trabajo que en sus hogares. Por eso hay necesidad de un sistema de monitorización del hogar donde la gente pueda conocer las condiciones de la casa mientras está en el trabajo. Sería aún mejor si uno pudiera simplemente preguntar a "alguien" sobre su casa durante las horas de trabajo. Esto se puede lograr usando Amazon Alexa como asistente que puede dar al usuario la información necesaria sobre su hogar.

No solo en el lugar de trabajo, los usuarios pueden conocer el estado de la casa en cualquier lugar del mundo mientras tengan conexión a internet y un dispositivo Amazon Alexa.

Las siguientes funciones están implementadas en este proyecto:

1) Controlar dispositivos domésticos como ventilador y luz

2) Indica el estado de los dispositivos

3) Indica las condiciones climáticas de la casa (temperatura y humedad)

4) Envía una instantánea del interior de la casa al usuario vía Gmail cuando se requiera.

5) Envía notificación en caso de:

* Intruso (también envía foto)

* Fuego

* Visita (también envía foto)

Pasos involucrados en el proyecto:

PASO 1: Programar el Arduino y el ESP8266

Descargad el Arduino IDE desde la web oficial: https://www.arduino.cc/en/Main/Software

Abrid Arduino IDE e id a Archivo → Preferencias → en URL adicional del Gestor de tarjetas escribid - https://arduino.esp8266.com/stable/package_esp8266com_index.json

Id a Herramientas → Placas → Gestor de tarjetas → e instalad el paquete esp8266 que está al final.

Para programar el Arduino solo conectad el cable USB del Arduino al ordenador y seleccionad Arduino/Genuino UNO en Herramientas → Placas. Aseguraos también de seleccionar los puertos COM correctos en Herramientas (el número de puerto COM se puede encontrar en el Administrador de dispositivos). Escribid el programa requerido, compiladlo y haced clic en Subir si no hay errores.

Para programar el ESP8266 haced la conexión como se muestra en el diagrama

Conectad el USB del Arduino al ordenador. En Herramientas → Placa → seleccionad Generic ESP8266 y también seleccionad el puerto COM correcto. Escribid el programa requerido, compiladlo y haced clic en Subir si no hay errores. Aseguraos de conectar el pin RST del Arduino a GND (el Arduino actúa como programador del ESP8266).

En este proyecto primero se programa el ESP8266 y luego se retiran las conexiones del circuito. Luego el circuito se reconecta como se muestra en la figura llamada "Conexiones del circuito". Y luego el Arduino es programado

PASO 2: Configurar thingspeak.com

Crear una cuenta en thingspeak.com.

Hacemos uso de canales en ThingSpeak para almacenar la información de control de dispositivos y enrutarla al Arduino/Alexa. También almacenamos los valores de temperatura y humedad en los canales. Es como una ubicación de almacenamiento para la información.

Id a Canales → Mis Canales y cread un nuevo canal. Dad nombre y descripción a vuestros canales.

En nuestro proyecto necesitamos 8 canales (podéis hacer el trabajo con menos canales pero será un poco más complicado al programar). Además ThingSpeak tiene una restricción de tiempo al actualizar un canal. Debe haber un intervalo de 10-15 segundos entre actualizaciones sucesivas de un canal en particular.

Ocho canales con sus valores y significado se dan a continuación:

Nombre del canal (valor1-significado, valor2-significado, etc):

1) Control de dispositivos (0 - luz ON, 1- luz OFF, 2- ventilador ON, 3- Ventilador OFF)

2) Estado de la luz (0- luz apagada, 1- luz encendida)

3) Estado del ventilador (0- ventilador apagado, 1- ventilador encendido)

4) Humedad (valor de humedad)

5) Temperatura (valor de temperatura)

6) Notificación de intruso (1- alerta de intruso)

7) Notificación de fuego (1- alerta de fuego)

8) Notificación de visita (1- alerta de visita)

Al hacer clic en cualquier canal podéis ver su ID de canal y claves API de escritura en la pestaña API Keys. El ID de canal es necesario para obtener la información/valor en el canal. Y la clave de escritura es necesaria para almacenar un valor en el canal.

Petición HTTP para actualizar un canal es:

https://api.thingspeak.com/update?api_key=<clave_escritura>&field1=<valor>

<clave_escritura> se reemplaza por las claves de escritura correspondientes del canal y el valor puede ser (0/1 en caso de control de dispositivos o valores temp/humedad)

Petición HTTP para leer valor de un canal es:

https://api.thingspeak.com/channels/<channel_id>/field/field1/last.html

<channel_id> se reemplaza por el ID de canal particular del canal del que queremos leer.

PASO 3: El Programa

El programa se divide en 3 partes:

A) Programa para Arduino: el programa para Arduino es muy simple. Recibe los datos del ESP8266 por serie y basándose en los datos recibidos controla los dispositivos. Más información sobre el programa se encuentra en los comentarios del propio programa.

B) Programa para ESP8266: el programa para ESP8266 implica 3 cosas:

1) Actualizar la temperatura y humedad usando petición HTTP:

client.print(String("GET ") + "/update?key=<write_key>&field1="+humidity+" HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); //actualizar humedad
client.print(String("GET ") + "/update?key=<write_key>&field1="+temperature+" HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); //actualizar temperatura

El <write_key> se reemplaza por la clave de escritura correspondiente encontrada en el canal de ThingSpeak para humedad y temperatura respectivamente. Y host es api.thingspeak.com.

Descargad la librería dht desde: https://github.com/adafruit/DHT-sensor-library

2) Leer de los canales correspondientes de ThingSpeak y controlar el dispositivo basándose en los valores obtenidos:

client.print(String("GET ") + "/channels/<channel_id>/field/field1/last.html HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");

Donde <channel_id> se reemplaza por el ID de canal correspondiente encontrado en ThingSpeak.

3) Enviar alerta en caso de temperatura alta vía PushingBox:

String host1="api.pushingbox.com";
client.print(String("GET ") + "/pushingbox?devid=<your_dev_id> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n");

Donde <your_dev_id> se reemplaza por vuestro device ID en PushingBox.

PASO 4: Configurar LinkIt Smart 7688 Duo y webcam

En este proyecto se usa webcam y LinkIt Smart 7688 Duo para capturar la foto requerida y enviarla al usuario. También podéis usar el módulo de cámara de Arduino e interconectarlo con Arduino o usar cualquier cámara IP.

Pulsad y mantened el botón WiFi en el LinkIt Smart 7688 durante 20 segundos para resetear la placa. Luego, tras resetear la configuración WiFi, podréis ver su nombre de punto de acceso en las conexiones de red inalámbrica. Ahora conectad el ordenador a esa red.

Después de conectar, abrid el navegador y escribid 192.168.100.1 en la barra de direcciones. Podréis ver su portal.

Estableced una contraseña para acceder a su portal.

Después de entrar, id a la pestaña Red y seleccionad Modo Estación (necesitamos que acceda a internet) y conectadlo a vuestra red WiFi y pulsad Configurar y Reiniciar.

Tras reiniciar la placa, se le asignará una dirección IP local. Averiguad la dirección usando cualquier herramienta IP o el portal de vuestro router. En mi caso era 192.168.1.4.

Ahora escribid la dirección IP local en la barra de direcciones del navegador. Aseguraos de que el ordenador está conectado a la misma red que el LinkIt Smart. Se os pedirá que iniciéis sesión de nuevo.

Para habilitar el streaming desde la webcam debéis habilitar MJPG Streamer (mjpg-streamer es una aplicación de línea de comandos que copia fotogramas JPEG de uno o más plugins de entrada a múltiples plugins de salida). Para hacer esto, en el portal id a la ubicación OpenWrt en la esquina superior derecha. Necesitáis iniciar sesión de nuevo.

Después de iniciar sesión, id a la pestaña Servicios y marcad habilitar MJPG Streamer y asignad un número de puerto para este servicio. He asignado 4440. Haced clic en Guardar y Aplicar.

Tras la configuración, podéis conectar vuestra webcam al puerto host USB del LinkIt Smart 7688 Duo a través de un cable OTG.

Ahora para ver el stream, abrid el navegador y escribid <dirección IP local>:<puerto> en la barra de direcciones. En mi caso es 192.168.1.4:4400

Para tomar la instantánea, escribid el comando <IP local>:<puerto>?action=snapshot

Ahora esta imagen está disponible localmente, pero necesitamos hacerla disponible al servicio PushingBox. Para lograr esto necesitamos hacer redirección de puertos (port forwarding). La redirección de puertos se puede hacer en el portal del router. El proceso es diferente para diferentes routers. Buscad en Google cómo hacer port forwarding para vuestro router específico. Normalmente está disponible bajo el servicio NAT.

Después de hacer el port forwarding, podéis acceder a este puerto (ej. 4440) desde vuestra IP externa. La IP externa se puede encontrar escribiendo "cuál es mi ip" en Google.

Necesitáis poner esta dirección, es decir, https://<IP externa>:<puerto>?action=snapshot en PushingBox (explicado en el siguiente paso) para que PushingBox pueda acceder a esta imagen, adjuntarla al correo y enviárosla cuando sea necesario.

También podéis almacenar la imagen en tarjeta SD ya que LinkIt Smart 7688 Duo también viene con una ranura para tarjeta SD para almacenar información.

Más información sobre esto en: https://docs.labs.mediatek.com/resource/linkit-smart-7688/en/get-started/get-started-with-the-linkit-smart-7688-duo-development-board/

PASO 5: Configurar PushingBox

PushingBox se usa para enviar notificaciones sobre diferentes alertas del proyecto a Gmail.

Iniciad sesión en PushingBox usando cuenta de Google: https://www.pushingbox.com/

Id a Mis Servicios → Añadir servicio. Hay muchos servicios para elegir como Gmail, Twitter, notificaciones push para Android, etc...

Seleccionad Gmail (ya que necesitamos enviar foto como adjunto) y rellenad la configuración de nombre de Gmail apropiada y el ID de Gmail del usuario al que se debe enviar la alerta.

Id a Mis Escenarios y cread un nuevo escenario. Dad nombre al escenario (ej: ALERTA) y añadid el servicio creado anteriormente.

Escribid un asunto y cuerpo de correo adecuados y introducid la URL para tomar la captura de pantalla de la webcam para adjuntar la foto. Crear diferentes escenarios para diferentes alertas.

API para ejecutar un escenario de PushingBox es: https://api.pushingbox.com/pushingbox?devid=<device_id>

PASO 6: Crear Skill de Alexa usando Backendless

Backendless se usa para crear la skill de Alexa. Es una programación simple de arrastrar y soltar usada para crear skill de Alexa (o cualquier programa) que puede ser accedida por la API de Backendless.

Crear una cuenta en Backendless: https://backendless.com/

• Iniciad sesión en vuestra cuenta de Backendless. Haced clic en Crear app y dad un nombre a vuestra app.
• Haced clic en el icono de Lógica de Negocio ubicado en la barra de iconos a la izquierda. Veréis la pantalla SERVICIOS API.
• Haced clic en el icono "+" para crear un nuevo servicio. Aseguraos de seleccionar CODELESS en el popup "Nuevo Servicio". Escribid "AlexaService" para el nombre del servicio. Haced clic en GUARDAR:

• Backendless crea el Servicio API y os pedirá crear un método para el servicio. Este será el método que procesará las peticiones de Alexa. Escribid "handleRequest" para el nombre del método. Aseguraos de seleccionar POST para la operación REST, y declarad un argumento con el nombre "req" y tipo "Any Object" como se muestra abajo:

Backendless crea un placeholder para la lógica codeless del método. Haced clic en EDITAR para empezar a cambiar al Diseñador de Lógica Codeless.

En el bloque de función creado, haced clic en el área que dice "doSomething" y cambiadla a "sendAlexaResponse". Esta función se usa para que Alexa diga algo que se puede pasar como argumento. Haced clic en GUARDAR para que la función se guarde:

Haced clic en el icono de engranaje ubicado en el bloque morado justo al lado de la palabra "Función". Añadid dos argumentos arrastrando los bloques de entrada como se muestra en la imagen de abajo. Asignad los nombres de los argumentos como "whatToSay" y "waitForResponse". Notad que al añadir argumentos, el área de Bloques de Contexto se popula automáticamente con los bloques que representan los valores de los argumentos:

Modificad la lógica de la función para que se vea como en la imagen de abajo. Para los bloques "Crear Objetos", usad el icono de engranaje para cambiar el nombre de las propiedades del objeto. No olvidéis guardar vuestro trabajo haciendo clic en el botón GUARDAR.

Ahora que la función personalizada está construida, volved al método handleRequest del servicio AlexaService. Haced clic en la categoría Funciones Personalizadas en la barra de herramientas a la izquierda y arrastrad el bloque sendAlexaResponse para conectar con el conector de retorno de vuestro método de servicio:

Los pasos anteriores también se pueden encontrar en su web: https://backendless.com/developing-alexa-skill-without-writing-any-code-part1-codeless-in-backendless-mbaas/

https://backendless.com/developing-an-alexa-skill-without-writing-any-code-part2-slots/

Haced clic en el nodo "Añadir Nuevo" bajo Funciones en la sección NAVEGADOR. En el bloque de función creado, haced clic en el área que dice "doSomething" y cambiadla a "getIntentName"

Modificad los bloques para que la función se vea así:

Esto obtendrá el nombre de la intención basado en las frases de ejemplo. Volved a Servicios API → <nombre app> → handle request en la sección NAVEGADOR. Variables y lógica se crean desde la sección Sistema. Crear las siguientes variables:

Luego almacenamos el nombre de la intención en la variable request. Y luego comparamos con las intenciones. Por ejemplo, si la petición es "introducción", entonces la variable respond se establece a "¡Hola! Puedo controlar....." y esta respuesta es leída en voz alta por Alexa al final.

Modificad el bloque como se muestra abajo:

Si la petición es intención LightsOn, entonces actualizamos el canal de ThingSpeak a '0' usando petición HTTP GET y al mismo tiempo actualizamos el estado del dispositivo (1/0 dependiendo de On/Off). Lo mismo se repite para LightsOff, FanOn y FanOff.

Para el clima leemos de los canales de Temperatura y Humedad y almacenamos el resultado en la variable respond. Como el canal solo da valores, añadimos textos para hacer la respuesta significativa:

Para instantánea de la sala de estar ejecutamos escenario de PushingBox:

Para estado del dispositivo leemos información del canal de estado de ThingSpeak:

Para notificaciones y alertas leemos de los canales de alerta (fuego, intruso y visita):

Basándonos en los valores que obtenemos del campo de notificación, los mensajes de alerta correspondientes se almacenan en la variable respond0. Si no hay notificaciones, no se almacena ningún mensaje de notificación.

Una vez que la notificación se lee en voz alta, se actualiza '0' en los canales de notificación para que Alexa no lea la misma notificación de nuevo. Luego, al final, basándonos en la petición, la variable respond0/respond se lee en voz alta.

PD: Después de crear el modelo requerido en Backendless, haced clic en Desplegar Modelo en la esquina superior derecha de la pantalla Codeless para desplegar el modelo.

PASO 7: Configurar Skill de Alexa en la Consola de Desarrollador de Amazon:

Id a la Consola de Desarrollador de Amazon e iniciad sesión con cuenta de Amazon. https://developer.amazon.com/

Id a la Consola de Desarrollador y haced clic en la pestaña ALEXA. Haced clic en Alexa Skills Kit empezar.

Crear skill de tipo personalizado, dad nombre y nombre de invocación a la skill.

Las respectivas intenciones y frases de ejemplo se dan en el código de abajo.

{ "languageModel": { "intents": [ { "name": "AMAZON.CancelIntent", "samples": [] }, { "name": "AMAZON.HelpIntent", "samples": [] }, { "name": "AMAZON.StopIntent", "samples": [] }, { "name": "Camera", "samples": [ "please send a snapshot of my living room", "please send a snapshot of my home", "please send a photo of my living room", "please send a photo of my home" ], "slots": [] }, { "name": "FanOff", "samples": [ "turn off Fan", "switch off Fan", "turn off the Fan", "switch off the Fan" ], "slots": [] }, { "name": "FanOn", "samples": [ "turn on Fan", "switch on Fan", "turn on the Fan", "switch on the Fan" ], "slots": [] }, { "name": "Introduction", "samples": [ "what you can do", "what can you do", "what can you do for me" ], "slots": [] }, { "name": "LightsOff", "samples": [ "turn off lights", "switch off lights", "turn off the lights", "switch off the lights" ], "slots": [] }, { "name": "LightsOn", "samples": [ "turn on lights", "switch on lights", "turn on the lights", "switch on the lights" ], "slots": [] }, { "name": "Notification", "samples": [ "what are my notifications", "is there any notifications", "is there any updates", "read out my notifications" ], "slots": [] }, { "name": "Status", "samples": [ "what is my device status", "what is the status of my devices" ], "slots": [] }, { "name": "Weather", "samples": [ "what is the weather condition of my home", "what is the weather of my home", "what is the weather", "what is the temperature of my home", "what is the temperature" ], "slots": [] } ], "invocationName": "my home" } }

En la pestaña Configuración seleccionad HTTPS como tipo de endpoint de servicio, rellenad la URL por defecto con la URL API de Backendless.

Seleccionad la 2ª opción en Certificado para endpoint por defecto en Certificado SSL. También podéis probar la skill usando el simulador de prueba.

Después de que la prueba esté completa, podéis publicar la skill con la información de publicación requerida.

PASO 8: Configuración final y ¡Finalizado!

Haced la conexión del circuito como se muestra a continuación

A veces el ESP8266 fallará porque de corriente insuficiente. Así que, aunque no se menciona en el circuito, se recomienda alimentar el ESP8266 desde una fuente separada de 3.3v. Si usáis un powerbank aseguraos de reducir el voltaje de 5v a 3.3v usando un regulador de voltaje de 3.3v.

Subid el programa al ESP8266 y al Arduino. He mostrado la conexión a la bombilla, lo mismo se puede extender al ventilador o cualquier dispositivo.

Finalmente usad Amazon Echo o echosim.io para probar vuestra skill.

Debéis activar la skill usando el nombre de invocación ( como es mi caso - "mi hogar" ). A veces no funcionará si se usa sin nombre de invocación como he mostrado un par de veces en mi video.

¡Espero que disfrutéis el tutorial!

¡Gracias!

Código

• Smart_bell_ESP8266.ino
• Home_monitor_arduino.ino
• Home_Monitor_ESP8266.ino

Smart_bell_ESP8266.inoArduino

Código para ESP8266 para obtener alerta sobre intruso y visita

/* * Este sketch es implementación de timbre inteligente y seguridad del hogar * */
#include <ESP8266WiFi.h>
#include<String.h>
//------------------------------------------
// variables
//------------------------------------------
int intruder=0,guest=2; // pin 0 como alerta intruso y pin2 como alerta visita
const char* ssid = "SSID"; //vuestro SSID de WIFI
const char* password = "password"; // contraseña de Wifi
//--------------------------------------------
const char* host = "api.thingspeak.com";
void setup() {
Serial.begin(115200);
delay(10);
// Empezamos conectando a una red WiFi
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
/* Establecer explícitamente el ESP8266 como cliente WiFi, de lo contrario, por defecto intentaría actuar como cliente y punto de acceso y podría causar problemas de red con otros dispositivos WiFi en vuestra red WiFi. */
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
int value = 0;
int x,y=0,z,k=0;
void loop() {
delay(1000);
++value;
Serial.print("connecting to ");
Serial.println(host);
// Usar clase WiFiClient para crear conexiones TCP
WiFiClient client;
const int httpPort = 80;
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
Serial.print("Requesting URL: ");
//============================================================================================================
// alerta intruso
//============================================================================================================
x=digitalRead(intruder);
//Serial.println(x);
if(x==0) {
y=0;
}
if(x==1&&y==0) {
Serial.println("Sending Alert Pls Wait.....");
delay(1000);
String host1="api.pushingbox.com";
client.print(String("GET ") + "/pushingbox?devid=<deviceID_intruderAlert> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n"); // ejecutar API pushing box
client.print(String("GET ") + "/update?api_key=<write_key_intruderAlert>&field1=1 HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); //actualizar notificación intruso
delay(1000);
y=1;
}
//============================================================================================================
// Fin de alerta intruso
//============================================================================================================
//============================================================================================================
// alerta visita
//============================================================================================================
long t1;
z=digitalRead(guest);
if(z==0 && (millis()>=t1+300000)) // esperar 5 min para evitar envío múltiple de alertas por múltiples pulsaciones del timbre
{
k=0;
}
if(x==1&&k==0) {
t1=millis(); // almacenar marca de tiempo actual en t1
Serial.println("Sending Alert Pls Wait.....");
delay(1000); // retraso para envío de alerta y debouncing del interruptor
String host1="api.pushingbox.com";
client.print(String("GET ") + "/pushingbox?devid=<deviceID_guestAlert> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n"); // ejecutar API pushing box
client.print(String("GET ") + "/update?api_key=<write_key_guestAlert>&field1=1 HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); //actualizar notificación visita
delay(1000);
k=1;
}
//============================================================================================================
// Fin de alerta visita
//============================================================================================================
unsigned long timeout = millis();
while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");
client.stop();
return;
}
}
//Serial.println("closing connection");
}

Home_monitor_arduino.inoArduino

Código para Arduino para controlar electrodomésticos

//Este sketch es la implementación de automatización del hogar
#include <SoftwareSerial.h>// importar la librería serial
#include<String.h>
//-----------------------------------------
// definiciones de pines
//-----------------------------------------
#define Light 2 // pin 2 para controlar luz
#define fan 3 // pin 3 para controlar ventilador
//------------------------------------------
// variables
//------------------------------------------
char e;
int p=0,q=0; //estas variables evitan encender/apagar dispositivos ya encendidos/apagados
SoftwareSerial home_monitor(10, 11); // RX, TX
char control_data; // los datos transmitidos por Bluetooth
void setup() {
// put your setup code here, to run once:
home_monitor.begin(115200);
Serial.begin(9600);
pinMode(13,OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
if (home_monitor.available()){
control_data=home_monitor.read(); // obtener información de control del ESP8266 por serie
e=control_data;
Serial.print(control_data);
//============================================================================================================
// Control de dispositivos
//============================================================================================================
// Realizar operaciones requeridas basadas en el valor del canal
//-------------------------------------------------------------
// LUZ
//-------------------------------------------------------------
if(e=='0'&&p==0) //Luz ON
{
digitalWrite(Light,LOW);
p=1;
}
if(e=='1'&&p==1) //Luz OFF
{
digitalWrite(Light,HIGH);
p=0;
}
//-------------------------------------------------------------
// Calefactor
//-------------------------------------------------------------
if(e=='2'&&q==0)
{
digitalWrite(fan,HIGH);
q=1;
}
if(e=='3'&&q==1)
{
digitalWrite(fan,LOW);
q=0;
}
}
}

Home_Monitor_ESP8266.inoArduino

Código para ESP8266 para actualizar humedad y temperatura en ThingSpeak y también recuperar información de control de ThingSpeak

/* * Este sketch actualiza información meteorológica en thingspeak.com y también recupera información de control de thingspeak.com * Envía la información de control a Arduino por serie */
#include <ESP8266WiFi.h>
#include<String.h>
#include "DHT.h" // incluyendo la librería del sensor de temperatura y humedad DHT11
#define DHTTYPE DHT11 // DHT 11
#define dht_dpin 2 // definir GPIO2 como entrada de datos
DHT dht(dht_dpin, DHTTYPE);
//------------------------------------------
// variables
//------------------------------------------
//dht DHT;
char c,e; // almacena los bytes que vienen del servidor
float temp,h; //almacena valor float de temp y humedad
String humidity,temperature,line; //almacena valor string de temp y humedad
int co=0; //controlar el envío de Alerta
const char* ssid = "SSID"; //vuestro SSID de WIFI
const char* password = "password"; // contraseña de Wifi
//--------------------------------------------
const char* host = "api.thingspeak.com";
void setup() {
dht.begin();
Serial.begin(115200);
delay(10);
// Empezamos conectando a una red WiFi
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
/* Establecer explícitamente el ESP8266 como cliente WiFi, de lo contrario, por defecto intentaría actuar como cliente y punto de acceso y podría causar problemas de red con otros dispositivos WiFi en vuestra red WiFi. */
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
int value = 0;
void loop() {
delay(1000);
++value;
Serial.print("connecting to ");
Serial.println(host);
// Usar clase WiFiClient para crear conexiones TCP
WiFiClient client;
const int httpPort = 80;
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
Serial.print("Requesting URL: ");
//============================================================================================================
// Mini Estación Meteorológica
//============================================================================================================
h = dht.readHumidity(); //leer humedad y temperatura
temp = dht.readTemperature();
if(temp<50.0) {
co=0;
}
if(temp>=50.0&&co==0) // enviar alerta si temperatura supera 50 grados y co evita alertas múltiples
{
Serial.println("Sending Alert please wait.......");
delay(1000);
String host1="api.pushingbox.com";
client.print(String("GET ") + "/pushingbox?devid=<deviceID_fireAlert> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n"); //API pushingbox para enviar alerta
delay(1000);
client.print(String("GET ") + "/update?key=<write_key_fireAlert>&field1=1 HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); //actualizar canal alerta fuego ThingSpeak
co=1;
}
humidity=String(h);
temperature=String(temp);
Serial.println(h);
Serial.println(temp);
client.print(String("GET ") + "/update?key=<write_key_humidity>&field1="+humidity+" HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); //actualizar humedad en canal ThingSpeak
client.print(String("GET ") + "/update?key=<write_key_temperature>&field1="+temperature+" HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); //actualizar temperatura en canal ThingSpeak
//============================================================================================================
// Fin de Estación Meteorológica
//============================================================================================================
//============================================================================================================
// Enviar info de control a Arduino por serie
//============================================================================================================
// Esto enviará la petición al servidor
client.print(String("GET ") + "/channels/<channelID_control>/field/field1/last.html HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // obtener información sobre control de dispositivo
unsigned long timeout = millis();
while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");
client.stop();
return;
}
}
// Leer todas las líneas de la respuesta del servidor e imprimirlas en Serie
while(client.available()){
String line = client.readStringUntil('\r');
}
Serial.print(line); // recibido por Arduino por serie
//Serial.println("closing connection");
}

Esquemáticos