Para el control de dispositivos electrónicos, gracias a las redes inalámbricas se potencia aún más el concepto de “Smart Home Automation” entendiendo la automatización del hogar como una red de hardware que funciona para comunicar los dispositivos cotidianos entre sí a través del servicio de Internet (IoT). Por ello conecta todos los dispositivos con una «única unidad de control central común» que depende de la entrada del usuario. Estos dispositivos pueden tener conectividad wifi para interactuar con teléfonos inteligentes o tabletas, ya sea que los usuarios estén en casa o en cualquier parte del mundo.

Por otro lado, tenemos a Blynk, una plataforma de Internet de las cosas que permite a los desarrolladores conectar sus dispositivos IoT (Internet de las cosas) a una variedad de servicios en la nube. La plataforma ofrece una aplicación móvil y un servidor de nube que se pueden utilizar para controlar y monitorear dispositivos conectados. Los desarrolladores pueden utilizar una variedad de lenguajes de programación para crear aplicaciones que se comuniquen con el servidor de Blynk y controlen sus dispositivos IoT.

En este post mostraremos un sistema de automatización del hogar inteligente con funciones de LDR, temperatura y humedad.  Además, cuenta con pulsador externo y funciones de interruptor táctil. Este sistema funciona a través del software Blynk, que como vamos a ver es fácil de controlar.

Este proyecto incluye dos partes principales: primero está el hardware, que nos permite controlar los sensores y actuadores del sistema de automatización del hogar inteligente, el segundo es el servidor, que gestiona, controla y monitoriza el domicilio del usuario.

Un sistema IoT se construye con sensores básicos, actuadores, sistema integrado, red, interfaz de usuario y almacenamiento de datos. Estos se discuten en detalle a continuación.

Sensores

Hay tres tipos de sensores que usamos para construir este sistema usando el software Blynk. El primero es el sensor DHT11 que puede detectar tanto la temperatura como la humedad, el cual hemos visto en este blog en numerosas aplicaciones. 

El DHT11 es un sensor de humedad y temperatura que se utiliza comúnmente en proyectos de IoT (Internet de las cosas) y automatización del hogar. Este sensor utiliza un chip capacitivo para medir la humedad y un termistor para medir la temperatura. El DHT11 es un sensor de bajo costo y bajo consumo de energía que es fácil de usar y se comunica con un microcontrolador a través de un protocolo de comunicación digital. Es un sensor bastante simple, pero es bastante preciso en las mediciones de humedad y temperatura en un rango de 0 a 50 grados Celsius y de 20 a 90% de humedad relativa.

El segundo es un simple LDR, que controla las funciones de encendido/apagado automático del sistema. Y el tercer sensor es un sensor táctil, que se utiliza para controlar los actuadores manualmente a través del tacto.

Actuadores

El módulo de relé de dos canales de 5 V se utiliza aquí como actuador. Básicamente, los pines de salida que están conectados directamente a la entrada del relé se denominan actuadores. Las cargas eléctricas como luces de CA, ventiladores, etc. están conectadas a los terminales comunes y normalmente abiertos de los relés. Este módulo de relé es controlado por la aplicación Blynk a través de teléfonos inteligentes.

Sistema Integrado

Cada dispositivo inteligente de automatización del hogar necesita un sistema integrado adecuado que pueda manejar todo el proceso. ESP8266 NodeMCU juega el papel aquí como un controlador integrado. Es programable por el software Arduino IDE. El NodeMCU controla los datos digitales y analógicos del receptor y los transmite a través de un servidor web. Al mismo tiempo, sus comandos de proceso son dados por sensores y actuadores.

Red

Para vincular todos los dispositivos con el sistema integrado, necesitamos una red adecuada para comunicarnos entre nosotros.

Interfaz de usuario

Para enviar datos del receptor al transmisor, necesitamos una interfaz de usuario para controlar los dispositivos desde cualquier lugar. En este proyecto, presentamos la plataforma Blynk para hacer este sistema inteligente de automatización del hogar. Es demasiado simple de usar. También proporciona botones no programables para ahorrar tiempo y esfuerzos de programación.

Almacenamiento de datos

El almacenamiento de datos utilizado aquí también lo proporciona la plataforma en la nube Blynk. El almacenamiento de big data es básicamente una gran cantidad de datos que se recopilan de todos los dispositivos. Este tipo de datos siempre varía de un dispositivo a otro. Al ser un servidor en la nube, la velocidad de datos es muy alta.

Diagrama de circuito

El circuito es realmente sencillo como podemos ver en el siguiente esquema siendo el «corazón» el ESP8266. En el circuito el DHT11 esta conectado al GPI10 mediante el protocolo one-wire. También tenemos cuatro pulsadores, tres conectados al GPIO16, GPIO13 y GPIO15 ( pueden usarse en su lugar también sensores táctiles ) y un cuarto al pin de reset. Asimismo no podemos olvidar el LDR conectado a la único puerto analógico disponible en el ESP8266 ( el ADCO).

Para terminar tenemos dos relés conectados al GPiO14 y GPIO12 mediante dos transistores de pequeña señal BC547B con sus correspondientes resistencias de base y diodos de protección en las bobinas de los relés.

Esta es la lista de componentes del circuito:

• ESP8266 NodeMCU
• Sensor de humedad DHT11
• Sensor LDR
• Sensor táctil (x3)
• Relé de 5V (x2)
• Acoplador óptico 817 (x2)
• Transistor BC547 NPN (x2)
• Pulsador (x3)
• LED rojo (x2)
• LED verde (x2)
• 1N4007 PN Diodo (x2)
• Terminal de tornillo (x2)
• Resistencia de 330Ω (x2)
• Resistencia de 1KΩ (2)
• alambres

Diseño de circuitos con software de PCB para la automatización del hogar inteligente

Para hacer el circuito compacto y darle un aspecto profesional, podemos usar una a PCB después de probar todas las características del proyecto de domótica inteligente utilizando el módulo wifi ESP8266 en la placa de pruebas. 

Para el archivo Gerber, consulte este enlace Automatización inteligente del hogar usando ESP8266 y Blynk .

Software necesario para la automatización del hogar inteligente

La comunicación entre los dispositivos y la plataforma Blynk IoT se establecerá cuando haya una conexión de red presente.

Para cargar el código a ESP8266 NodeMCU, necesitamos el software Arduino IDE.

• Primer software Arduino IDE abierto
• Vaya a Archivo y seleccione Preferencias y pegue el enlace » https://arduino.esp8266.com/stable/package_esp8266com_index.json » en las URL de Administrador de placa adicional para agregar la placa ESP8266. Abra Boards Manager desde el menú Herramientas y escriba ESP8266 para instalar la plataforma ESP8266.
• Para programar el módulo ESP8266, se requiere una identidad única del software Blynk. Ese es el código de autenticación. Después de conectarse a una red, esta identificación ayuda a comunicarse con el dispositivo.
• Para conectarse a la red WiFi local se requiere WiFi SSID y contraseña.
• Antes de compilar y cargar el código en este módulo, debemos instalar la  biblioteca de sensores de Adafruit , la biblioteca Blynk , la biblioteca DHT11 y la biblioteca OLED .

Para agregar estas bibliotecas al IDE de Arduino, vaya a Sketch – Incluir biblioteca – Agregar biblioteca .zip – busque e instale archivos.

Preparación del panel de control de automatización del hogar inteligente con Blynk

Abra la aplicación oficial de Blynk y cree una cuenta para usted. Después de crear un nuevo proyecto, recibirá el token de autenticación a través de su correo electrónico.

Copie este token de autenticación y péguelo en los campos correspondientes del código Arduino ESP8266. Después de eso, cargue el código IDE de Arduino en NodeMCU y espere a que se conecte con el dispositivo en la red.

La página siguiente mostrará un espacio en blanco para agregar botones para el sistema. Toque el espacio en blanco y elija la opción de botón y agregue esto. Nuevamente haga clic en esto y elija un pin virtual y seleccione el pin deseado que incluye en su código Arduino. Luego haga clic en Aceptar y presione Atrás.

Continuar con el mismo proceso con el otro. Después de eso, elija el botón de indicador de temperatura y humedad y elija sus pines virtuales. Finalmente, regrese a la página de inicio y haga clic en el botón de reproducción en la parte superior derecha. Puede controlar sus dispositivos a través de esta aplicación Blynk.

Principio de funcionamiento del sistema de automatización del hogar inteligente

El sistema de automatización del hogar inteligente basado en ESP8266 se basa en el módulo wifi ESP8266, LDR, sensor DHT11, tres sensores táctiles, pantalla OLED y dos relés.

Este circuito tiene dos partes de sensores:

•  La primera parte es una entrada analógica para medir la intensidad de la luz a través del sensor LDR
•  La segunda parte es una entrada digital para leer valores de temperatura y humedad a través del sensor de humedad DHT11. Para medir una amplia gama de temperatura y humedad, puede usar DHT22 como reemplazo de DHT11.

Necesitamos un suministro de 5 V CC para encender este circuito, ya que necesita controlar los relés. Luego, también tenemos que alimentar el ESP8266 NodeMCU. ESP8266 NodeMCU V1.0 tiene 11 pines GPIO y un pin ADC con resolución de 10 bits. En la figura, explicamos la configuración de pines de ESP8266. Este módulo tiene un regulador de voltaje incorporado de 3.3V. También tiene un convertidor de USB a serie basado en CP2102 que brinda una interfaz fácil con el PC para cargar el código Arduino en el módulo.

El sensor LDR se usa aquí para detectar la intensidad de la luz a su alrededor. Puede controlar el encendido o apagado de las luces según la intensidad de la luz. Esto está conectado al pin A0 del ESP8266 NodeMCU para leer el voltaje analógico según la luz ambiental. Se puede cambiar manualmente a través del botón CMOD en el sistema.

El sensor DHT11 se usa aquí para leer la temperatura y la humedad a través del pin de entrada digital SD3. Los datos dados se dividen en temperatura y humedad por DHT11 a través del mismo pin de entrada. Los pines digitales D5 y D6 están conectados a las entradas del relé que actúan como actuadores. Estos pines controlan los dispositivos de CA a través de la aplicación. Tres sensores táctiles se conectan a través de tres botones y luego se conectan a los pines digitales D0, D7 y D8 respectivamente. Cuando el sistema se desconecta, estos funcionarán como interruptores normales. Entonces, podríamos usar este proyecto de automatización del hogar inteligente tanto en modo en línea como fuera de línea.

Por último, necesitamos conectar la pantalla OLED con el sistema a través de los pines I2C de la pantalla NodeMCU y OLED. Esta pantalla OLED es opcional.

Código NodeMCU

//ESP8266 Based Smart Home Automation System Using Blynk
#define BLYNK_PRINT Serial            
#include <BlynkSimpleEsp8266.h>  
#include <DHT.h>
#include <SH1106Wire.h> 
void checkPhysicalButton();
int toggleState_1 = 0;
int pushButton1State = LOW;
int toggleState_2 = 0;
int pushButton2State = LOW;
float temperature1 = 0;
float humidity1   = 0;
int   ldrVal;
int   switchMode = 0;
//Set values for Auto Control Mode
const float maxTemp = 34.10;
const float minTemp = 33.8;
const int maxLight = 1000;
const int minLight = 200;
#define AUTH "4w8iA4UCRADMzqEt60NoviM3Ntno0oHP"                 // You should get Auth Token in the Blynk App.  
#define WIFI_SSID "CyBorg"             //Enter Wifi Name
#define WIFI_PASS "Tanmoy#Wifi@8481"         //Enter wifi Password
#define PUSH_BUTTON_CMODE  15 //D8
#define LDR_PIN            A0 //A0
#define DHTPIN             10 //SD3  pin connected with DHT
#define RELAY_PIN_1      14   //D5
#define RELAY_PIN_2      12   //D6
#define PUSH_BUTTON_1    16   //D0
#define PUSH_BUTTON_2    13   //D7
#define VPIN_BUTTON_1    V1 
#define VPIN_BUTTON_2    V2
#define VPIN_BUTTON_C    V3
#define VPIN_HUMIDITY    V5
#define VPIN_TEMPERATURE V6
// Declaration for an SH1106 display connected to I2C (SDA, SCL pins)
SH1106Wire display(0x3c, D2, D1);
// Uncomment whatever type you're using!
#define DHTTYPE DHT11     // DHT 11
//#define DHTTYPE DHT22   // DHT 22, AM2302, AM2321
//#define DHTTYPE DHT21   // DHT 21, AM2301
DHT dht(DHTPIN, DHTTYPE);
BlynkTimer timer;
void changeMode(){      
  delay(200);
  if (switchMode == 0){
    switchMode = 1;
  }
  else if (switchMode == 1) {
    switchMode = 0;
  }
  display.clear();
  display.setFont(ArialMT_Plain_24);
  display.drawString(10, 5, "Set Mode: ");
  display.setFont(ArialMT_Plain_24);
  display.drawString(20, 35, String(modeDecode(switchMode)));    
  display.display();
  delay(500);
  Blynk.virtualWrite(VPIN_BUTTON_C, switchMode);
  //display.clear();
}
void relayOnOff(int relay){
    switch(relay){
      case 1: 
             if(toggleState_1 == 0){
              digitalWrite(RELAY_PIN_1, HIGH); // turn on relay 1
              toggleState_1 = 1;
              }
             else{
              digitalWrite(RELAY_PIN_1, LOW); // turn off relay 1
              toggleState_1 = 0;
              }
             delay(100);
      break;
      case 2: 
             if(toggleState_2 == 0){
              digitalWrite(RELAY_PIN_2, HIGH); // turn on relay 2
              toggleState_2 = 1;
              }
             else{
              digitalWrite(RELAY_PIN_2, LOW); // turn off relay 2
              toggleState_2 = 0;
              }
             delay(100);
      break;
      default : break;      
      }
  
}
String modeDecode(int count){
  if (count == 0){
    return " Manual ";
  }
  else if (count == 1){
    return " Auto ";
  }
}
void displayData(){
  display.clear();
  display.setFont(ArialMT_Plain_24);
  display.drawString(20, 0, String(temperature1) + " 'C");
  display.drawString(20, 25, String(humidity1) + " %");
  display.setFont(ArialMT_Plain_16);
  display.drawString(10, 48, "Mode -> ");
  display.drawString(68, 48, String(modeDecode(switchMode)));
  display.display();
  Serial.print(F("Temperature: "));
  Serial.print(temperature1);
  Serial.print("   ");
  Serial.print(F("humidity: "));
  Serial.print(humidity1);
  Serial.print("   ");
  Serial.println(ldrVal); 
  Serial.println("");
}
void readSensor(){
    
  ldrVal = analogRead(LDR_PIN);
  
  float h = dht.readHumidity();
  float t = dht.readTemperature(); // or dht.readTemperature(true) for Fahrenheit
  
  if (isnan(h) || isnan(t)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }
  else {
    humidity1 = h;
    temperature1 = t;
  }  
}
void sendSensor()
{
  readSensor();
  // You can send any value at any time.
  // Please don't send more that 10 values per second.
  Blynk.virtualWrite(VPIN_HUMIDITY, humidity1);
  Blynk.virtualWrite(VPIN_TEMPERATURE, temperature1);
}
BLYNK_CONNECTED() {
  // Request the latest state from the server
  Blynk.syncVirtual(VPIN_BUTTON_1);
  Blynk.syncVirtual(VPIN_BUTTON_2);
  Blynk.syncVirtual(VPIN_BUTTON_C);
}
// When App button is pushed - switch the state
BLYNK_WRITE(VPIN_BUTTON_1) {
  toggleState_1 = param.asInt();
  digitalWrite(RELAY_PIN_1, toggleState_1);
}
BLYNK_WRITE(VPIN_BUTTON_2) {
  toggleState_2 = param.asInt();
  digitalWrite(RELAY_PIN_2, toggleState_2);
}
BLYNK_WRITE(VPIN_BUTTON_C) {
  switchMode = param.asInt();
}
void checkPhysicalButton()
{
  if (digitalRead(PUSH_BUTTON_1) == HIGH) {
      relayOnOff(1);
      // Update Button Widget
      Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
    }
  if (digitalRead(PUSH_BUTTON_2) == HIGH) {
      relayOnOff(2);
      // Update Button Widget
      Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
    }
}
void setup()
{
  Serial.begin(9600);
  
  // Initialising the UI will init the display too.
  display.init();
  display.flipScreenVertically();
  display.setFont(ArialMT_Plain_16);
  display.setTextAlignment(TEXT_ALIGN_LEFT);
  delay(1000);  
  display.setColor(WHITE);
  display.clear();
  pinMode(RELAY_PIN_1, OUTPUT);
  pinMode(PUSH_BUTTON_1, INPUT);
  digitalWrite(RELAY_PIN_1, toggleState_1);
  pinMode(RELAY_PIN_2, OUTPUT);
  pinMode(PUSH_BUTTON_2, INPUT);
  digitalWrite(RELAY_PIN_2, toggleState_2);
  Blynk.begin(AUTH, WIFI_SSID, WIFI_PASS);  
  // Setup a function to be called every 500 ms
  timer.setInterval(500L, checkPhysicalButton);
  
  dht.begin();
  // Setup a function to be called every second
  timer.setInterval(1000L, sendSensor);
  // Setup a function to be called every 2 second
  timer.setInterval(2000L, displayData);
}
void loop()
{
  if (digitalRead(PUSH_BUTTON_CMODE) == HIGH){
    changeMode();
  }   
  else{    
    if(switchMode == 1){ //if Auto Mode
      //DHT11 control Relay 1
      if(temperature1 > maxTemp){
        if(toggleState_1 == 0){
          digitalWrite(RELAY_PIN_1, HIGH); // turn ON relay 1
          toggleState_1 = 1;
          // Update Button Widget
          Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
        }
      }
      else if (temperature1 < minTemp){
        if(toggleState_1 == 1){
           digitalWrite(RELAY_PIN_1, LOW); // turn OFF relay 1
           toggleState_1 = 0;
           // Update Button Widget
           Blynk.virtualWrite(VPIN_BUTTON_1, toggleState_1);
          }
      }
      //LDR control Relay 2
      if( ldrVal < minLight){
        if(toggleState_2 == 0){
          digitalWrite(RELAY_PIN_2, HIGH); // turn ON relay 2
          toggleState_2 = 1;
          // Update Button Widget
          Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
        }
      }
      else if (ldrVal > maxLight){
        if(toggleState_2 == 1){
           digitalWrite(RELAY_PIN_2, LOW); // turn OFF relay 2
           toggleState_2 = 0;
           // Update Button Widget
           Blynk.virtualWrite(VPIN_BUTTON_2, toggleState_2);
          }
      } 
    }
    timer.run();
    Blynk.run();
  }
}

Explicación del código:

Este código es para un sistema de automatización del hogar basado en el ESP8266 y la aplicación Blynk. Aquí una explicación de las partes principales del código:

1. Inclusión de Librerías

#define BLYNK_PRINT Serial            
#include <BlynkSimpleEsp8266.h>  
#include <DHT.h>
#include <SH1106Wire.h> 

Estas líneas incluyen las librerías necesarias para Blynk, el sensor DHT y la pantalla SH1106.

2. Definición de Variables y Pines

int toggleState_1 = 0;
int pushButton1State = LOW;
int toggleState_2 = 0;
int pushButton2State = LOW;
float temperature1 = 0;
float humidity1 = 0;
int ldrVal;
int switchMode = 0;

Estas variables almacenan el estado de los botones, la temperatura, la humedad y el valor del sensor de luz (LDR).

3. Constantes para el Modo de Control Automático

const float maxTemp = 34.10;
const float minTemp = 33.8;
const int maxLight = 1000;
const int minLight = 200;

Estas constantes definen los límites para el control automático de temperatura y luz.

4. Configuración de WiFi y Blynk

#define AUTH "4w8iA4UCRADMzqEt60NoviM3Ntno0oHP"
#define WIFI_SSID "CyBorg"
#define WIFI_PASS "Tanmoy#Wifi@8481"

Estas líneas configuran el token de autenticación de Blynk y las credenciales de WiFi.

5. Definición de Pines

#define PUSH_BUTTON_CMODE  15 //D8
#define LDR_PIN            A0 //A0
#define DHTPIN             10 //SD3
#define RELAY_PIN_1        14 //D5
#define RELAY_PIN_2        12 //D6
#define PUSH_BUTTON_1      16 //D0
#define PUSH_BUTTON_2      13 //D7
#define VPIN_BUTTON_1      V1 
#define VPIN_BUTTON_2      V2
#define VPIN_BUTTON_C      V3
#define VPIN_HUMIDITY      V5
#define VPIN_TEMPERATURE   V6

Aquí se definen los pines para los botones, el sensor DHT, los relés y las variables virtuales de Blynk.

6. Inicialización del Sensor DHT y la Pantalla

DHT dht(DHTPIN, DHTTYPE);
SH1106Wire display(0x3c, D2, D1);

Estas líneas inicializan el sensor DHT y la pantalla SH1106.

7. Funciones Principales

• changeMode(): Cambia entre los modos manual y automático.
• relayOnOff(int relay): Controla el encendido y apagado de los relés.
• modeDecode(int count): Devuelve el modo actual como una cadena (“Manual” o “Auto”).
• displayData(): Muestra los datos en la pantalla.
• readSensor(): Lee los valores del sensor DHT y el LDR.
• sendSensor(): Envía los datos del sensor a Blynk.

8. Configuración de Blynk y WiFi

void setup() {
  Serial.begin(9600);
  Blynk.begin(AUTH, WIFI_SSID, WIFI_PASS);
  dht.begin();
  display.init();
  display.flipScreenVertically();
  display.setFont(ArialMT_Plain_10);
  pinMode(RELAY_PIN_1, OUTPUT);
  pinMode(RELAY_PIN_2, OUTPUT);
  pinMode(PUSH_BUTTON_1, INPUT_PULLUP);
  pinMode(PUSH_BUTTON_2, INPUT_PULLUP);
  pinMode(PUSH_BUTTON_CMODE, INPUT_PULLUP);
  timer.setInterval(1000L, sendSensor);
}

Esta función configura la conexión WiFi, inicializa los sensores y la pantalla, y configura los pines.

9. Bucle Principal

void loop() {
  Blynk.run();
  timer.run();
  checkPhysicalButton();
  displayData();
}

El bucle principal mantiene el funcionamiento de Blynk, el temporizador y actualiza la pantalla.

Este código permite controlar dispositivos del hogar de manera manual o automática, monitorear la temperatura y la humedad, y visualizar los datos en una pantalla.

Fuente https://circuitdiagrams.in/smart-home-automation-using-blynk/