3.5 Interruptor-Tomacorriente: Esquemático ESP01-Config

También posible construir una placa con los elementos necesarios para controlar el modo de operación del Módulo ESP-01 por medio de un DIP-Switch:

  • Modo Operación:  DIP-switch en 0111
  • Modo Programación: DIP-Switch en 1000

La operación es semejante al presentado en ésta sección, la diferencia es que no se requiere retirar el ESP01 de la placa. De ésta manera no se requiere retirar el módulo ESP-01 de la placa para realizar la carga del archivo.ino con la programación con un USB-TTL.

1. Esquemático con ESP01

2. Ensamble en Protoboard

3. Circuito impreso – PCB

4. Implementación en Placa perforada

Realizado para verificar las dimensiones y espacio usados en el diseño de la PCB. La versión es previa a la mostrada en la sección 3.

 

Conexión WiFi-MQTT

La conexión de un módulo ESP8266 a un «broker Mosquitto» se puede describir como una conversación en la que se habla (publish) y escucha (subscribe). En la conversación hay un intermediario (broker) que gestiona los mensajes, recibe mensajes de actualización de estados (publish) y los re-envía a los subscriptores.

Para la conexión a un broker MQTT, se supondrá que ya ha dispone de un servidor MQTT en forma básica, semejante a la descrita en la sección «Broker-MQTT Mosquitto instalar».
http://blog.espol.edu.ec/edelros/3-mqtt-mosquitto-instalar/

Adicionalmente, ya ha establecido la conexión a la red WiFi semejante al ejemplo del siquiente enlace.

http://blog.espol.edu.ec/edelros/conexion-wifi/

Verificada la conexión a la red WiFi, se procede describir el proceso de conexión al broker MQTT,

Instrucciones en Arduino IDE

Se inicia con las librerias para la conexión WiFi, y comunicación MQTT.

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

Datos MQTT- servidor

Para establecer la conexión con el broker, se requieren la dirección IP, usuario y contraseña MQTT. Actualice los datos correspondientes a la configuración de su broker.

// MQTT: Servidor
char* MQTT_IP = "192.168.xxx.xxx";
uint16_t MQTT_puerto = 1883;
char* MQTT_usuario = "usuarioprueba";
char* MQTT_contrasena = "usuarioclave";

Datos MQTT-dispositivo

Para cada dispositivo se asigna un identificador, tópico, instrucción de activación (command) y los valores de estado posibles. Ejemplo: ON, OFF.

// MQTT: Dispositivo Actuador Luz
char* MQTT_ID = "oficina_luz1";
char* MQTT_TOPIC = "oficina/luz1/estado";
char* MQTT_COMMAND = "oficina/luz1/cambia";
char MQTT_ActuadorEstado[10] = "OFF";

char* sensor_ON  = "ON";
char* sensor_OFF = "OFF";

Configuración de inicio

Para el bloque de configuración (setup) se verifica el estado de la conexión WiFi antes de intentar conectarse al broker MQTT-Mosquitto.

Para revisar el proceso por medio del monitor serie de Arduino IDE, se establece la variable serial_msg=true. Si los pines Tx-Rx se encuentran ocupados como entrada o salida, serial_msg=false para evitar conflictos entre mensajes y valores del proceso.

  // conexión WIFI y MQTT
  inicia_wifi(serial_msg);
  if (WiFi.status() == WL_CONNECTED){
    inicia_mqtt(serial_msg);
    }

La subrutina de inicio se resume en establecer los valores de servidor, la conexión y la interpretación de instrucción recibida (callback). Al establecer la conexión se procede a publicar el estado del dispositivo.

void inicia_mqtt(boolean SerialMensajes){
  int intentos = 5;
  int cuenta = 0;
  
  if (SerialMensajes){
    Serial.print(" MQTT Conectando a ");
    Serial.println(MQTT_IP);
    }
    
  mqttclient.setServer(MQTT_IP, MQTT_puerto);
  mqttclient.connect(MQTT_ID, MQTT_usuario, MQTT_contrasena);
  mqttclient.setCallback(callback);
  
  while (!mqttclient.connected() && (cuenta<=intentos)) {
    if (SerialMensajes){
      Serial.print(".");
    }
    cuenta = cuenta + 1;
    // LED Monitor parpadeo MQTT, enciende LOW
    digitalWrite(LED_pin, LOW);
    delay(600);
    digitalWrite(LED_pin, HIGH);
    delay(400);
    }
  if (mqttclient.connected()){
      publica_estado();
  }
  if (SerialMensajes){
    //Fin de "...."
    Serial.println();
    Serial.print(" MQTT Conectado: ");
    Serial.println(mqttclient.connected());
    Serial.print(" MQTT Estado: ");
    Serial.println(mqttclient.state());
    }
  }

Publicación, subscripción y Recepción de intrucción

Estas operaciones se deben personalizar para cada caso. Las siguientes partes se presentan como ejemplo, donde se deben seleccionar los tópicos, valores, comándos y actualizarlos para la aplicación específica que se encuentre desarrollando.

Publicación o Subscripción de estados

La publicación de estados y subscripción se realiza como una función.

// Publicar el estado del dispositivo
void publica_estado() {
  if (actuador_estado){
    snprintf (MQTT_ActuadorEstado,10, sensor_ON);
  }else{
    snprintf (MQTT_ActuadorEstado,10, sensor_OFF);
  }
  mqttclient.publish(MQTT_TOPIC,MQTT_ActuadorEstado,true); 
  mqttclient.subscribe(MQTT_COMMAND);

Recibir una Instrucción (callback)

Para recibir una instrucción (command) se procesa mediante la función «callback», que consiste en analizar  la instrucción y el valor recibidos con los parámetros del dispositivo para establecer la acción a seguir en el dispositivo (actuador).

/ llega mensaje MQTT
void callback(char* p_topic, byte* p_payload, unsigned int p_length) {
  // procesa valor de cambio a texto
  String valor;
  for (uint8_t i = 0; i < p_length; i++) {
    valor.concat((char)p_payload[i]);
    }
  // compara mensaje recibido y actualiza estado
  if (String(MQTT_COMMAND).equals(p_topic)) {
    if (valor.equals(String(sensor_ON))) {
      if (actuador_estado != true) {
        actuador_estado = true;
        }
      }
    if (valor.equals(String(sensor_OFF))) {
      if (actuador_estado != false) {
          actuador_estado = false;
        }
      }
    LEDactivaestado();
    ACTUADORactivaestado();
    publica_estado();
    }
    if (serial_msg){
      Serial.println(" MQTT recibido ");
      Serial.print(MQTT_COMMAND);
      Serial.print(" ");
      Serial.println(valor);
    }
  }

Conexión WiFi

Prueba básica de conexión a WiFi, para el ejemplo se presenta con módulo ESP-01 y conexión con un USB-TTL. La conexión a otros módulos es semejante en el uso de los pines de configuración.

El ejemplo, el módulo en operación  realiza un parpadeo de un LED por un segundo (1000 ms). mientras que para el modo de conexión realiza parpadeos más rápido s(250ms).

Esquematico

La alimentación del circuito  mostrada sigue las indicaciones de la sección: Fuente de alimentación 3.3VDC

El control para el modo de «operación/Programación» y «reset» se implementa por medio de botoneras. El modo predeterminado de inicio es «operación»  por medio de  GPIO0 a estado +VCC (HIGH) con una resistencia (pullup), al  presionar la botonera se cambia el estado a GND (LOW).

Para programar se presiona la botonera «programar» y luego un pulso de «reset», el módulo está listo para «subir» instrucciones desde IDE Arduino.

Para referencia se muestran las conexiones usando un protoboard.

Instrucciones en Arduino IDE

Se usa la libreria < ESP8266WiFi.h> personalizada para los módulos ESP8266, permite obtener datos como MAC, IP, RSSI, y algunos valores de estado de conexión.

Las variables ssid y password se usan para el identificador de red y contraseña del router a conectarse, reemplace con el valor apropiado para la red a usar.

Una versión simplificada de instrucciones permite la conexión y observación por medio de los parpadeos del led del módulo.

/* ESP8266/ESP-01 WIFI Blink 
 *  edelros@espol.edu.ec 2019
 *  Ejemplo de conexión a WiFi
 *  Para usar, actualice las secciones de:
 *  - WIFI:Router
*/
#include 

// WIFI: conexión a Router
char* ssid = "aaaaa";
char* password = "aaaaa";

// LED monitor //interno: ESP01-pin=1, ESP07-pin=2
int LED_pin=1;

WiFiClient wifiClient;

void setup() {
  // LED monitor, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI y MQTT
  inicia_wifi();
  }

void loop() {
  // revisa estado de WiFi
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi();
    }

    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(1000); // un segundo
    digitalWrite(LED_pin, HIGH);
    delay(1000);
    
    // Tiempo para procesar señal WiFi
    delay(100);
}

void inicia_wifi(){
  int intentos = 20;
  int cuenta = 0;
     
  WiFi.begin(ssid, password);
  
  while((WiFi.status() != WL_CONNECTED)&&(cuenta<=intentos)){
    cuenta = cuenta+1;
    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(250);
    digitalWrite(LED_pin, HIGH);
    delay(250);
    }
  }

Instrucciones con mensajes a monitor Serial

El proceso se puede observar mediante desde el IDE Arduino para el módulo ESP-07. En la versión ESP-01 el LED interno se encuentra conectado al pin de TX usado para la comunicación Serial y causaría un conflicto.

En ésta versión se puede cambiar el led a otro pin configurado como salida GPIO2, lo que permite conectar Tx y Rx y observar los mensajes del proceso de conexión.

/* ESP8266/ESP-01 WIFI Blink 
 *  edelros@espol.edu.ec 2019
 *  Ejemplo de conexión a WiFi
 *  Para usar, actualice las secciones de:
 *  - WIFI:Router
 *  ESP-01: desactive los Mensajes seriales
 *  ESP-07: Active los Mensajes por serial
 *  usando serial_msg = false o true
*/
#include <ESP8266WiFi.h>

// WIFI: conexión a Router
char* ssid = "aaaaa";
char* password = "aaaaa";

// LED monitor //interno: ESP01-pin=1, ESP07-pin=2
int LED_pin=1;

// Mensajes por Puerto Serial
volatile boolean serial_msg = false;

WiFiClient wifiClient;

void setup() {
  if (serial_msg){
    // Conexion serial // ESP01 muestra reinicio en 74880
    Serial.begin(74880);//115200,74880
  }

  // LED monitor, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // conexión WIFI y MQTT
  inicia_wifi(serial_msg);
  }

void loop() {
  // revisa estado de WiFi
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi(serial_msg);
    }

    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(1000); // un segundo
    digitalWrite(LED_pin, HIGH);
    delay(1000);
    
    // Tiempo para procesar señal WiFi
    delay(100);
}

void inicia_wifi(boolean SerialMensajes){
  int intentos = 20;
  int cuenta = 0;
  
  if (SerialMensajes){
    Serial.print(" WIFI Conectando a ");
    Serial.println(ssid);
    }
    
  WiFi.begin(ssid, password);
  
  while((WiFi.status() != WL_CONNECTED)&&(cuenta<=intentos)){
    if (SerialMensajes){
      Serial.print(".");
      }
    cuenta = cuenta+1;
    // LED Monitor Parpadea, enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(250);
    digitalWrite(LED_pin, HIGH);
    delay(250);
    }

  if (SerialMensajes){
    //Fin de "..."
    Serial.println();
    if (WiFi.status() == WL_CONNECTED){
      Serial.print(" Estado: ");
      Serial.println(WiFi.status());
      Serial.print(" MAC: ");
      Serial.println(WiFi.macAddress());
      Serial.print(" IP: ");
      Serial.println(WiFi.localIP());
      Serial.print(" RSSI: ");
      Serial.println(WiFi.RSSI());
      Serial.println();
      }
    if (WiFi.status() != WL_CONNECTED){
      WiFi.printDiag(Serial);
      Serial.println();
      }
    }
  }

Referencia: https://esp8266-arduino-spanish.readthedocs.io/es/latest/esp8266wifi/readme.html

IDE Arduino con ESP8266

Las instrucciones para el módulo ESP8266 se pueden desarrollar en el IDE Arduino. Se requiere añadir el módulo a las «Herramientas» en el «Gestor de tarjetas» usando la versión «ESP8266 Community» más actualizada.

Los pasos a seguir son:

1. En el menú Archivo/Preferencias, se añade en «Gestor de URL’s Adicionales de Tarjetas» la dirección:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

2. En menú de Herramientas, Placas, Gestor de tarjetas, se añade «ESP8266 Community». Se puede buscar y filtrar con las palabras esp8266.

3. La acción anterior habilita la opción se seleccionar como placa: «Generic ESP8266 Module»

Con lo que es posible usar los ejemplos presentados.


Referencia

https://github.com/esp8266/Arduino

ESP07 MQTT-TLS-LED

Se adjuntan las instrucciones básicas para controlar el led incorporado en el módulo ESP-07 usando MQTT con TLS. Revise la sección de Broker para MQTT-TLS

Se mantiene como punto de partida para usar TLS en los prototipos de Dispositivos.

/*  ESP8266 MQTT TLS 1.2 Ejemplo para estado LED
 *  Controlado desde broker MQTT-Mosquitto y Home Assistant
 *  Grupo IRNI-FIEC-ESPOL
*/
#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// WIFI datos para conexión a Router
const PROGMEM char* ssid = "xxxx";
const PROGMEM char* password = "xxxx";

// MQTT: Servidor MQTT 
const PROGMEM char* MQTT_SERVER_IP = "xxxx";
const PROGMEM uint16_t MQTT_SERVER_PORT = 8883;
const PROGMEM char* MQTT_USER = "usuarioprueba";
const PROGMEM char* MQTT_PASSWORD = "usuarioclave";

// MQTT: identificador de dispositivo y topics
const PROGMEM char* MQTT_CLIENT_ID = "Jardin01";
const char* MQTT_SENSOR_TOPIC =  "home/garden/fountain";
const char* MQTT_SENSOR_COMMAND_TOPIC = "home/garden/fountain";
// payloads by default (on/off)
const char* SENSOR_ON = "ON";
const char* SENSOR_OFF = "OFF";
char MQTT_SENSOR_STATE[10] = "OFF"; // inicializa

// Certificados TLS: Certificate Authority
const char caCert[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
MIID+TCCAuGgAwIBAgIUC9VemIObh1BEF0vR0d2lNDEbfZ0wDQYJKoZIhvcNAQEL
BQAwgYsxCzAJBgNVBAYTAkVDMQ8wDQYDVQQIDAZHdWF5YXMxEjAQBgNVBAcMCUd1
...
9vX0/zaZoHcIeJwX0X3Ej6d3f+v9dLUhh14veDhnXzNSAeHCoM2QuIH1LnEl2Xrl
JNQANSgsMMh0tXJQQqJd1E2nxOCv5kxmKd3p7VnrD2JajsqQ9LxepsyC9W4V6Gjw
MIXc4ndT9GV03KxCGA==
-----END CERTIFICATE-----
)EOF";

// MQTT: cert SHA1 fingerprint
const uint8_t mqttCertFingerprint[] = {0x79,0xCA,0x31,0x25,0x0A,0xCB,0x70,0x48,0xF9,0xAE,0xA7,0xDE,0xB2,0x6E,0xAB,0x8D,0x22,0x17,0x17,0x3A};

// X.509 parsed CA Cert 
X509List caCertX509(caCert);
// Secure client connection class
WiFiClientSecure espClient;
// MQTT: Client connection
PubSubClient mqttClient(espClient);
// MQTT: client ID (will add random hex suffix during setup
String clientId = "ESP8266Client-"; 

// LED monitor interno: ESP01-pin=1, 
// ESP07-pin=2, ESP32-PIN=5
const PROGMEM uint8_t LED_pin = 2;
volatile int SENSOR_estado = LOW;

// control de mensajes serial
volatile boolean serial_msg = true;

void setup() {
  if (serial_msg){
    // Conexion serial
    Serial.begin(74880);//115200,74880
    Serial.setTimeout(2000);
    // espera inicializar serial
    while(!Serial) { }
  }

    // LED monitor
    pinMode(LED_pin, OUTPUT);
    
    // conexión WIFI y MQTT
    inicia_wifi();
    if (WiFi.status() == WL_CONNECTED){
        inicia_mqtt();
    }
}

void loop() {
  LEDactivaestado();
  mensajes();
  // SENSORpublicaestado();

  if (WiFi.status() != WL_CONNECTED){
      inicia_wifi();
  }else{
      if (!mqttClient.connected()){
          inicia_mqtt();
      }else{
          mqttClient.loop();
        }
  }
  delay(1000);
}
// establece estado LED monitor en ESP8266
void LEDactivaestado(){
    if (SENSOR_estado){
        digitalWrite(LED_pin, LOW);
    }else{
        digitalWrite(LED_pin, HIGH);
    }
}

void mensajes(){
    if (serial_msg){
        Serial.println();
        Serial.print("\n Sensor: ");
        Serial.print(SENSOR_estado);
        Serial.print("   MQTT: ");
        Serial.print(MQTT_SENSOR_STATE);
        Serial.print("\n MAC: ");
        Serial.println(WiFi.macAddress());
        if (WiFi.status() == WL_CONNECTED){
            Serial.print(" WiFi IP: ");
            Serial.println(WiFi.localIP());
            if (mqttClient.connected()){
              Serial.print(" MQTT conectado, estado: ");
              Serial.println(String(mqttClient.state()));
            }
        }
    }
  }

// Publicar el estado del dispositivo
void SENSORpublicaestado() {
    if (SENSOR_estado) {
        mqttClient.publish(MQTT_SENSOR_TOPIC, SENSOR_ON, true);
    }else{
        mqttClient.publish(MQTT_SENSOR_TOPIC, SENSOR_OFF, true);
    }
}

void inicia_wifi() {
    int intentos = 20;
    int cuenta = 0;
    if (serial_msg){
        Serial.print(" WIFI Conectando a ");
        Serial.println(ssid);
    }
    
    WiFi.begin(ssid, password);
    while ((WiFi.status() != WL_CONNECTED) && (cuenta<=intentos)){
        if (serial_msg){
          Serial.print(".");
        }
        cuenta = cuenta+1;
        delay(250);
        }
    if (serial_msg){
      Serial.println();
      }
}

void inicia_mqtt(){
    int intentos = 2;
    int cuenta = 0;

    // Configura cliente TLS
    // añade CA cert en los sitios de confianza
    espClient.setTrustAnchors(&caCertX509);
    // Habilita self-signed cert       
    espClient.allowSelfSignedCerts(); 
    // añade fingerprint para validar conexión              
    espClient.setFingerprint(mqttCertFingerprint);  
    
    if (serial_msg){
        Serial.print(" MQTT Conectando a ");
        Serial.println(MQTT_SERVER_IP);
    }

    mqttClient.setServer(MQTT_SERVER_IP, MQTT_SERVER_PORT);
    mqttClient.setCallback(callback);
    
    while (!mqttClient.connected() && (cuenta<=intentos)) {
        if (serial_msg){
            Serial.print(".");
        }
        mqttClient.connect(MQTT_CLIENT_ID, MQTT_USER, MQTT_PASSWORD);
        cuenta = cuenta + 1;
        delay(250);
    }
    if (serial_msg){
      Serial.println();
    }
    if (mqttClient.connected()){
      mqttClient.subscribe(MQTT_SENSOR_COMMAND_TOPIC);
      SENSORpublicaestado();
    }
}

// llega mensaje MQTT
void callback(char* p_topic, byte* p_payload, unsigned int p_length) {
    // convierte a cadena
    String payload;
    for (uint8_t i = 0; i < p_length; i++) {
        payload.concat((char)p_payload[i]);
        }
    if (serial_msg){
      Serial.println();
      Serial.print(" Llegó un mensaje: ");
      Serial.println(p_topic);
      Serial.println(payload);
    }
    // analiza mensaje por topico
    if (String(MQTT_SENSOR_COMMAND_TOPIC).equals(p_topic)) {
        if (payload.equals(String(SENSOR_ON))) {
            if (SENSOR_estado != true) {
                SENSOR_estado = true;
                LEDactivaestado();
                }
        } else if (payload.equals(String(SENSOR_OFF))) {
            if (SENSOR_estado != false) {
                SENSOR_estado = false;
                LEDactivaestado();
                }
        }
        if (SENSOR_estado){
          snprintf (MQTT_SENSOR_STATE,10, SENSOR_ON);
          }else{
            snprintf (MQTT_SENSOR_STATE,10, SENSOR_OFF);
          }
                
     }
}

Referencia: https://blog.thewalr.us/2019/03/27/using-esp8266-as-an-iot-endpoint-with-encrypted-mqtt-transport/

4.4 Sensor a Batería/Temp-Hum: Archivo.ino

1. Instrucciones en Arduino IDE

El modelo ESP-07 dispone de suficientes pines que permiten incorporar las funciones de programación usando pines de una sola función. Por lo que se facilita el diseño.

Modo Ahorro de Energía

Las instrucciones se desarrollan en la parte de configuración Setup() en lugar del lazo, Loop(), debido a que se utiliza el modo de ahorro de energía (deep-sleep).

2 Funciones para sensores y actuadores

Se han separado en funciones las instrucciones para el sensor de batería y temperatura-humedad.

/* Sensor de Temperatura y Humedad DHT11
Sensor de Estado de Batería
Funcionamiento con Batería
Para usar, se debe actualizar las secciones de:
 - WIFI datos para conexión a Router
 - MQTT: Servidor MQTT 
 - MQTT: identificador de dispositivo y topics
Se está usando ESP8266-07, pero para programar,
usar Placa:ESP8285
*/
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <dht.h>

// WIFI datos para conexión a Router
const PROGMEM char* ssid = "iotirni19";
const PROGMEM char* password = "anera2018";

// MQTT: Servidor MQTT 
const PROGMEM char* MQTT_SERVER_IP = "192.168.10.100";
const PROGMEM uint16_t MQTT_SERVER_PORT = 1883;
const PROGMEM char* MQTT_USER = "username";
const PROGMEM char* MQTT_PASSWORD = "password";

// MQTT: identificador de dispositivo y topics
const PROGMEM char* MQTT_CLIENT_ID = "Temp_humedad01";
const PROGMEM char* MQTT_SENSOR_TOPIC_T = "oficina/DHT_Temperatura";
const PROGMEM char* MQTT_SENSOR_TOPIC_H = "oficina/DHT_Humedad";
const PROGMEM char* MQTT_SENSOR_TOPIC_B = "oficina/DHT_Bateria";
const PROGMEM char* MQTT_SENSOR_TOPIC_BS = "oficina/DHT_BatSistema";
char MQTT_SENSOR_STATE_T[10] = "0"; // inicializa
char MQTT_SENSOR_STATE_H[10] = "0"; // inicializa
char MQTT_SENSOR_STATE_B[10] = "0"; // inicializa
char MQTT_SENSOR_STATE_BS[10] = "0"; // inicializa

// LED monitor interno
//ESP01-pin=1, ESP07-pin=2
const PROGMEM uint8_t LED_pin = 2; 

// Sensor de Temperatura&Humedad
dht DHT;
#define DHT11_PIN 12

// Bateria
#define bat_estado A0
const PROGMEM uint8_t bat_activa = 4;

// tiempo de dormir
int durmiendo = 5; //segundos

WiFiClient wifiClient;
PubSubClient client(wifiClient);

void setup() {
    // Conexion serial
    Serial.begin(9600);//74880);
    Serial.setTimeout(2000);

    // SENSOR Temperatura&Humedad
    //pinMode(DHT11_PIN, INPUT);

    // SENSOR Bateria
    pinMode(bat_activa, OUTPUT);
    digitalWrite(bat_activa, LOW);

    // LED monitor
    pinMode(LED_pin, OUTPUT);
    // LEDactivaestado();

    // Inicia redes
    if(WiFi.status() != WL_CONNECTED){
        inicia_wifi();
        }
    if (!client.connected()){
        inicia_mqtt();
        }
    client.loop();
    
    // espera inicializar serial
    while(!Serial) { }
    // actividad al despertar
    Serial.println();
    Serial.println("despertando");
    
    // lectura de sensores
    SensorTempHum();
    SensorBateria();

    // a dormir
    Serial.println("A dormir por " + String(durmiendo) + " segundos");
    ESP.deepSleep(durmiendo*1e6); //en microsegundos
}

void loop() {
    // modo sleep usa función setup
}

void SensorTempHum(){
    int chk = DHT.read11(DHT11_PIN);
    float temperatura = DHT.temperature;
    float humedad = DHT.humidity;
    Serial.println("Temperatura,Humedad: ");
    Serial.print(temperatura);
    Serial.print(",");
    Serial.println(humedad);
    client.publish(MQTT_SENSOR_TOPIC_T, 
                    String(temperatura).c_str(), 
                    true);
    client.publish(MQTT_SENSOR_TOPIC_H, 
                    String(humedad).c_str(), 
                    true);
    delay(1000);
}
void SensorBateria(){

    // Activar, Leer, Desactivar, publicar
    digitalWrite(bat_activa, HIGH);
    
    float bateria = analogRead(A0)*(57/10)/1024;
    int bat_sistema = ESP.getVcc()*100/65535;
    //delay(5000); // observar cambio
    digitalWrite(bat_activa, LOW);
    
    Serial.println("Bateria (V), sistema (%):");
    Serial.print(bateria);
    Serial.print(",");
    Serial.println(bat_sistema);
    
    client.publish(MQTT_SENSOR_TOPIC_B,
                    String(bateria).c_str(),
                    true);
    client.publish(MQTT_SENSOR_TOPIC_BS,
                    String(bat_sistema).c_str(),
                    true);
    delay(10);
}

void inicia_wifi() {
    // conexion WiFi
    Serial.print("\n Conectando a ");
    Serial.println(ssid);
    WiFi.begin(ssid, password);
    int cuenta = 0;
    while (WiFi.status() != WL_CONNECTED){
        Serial.print(".");
        cuenta = cuenta+1;
        if (cuenta>=40){
            Serial.println();
            cuenta = 0;}
        // LED interno enciende en LOW
        digitalWrite(LED_pin, LOW);
        delay(250);
        digitalWrite(LED_pin, HIGH);
        delay(250);
        }
    Serial.print("\n WiFi conectado \n Dirección IP: ");
    Serial.println(WiFi.localIP());
    delay(10);
}

void inicia_mqtt(){
    client.setServer(MQTT_SERVER_IP, MQTT_SERVER_PORT);
    //client.setCallback(callback);
    while (!client.connected()) {
        //Serial.println("\n Conectando a MQTT ");
        if (client.connect(MQTT_CLIENT_ID, MQTT_USER, MQTT_PASSWORD)) {
            Serial.println(" MQTT conectado");  
        } else {
            Serial.print("Falló, estado: ");
            Serial.print(client.state()); 
            Serial.print(" , reintento en 5 segundos");
            // LED interno enciende en LOW
            for (int i=0;i<=5;i=i+1){
                digitalWrite(LED_pin, LOW);
                delay(600);
                digitalWrite(LED_pin, HIGH);
                delay(400);
            }
        }
    }
}

5.3 Control Remoto IR: Archivo.ino

Instrucciones

Las instrucciones enfocadas en cada sensor o actividad se resumen en funciones, tratando de mantener la simplicidad del lazo principal.

Las instrucciones incorporan las siguientes características:

  • El control se realiza mediante las instrucciones MQTT
  • Usa el LED del ESP8266 como indicador de estado del acondicionador de aire o equipo activado por control remoto
  • Se emite la señal de control mediante la variable senal_ONOFF
  • Se controla el estado de lectura del sensor/decodificador infrarojo mediante MQTT, y la respuesta se emite a la conexión serial.
  • La temperatura y humedad se actualizan con el parametro «intervalo» cuyo primer número es minutos
/* Control Remoto con sensor de temperatura/Humedad
 *  version 1.0
Para usar, se debe actualizar las secciones de:
 - WIFI datos para conexión a Router
 - MQTT: Servidor MQTT 
 - MQTT: identificador de dispositivo y topics
Se está usando ESP8266-07, pero para programar,
usar Placa:ESP8285
*/
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <dht.h>

#include <IRremoteESP8266.h>
#include <IRsend.h>
#include <IRrecv.h>

#ifndef UNIT_TEST
#include <Arduino.h>
#endif
#include <IRutils.h>
// The following are only needed for extended decoding of A/C Messages
#include <ir_Coolix.h>
#include <ir_Daikin.h>
#include <ir_Fujitsu.h>
#include <ir_Gree.h>
#include <ir_Haier.h>
#include <ir_Hitachi.h>
#include <ir_Kelvinator.h>
#include <ir_Midea.h>
#include <ir_Mitsubishi.h>
#include <ir_MitsubishiHeavy.h>
#include <ir_Panasonic.h>
#include <ir_Samsung.h>
#include <ir_Tcl.h>
#include <ir_Teco.h>
#include <ir_Toshiba.h>
#include <ir_Vestel.h>
#include <ir_Whirlpool.h>

// WIFI datos para conexión a Router
const PROGMEM char* ssid = "xxxx";
const PROGMEM char* password = "xxxx";

// MQTT: Servidor MQTT 
const PROGMEM char* MQTT_SERVER_IP = "xx.xx.xx.xx";
const PROGMEM uint16_t MQTT_SERVER_PORT = 1883;
const PROGMEM char* MQTT_USER = "username";
const PROGMEM char* MQTT_PASSWORD = "password";

// MQTT: identificador de dispositivo y topics
const PROGMEM char* MQTT_CLIENT_ID = "Control Remoto 01";
const PROGMEM char* MQTT_SENSOR_TOPIC_T = "oficina/CR01/Temperatura";
const PROGMEM char* MQTT_SENSOR_TOPIC_H = "oficina/CR01/Humedad";

// MQTT: Control remoto enciende
const PROGMEM char* MQTT_SENSOR_TOPIC_10 = "oficina/CR01/enciende/status";
const PROGMEM char* MQTT_SENSOR_STATE_TOPIC_10 = "oficina/CR01/enciende/switch";
const PROGMEM char* MQTT_SENSOR_COMMAND_TOPIC_10 = "oficina/CR01/enciende/set";


// MQTT: lectura sensor IR
const PROGMEM char* MQTT_SENSOR_TOPIC_IR = "oficina/CR01/lectura/status";
const PROGMEM char* MQTT_SENSOR_STATE_TOPIC_IR = "oficina/CR01/lectura/switch";
const PROGMEM char* MQTT_SENSOR_COMMAND_TOPIC_IR = "oficina/CR01/lectura/set";
const PROGMEM char* MQTT_SENSOR_AVAILABILITY_TOPIC_IR = "oficina/CR01/lectura/available";


char MQTT_SENSOR_STATE_T[10] = "0"; // inicializa
char MQTT_SENSOR_STATE_H[10] = "0"; // inicializa
char MQTT_SENSOR_STATE[10] = "OFF"; // inicializa LED interno
char MQTT_SENSOR_STATE_IR[10] = "OFF"; // inicializa lectura IR

const PROGMEM char* SENSOR_ON  = "ON";
const PROGMEM char* SENSOR_OFF = "OFF";

volatile boolean SENSOR_estado = false;
volatile boolean SENSOR_IR = false;

// LED monitor interno
//ESP01-pin=1, ESP07-pin=2
const PROGMEM uint8_t LED_pin = 2; 

// Sensor de Temperatura&Humedad
dht DHT;
#define DHT11_PIN 13

// Control de tiempos
unsigned long antes = 0; 
unsigned long ahora = millis();
const long intervalo = 5*60*1000;//minutos*60s*1000ms

// Control Remoto Emisor LED
const PROGMEM uint8_t IR_LED = 5;
uint32_t senal_ONOFF = 0xFF5AA5; // código de control

IRsend irsend(IR_LED);  // configura emisor

// Control Remoto Receptor -------
const uint16_t kRecvPin = 4;
const uint32_t kBaudRate = 115200;
const uint16_t kCaptureBufferSize = 1024;
#if DECODE_AC
// Some A/C units have gaps in their protocols of ~40ms. e.g. Kelvinator
// A value this large may swallow repeats of some protocols
const uint8_t kTimeout = 50;
#else   // DECODE_AC
// Suits most messages, while not swallowing many repeats.
const uint8_t kTimeout = 15;
#endif  // DECODE_AC
const uint16_t kMinUnknownSize = 12; //12
IRrecv irrecv(kRecvPin, kCaptureBufferSize, kTimeout, true);
decode_results results;  // Somewhere to store the results

WiFiClient wifiClient;
PubSubClient client(wifiClient);

void setup() {
    // Conexion serial
    Serial.begin(115200);//74880);
    Serial.setTimeout(2000);
    // espera inicializar serial
    while(!Serial) { }

    // SENSOR Temperatura&Humedad
    pinMode(DHT11_PIN, INPUT);

    // Control Remoto Emisor LED
    irsend.begin();

    // LED monitor
    pinMode(LED_pin, OUTPUT);

    // Inicia redes
    if(WiFi.status() != WL_CONNECTED){
        inicia_wifi();
        }
    if (!client.connected()){
        inicia_mqtt();
        }

    // Inicia Receptor IR
    #if DECODE_HASH
    // Ignore messages with less than minimum on or off pulses.
    irrecv.setUnknownThreshold(kMinUnknownSize);
    #endif                  // DECODE_HASH
    irrecv.enableIRIn();  
}

void loop() {
    unsigned long ahora = millis();
    
    if(WiFi.status() != WL_CONNECTED){
        inicia_wifi();
        }
    if (!client.connected()){
        inicia_mqtt();
        }
    delay(10);   
    client.loop();

    if (((ahora - antes)> intervalo)) {
        antes = ahora;
    
        // lectura de sensores
        SensorTempHum();
        Serial.print("ESTADO DISPOSITIVO: \nLED ");
        Serial.print(SENSOR_estado);
        Serial.print(" , IR ");
        Serial.println(SENSOR_IR);
    }
    
    if (SENSOR_IR == true){
        sensarcodigos();
    }
    delay(10);
}

// establece estado LED monitor en ESP8266
void CR01activaestado(){
        irsend.sendNEC(senal_ONOFF,32);
}

// llega mensaje MQTT
void callback(char* p_topic, byte* p_payload, unsigned int p_length) {
    // convierte a cadena
    String payload;
    for (uint8_t i = 0; i < p_length; i++) {
        payload.concat((char)p_payload[i]);
        }
    Serial.print(" Llegó un mensaje: ");
    Serial.println(p_topic);
    Serial.println(payload);
    // analiza mensaje por topico
    if (String(MQTT_SENSOR_COMMAND_TOPIC_10).equals(p_topic)) {
        if (payload.equals(String(SENSOR_ON))) {
            if (SENSOR_estado != true) {
                SENSOR_estado = true;
                LEDactivaestado();
                CR01activaestado();
                SENSORpublicaestado();
                }
        } else if (payload.equals(String(SENSOR_OFF))) {
            if (SENSOR_estado != false) {
                SENSOR_estado = false;
                LEDactivaestado();
                CR01activaestado();
                SENSORpublicaestado();
                }
        }
     }
     if (String(MQTT_SENSOR_COMMAND_TOPIC_IR).equals(p_topic)) {
        Serial.print("+++ cambio de estado detectado para IR: ");
            if (payload.equals(String(SENSOR_ON))) {
                Serial.println("Lectura ON");
                if (SENSOR_IR != true) {
                SENSOR_IR = true;
                SENSOR_IRpublicaestado();
                }
            } else if (payload.equals(String(SENSOR_OFF))) {
                Serial.println("Lectura OFF");
                if (SENSOR_IR != false) {
                SENSOR_IR = false;
                SENSOR_IRpublicaestado();
                }
            }
     }
}

// establece estado LED monitor en ESP8266
void LEDactivaestado(){
    if (SENSOR_estado){
        digitalWrite(LED_pin, LOW);
    }else{
        digitalWrite(LED_pin, HIGH);
    }
}

void SensorTempHum(){
    int chk = DHT.read11(DHT11_PIN);
    float temperatura = DHT.temperature;
    float humedad = DHT.humidity;
    Serial.println("Temperatura,Humedad: ");
    Serial.print(temperatura);
    Serial.print(",");
    Serial.println(humedad);
    client.publish(MQTT_SENSOR_TOPIC_T, 
                    String(temperatura).c_str(), 
                    true);
    client.publish(MQTT_SENSOR_TOPIC_H, 
                    String(humedad).c_str(), 
                    true);
    delay(1000);
}

void inicia_wifi() {
    // conexion WiFi
    Serial.print("\n Conectando a ");
    Serial.println(ssid);
    WiFi.begin(ssid, password);
    int cuenta = 0;
    while (WiFi.status() != WL_CONNECTED){
        Serial.print(".");
        cuenta = cuenta+1;
        if (cuenta>=40){
            Serial.println();
            cuenta = 0;}
        // LED interno enciende en LOW
        digitalWrite(LED_pin, LOW);
        delay(250);
        digitalWrite(LED_pin, HIGH);
        delay(250);
        }
    Serial.print("\n WiFi conectado \n Dirección IP: ");
    Serial.println(WiFi.localIP());
    delay(10);
}

void inicia_mqtt(){
    client.setServer(MQTT_SERVER_IP, MQTT_SERVER_PORT);
    client.setCallback(callback);
    while (!client.connected()) {
        Serial.println("\n Conectando a MQTT ");
        if (client.connect(MQTT_CLIENT_ID, MQTT_USER, MQTT_PASSWORD)) {
            Serial.println(" MQTT conectado");  
        } else {
            Serial.print("Falló, estado: ");
            Serial.print(client.state()); 
            Serial.print(" , reintento en 5 segundos");
            // LED interno enciende en LOW 
            for (int i=0;i&lt;=5;i=i+1){
                digitalWrite(LED_pin, LOW);
                delay(600);
                digitalWrite(LED_pin, HIGH);
                delay(400);
            }
        }
    }
    client.publish(MQTT_SENSOR_TOPIC_10, MQTT_SENSOR_STATE_TOPIC_10);
    client.subscribe(MQTT_SENSOR_COMMAND_TOPIC_10);

    client.publish(MQTT_SENSOR_TOPIC_IR, MQTT_SENSOR_STATE_TOPIC_IR);
    client.subscribe(MQTT_SENSOR_COMMAND_TOPIC_IR);
}

// Publicar el estado del dispositivo
void SENSORpublicaestado() {
    if (SENSOR_estado) {
        client.publish(MQTT_SENSOR_TOPIC_10, SENSOR_ON, true);
    }else{
        client.publish(MQTT_SENSOR_TOPIC_10, SENSOR_OFF, true);
    }
    client.subscribe(MQTT_SENSOR_COMMAND_TOPIC_10);
}
// Publicar el estado del dispositivo IR
void SENSOR_IRpublicaestado() {
    if (SENSOR_IR) {
        client.publish(MQTT_SENSOR_TOPIC_IR, SENSOR_ON, true);
    }else{
        client.publish(MQTT_SENSOR_TOPIC_IR, SENSOR_OFF, true);
    }
    client.subscribe(MQTT_SENSOR_COMMAND_TOPIC_IR);
}

// Sensor IR para recibir códigos
void sensarcodigos(){
  // Check if the IR code has been received.
  if (irrecv.decode(&results)) {
    // Display a crude timestamp.
    uint32_t now = millis();
    Serial.printf("Timestamp : %06u.%03u\n", now / 1000, now % 1000);
    if (results.overflow)
      Serial.printf(
          "WARNING: IR code is too big for buffer (>= %d). "
          "This result shouldn't be trusted until this is resolved. "
          "Edit & increase kCaptureBufferSize.\n",
          kCaptureBufferSize);
    // Display the basic output of what we found.
    Serial.print(resultToHumanReadableBasic(&results));
    dumpACInfo(&results);  // Display any extra A/C info if we have it.
    yield();  // Feed the WDT as the text output can take a while to print.

    // Display the library version the message was captured with.
    Serial.print("Library   : v");
    Serial.println(_IRREMOTEESP8266_VERSION_);
    Serial.println();

    // Output RAW timing info of the result.
    Serial.println(resultToTimingInfo(&results));
    yield();  // Feed the WDT (again)

    // Output the results as source code
    Serial.println(resultToSourceCode(&results));
    Serial.println("");  // Blank line between entries
    yield();             // Feed the WDT (again)
  }
}

// Display the human readable state of an A/C message if we can.
void dumpACInfo(decode_results *results) {
  String description = "";
  #if DECODE_DAIKIN
  if (results->decode_type == DAIKIN) {
    IRDaikinESP ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_DAIKIN
  #if DECODE_DAIKIN2
  if (results->decode_type == DAIKIN2) {
    IRDaikin2 ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_DAIKIN2
  #if DECODE_DAIKIN216
  if (results->decode_type == DAIKIN216) {
    IRDaikin216 ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_DAIKIN216
  #if DECODE_FUJITSU_AC
  if (results->decode_type == FUJITSU_AC) {
    IRFujitsuAC ac(0);
    ac.setRaw(results->state, results-&gt>bits / 8);
    description = ac.toString();
  }
  #endif  // DECODE_FUJITSU_AC
  #if DECODE_KELVINATOR
  if (results->decode_type == KELVINATOR) {
    IRKelvinatorAC ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_KELVINATOR
  #if DECODE_MITSUBISHI_AC
  if (results->decode_type == MITSUBISHI_AC) {
    IRMitsubishiAC ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_MITSUBISHI_AC
  #if DECODE_MITSUBISHIHEAVY
  if (results->decode_type == MITSUBISHI_HEAVY_88) {
    IRMitsubishiHeavy88Ac ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  if (results->decode_type == MITSUBISHI_HEAVY_152) {
    IRMitsubishiHeavy152Ac ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_MITSUBISHIHEAVY
  #if DECODE_TOSHIBA_AC
  if (results->decode_type == TOSHIBA_AC) {
    IRToshibaAC ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_TOSHIBA_AC
  #if DECODE_GREE
  if (results->decode_type == GREE) {
    IRGreeAC ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_GREE
  #if DECODE_MIDEA
  if (results->decode_type == MIDEA) {
    IRMideaAC ac(0);
    ac.setRaw(results->value);  // Midea uses value instead of state.
    description = ac.toString();
  }
  #endif  // DECODE_MIDEA
  #if DECODE_HAIER_AC
  if (results->decode_type == HAIER_AC) {
    IRHaierAC ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_HAIER_AC
  #if DECODE_HAIER_AC_YRW02
  if (results->decode_type == HAIER_AC_YRW02) {
    IRHaierACYRW02 ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_HAIER_AC_YRW02
  #if DECODE_SAMSUNG_AC
  if (results->decode_type == SAMSUNG_AC) {
    IRSamsungAc ac(0);
    ac.setRaw(results->state, results->bits / 8);
    description = ac.toString();
  }
  #endif  // DECODE_SAMSUNG_AC
  #if DECODE_COOLIX
  if (results->decode_type == COOLIX) {
    IRCoolixAC ac(0);
    ac.setRaw(results->value);  // Coolix uses value instead of state.
    description = ac.toString();
  }
  #endif  // DECODE_COOLIX
  #if DECODE_PANASONIC_AC
  if (results->decode_type == PANASONIC_AC &&
      results->bits > kPanasonicAcShortBits) {
    IRPanasonicAc ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_PANASONIC_AC
  #if DECODE_HITACHI_AC
  if (results->decode_type == HITACHI_AC) {
    IRHitachiAc ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_HITACHI_AC
  #if DECODE_WHIRLPOOL_AC
  if (results->decode_type == WHIRLPOOL_AC) {
    IRWhirlpoolAc ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_WHIRLPOOL_AC
  #if DECODE_VESTEL_AC
  if (results->decode_type == VESTEL_AC) {
    IRVestelAc ac(0);
    ac.setRaw(results->value);  // Like Coolix, use value instead of state.
    description = ac.toString();
  }
  #endif  // DECODE_VESTEL_AC
  #if DECODE_TECO
  if (results->decode_type == TECO) {
    IRTecoAc ac(0);
    ac.setRaw(results->value);  // Like Coolix, use value instead of state.
    description = ac.toString();
  }
  #endif  // DECODE_TECO
  #if DECODE_TCL112AC
  if (results->decode_type == TCL112AC) {
    IRTcl112Ac ac(0);
    ac.setRaw(results->state);
    description = ac.toString();
  }
  #endif  // DECODE_TCL112AC
  // If we got a human-readable description of the message, display it.
  if (description != "") Serial.println("Mesg Desc.: " + description);
}

5.2 Control Remoto IR: Esquematico ESP07

1. Esquematico con ESP01

El esquematico se divide varias secciones mostradas en la figura y descritas a continuación.

Se integran el diseño presentado en los ejemplos de Receptor, Emisor infrarrojo y sensor de temperatura/humedad, lo que lo convierte en un ejercicio sumativo de experiencias previas.

1.1 Sensor

El sensor es infrarrojo , tipo TSOP382, TSOP384, o alguna versión que incluya el circuito de demodulación.

La versión del sensor infrarojo con detección y demodulación simplifica el circuito a un pin digital configurado como entrada en el módulo a usar, además de Vcc y Gnd.

Usando un control remoto IR convencional, al presionar una tecla se genera un código único que es detectado con el sensor.

El otro sensor usado en el dispositivo es temperatura y Humedad. La temperatura y humedad es información complementaria para operar un acondicionador de aire.

Los pines usados para cada sensor y actuador se encuentran etiquetados en el esquemático.

1.2 Actuador

Para enviar la señal del control al aparato (COSA: acondicionador de aire), se utiliza un LED infrarrojo semejante al mostrado en la figura.

Considere que algunos LED infrarojo son transparentes. La operación se puede comprobar al conectarlo como un LED normal y observarlo con la cámara de un teléfono móvil donde se ve la luminocidad.

 

1.3 Controlador

Centrado en ESP8266-07 con conector para sensor. La activación del módulo se realiza de acuerdo a lo descrito en el manual del módulo. Revisar en la sección «Módulos» ESP8266 versión ESP-07.

El reinicio del dispositivo se controla con la botonera «Reset» al cambiar el pin a estado BAJO (GND). El estado predeterminado es ALTO por medio de R1 y C1 minimiza los rebotes del pulsador.

1.3.1 Modo Ejecución

La operación predeterminada es «Ejecutar Programa» por medio de R3 hacia estado ALTO (pullup HIGH). Es posible reiniciar la ejecución usando la botonera Reset.

1.3.2 Modo Cargar Programa

Para «Cargar Programa» se realiza el cambio de estado con una botonera «PROG» hacia BAJO (GND), y conectando un módulo USB-TTL al computador con Arduino IDE. El módulo se conecta a los pines RX-TX-GND intercambiando entre ellos RX con TX.

Para iniciar la subida del programa desde Arduino IDE, se presionan en conjunto los botones RESET y PROG, soltando luego de 1 segundo solamente RESET y comenzará la subida del archivo. La botonera Reset dispone de R1 hacia estado predeterminado ALTO y C1 se usa para minimizar los rebotes.

La configuración se completa manteniendo el estado de GPIO2 en estado ALTO (pullup HIGH) con R2 y el pin de CH_PD a estado ALTO mediante R4.

1.4 Fuente DC

Conformada por el Regulador d 110VAC  a 5VDC, y el Regulador de 5VDC a 3.3VDC usando el módulo AMS1117.

Los componentes usados o sus sus componentes alternos se describen en la sección de Fuentes de Alimentación para Módulos.

http://blog.espol.edu.ec/edelros/fuente-de-alimentacion-a-3-3vdc/


2. Ensamble en Protoboard

Para probar el circuito se ensambla en un protoboard teniendo como guía el diagrama del circuito del punto anterior.

3. Circuito impreso – PCB

El diseño se ha realizado en dos placas por flexibilidad de ensamble. La placa de fuente de alimentación se puede reemplazar por un cargador USB, conectando a la primera placa del dispositivo a los conetores +5VDC-.

Observe al conectar los pines para el sensor y emisor infrarrojos.

2.4 Actuador Tomacorriente: MQTT-HA

Esta es la última sección a realizar, pues se supone que tiene listo el dispositivo, construido y operativas las partes: Dispositivo y Broker.

El objetivo es incorporar dispositivo Interruptor-Tomacorriente en el broker MQTT y observar los resultados.

Se plantea observar los estados del dispositivo en dos formas:

  • Desde un navegador en la página local de Home-Assistant
  • Desde una consola conectando al servidor MQTT

1. Incorporar el dispositivo en Home Assistant

Se requiere modificar el archivo configuration.yaml en el raspberry.

Se puede realizar en forma local desde el raspberry que tiene monitor, teclado y mouse conectado, y editar el archivo que se encuentra en el directorio:

 /home/homeassistant/.homeassistant/configuration.yaml

La otra forma es conectarse via remota por medio de una sesión ssh. Requiere dirección, usuario y password. Los detalles se dan en la sección Raspberry.

En el archivo se añade los datos del dispositivo interruptor-tomacorriente, que en el caso actual para pruebas se identifica como una luminaria (light).

El sensor trabaja con MQTT, se le asigna un nombre más sencillo de reconocer como «oficina luz 1.

Se complementa con la instrucción de control para el dispositivo (command_topic) identificada en el formato: «oficina/luz1/switch».

 

light:
  - platform: mqtt
    name: 'oficina_luz1'
    state_topic: 'oficina/luz1/estado'
    command_topic: 'oficina/luz1/cambia'
    optimistic: false

1.2  Monitoreo desde MQTT

Para monitorear señal desde consola Raspberry usando MQTT, usar la instrucción:

mosquitto_sub -h 192.168.10.100 -t oficina/luz1/estado