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 luz 1'
    command_topic: 'oficina/luz1/switch'
    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/contact

2.3 Actuador Tomacorriente: Archivo.ino

1. Instrucciones en Arduino IDE

Como la versión del ESP8266-01 no dispone de muchos pines de trabajo, se define el uso de los pines como:

  • monitor de operación del dispositivo: LED interno, GPIO1 (TXD)
  • control Actuador en GPIO2, pin 3, que es usado para la modo de operación al iniciar el dispositivo. Luego de iniciado se lo puede reconfigurar.

Por el uso en operación de los pines de comunicación Serial (GPIO1 y GPIO3) se descartan las lineas Serial.print() convirtiendolas en comentarios «//».

El diseño realizado permite conectar un módulo USB-TTL a la placa PCB. Revise la configuración de las botoneras Reset, PROG y los Jumpers para realizar la carga del archivo.ino.

Si la subida del archivo.ino al módulo ESP01  se realiza fuera de la placa PCB revise nuevamente la configuración de PCB para que trabaje en modo «Ejecutar» luego de insertar el módulo ESP01.

2. Funciones repetitivas

Para las acciones repetitivas como la conexión a WIFI y comunicación por MQTT se realizan en funciones para simplificar las instrucciones en la configuración inicial (setup) y la ejecución principal (loop).

Al inicio se definen las librerías y los valores para la conexión WIFI y los datos para comunicarse con el servidor MQTT-Mosquitto implementado en el Raspberry. Revisar de ser necesario al sección Broker.

2.1 función para actuador

Para procesar las instrucciones enviadas por el Broker en MQTT se añade la función callback().

Para el control del Relé se usa la función ACTUADORactivaestado() que realiza acciones semejantes a la de activar el monitor LED, y permite en futuro mantener separadas las acciones sobre el ACTUADOR o Relé.)

/*
 TOMACORRIENTE  | AC outlet
 Basic ESP8266 MQTT example with the ESP8266 board/library.
 Actuador Binario, para control de estado de una Luz.
 Para usar, se debe actualizar las secciones de:
 - WIFI datos para conexión a Router
 - MQTT: Servidor MQTT 
 - MQTT: identificador de dispositivo y topics
 Al usar ESP8266-01 se toman los pines TX para LED y GPI02 actuador
 por lo que se no se usa Serial.print(), con mesajes usado para depuración.
*/

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

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

// MQTT: Servidor MQTT 
const PROGMEM char* MQTT_SERVER_IP = "192.168.xx.xxx";
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 = "luz1";
const PROGMEM char* MQTT_SENSOR_TOPIC = "oficina/luz1/contact";
const PROGMEM char* MQTT_SENSOR_COMMAND_TOPIC = "oficina/luz1/switch";
const PROGMEM char* SENSOR_ON  = "ON";
const PROGMEM char* SENSOR_OFF = "OFF";
char MQTT_SENSOR_STATE[10] = "OFF"; // inicializa

// Actuador Switch Luz
const PROGMEM uint8_t ACTUADOR_pin = 2;

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

// Control de tiempos
unsigned long antes = 0; 
const long intervalo = 300;

WiFiClient wifiClient;
PubSubClient client(wifiClient);

void setup() {
    // Conexion serial
    // Serial.begin(115200);

    // SENSOR Binario
    pinMode(SENSOR_pin, INPUT);
    attachInterrupt(digitalPinToInterrupt(SENSOR_pin),SensorActivado,CHANGE);
    
    // ACTUADOR Binario
    pinMode(ACTUADOR_pin, OUTPUT);
    digitalWrite(ACTUADOR_pin, HIGH);
    ACTUADORactivaestado();
    
    // LED monitor
    pinMode(LED_pin, OUTPUT);
    LEDactivaestado();
    
    // conexión WIFI y MQTT
    inicia_wifi();
    inicia_mqtt();
}

void loop() {
    if(WiFi.status() != WL_CONNECTED){
        inicia_wifi();
        }
    if (!client.connected()){
        inicia_mqtt();
        }
    client.loop();
    if (SENSOR_bandera){
        SENSOR_estado = digitalRead(SENSOR_pin);
        
        // Serial.println("Actualiza LED");
        LEDactivaestado();
        ACTUADORactivaestado();
        
        // actualiza estado del Sensor en MQTT
        if (SENSOR_estado){
            snprintf (MQTT_SENSOR_STATE,10, SENSOR_ON);
        }else{
            snprintf (MQTT_SENSOR_STATE,10, SENSOR_OFF);
        }
        // Serial.print("Sensor, estado: ");
        // Serial.println(MQTT_SENSOR_STATE);
        
        client.publish(MQTT_SENSOR_TOPIC,MQTT_SENSOR_STATE);
        client.subscribe(MQTT_SENSOR_COMMAND_TOPIC);

        SENSOR_bandera=false;
    }
    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);
            }
        }
    }
    client.publish(MQTT_SENSOR_TOPIC, MQTT_SENSOR_STATE);
    client.subscribe(MQTT_SENSOR_COMMAND_TOPIC);
}

// 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]);
        }
    // 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();
                ACTUADORactivaestado();
                SENSORpublicaestado();
                }
        } else if (payload.equals(String(SENSOR_OFF))) {
            if (SENSOR_estado != false) {
                SENSOR_estado = false;
                LEDactivaestado();
                ACTUADORactivaestado();
                SENSORpublicaestado();
                }
        }
    }
}

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

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

2.2 Actuador Tomacorriente: Esquemático ESP01

1. Esquemático con ESP01

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

1.1 Actuador

Para controlar el estado de un tomacorriente y la carga conectada se usa un relé.

La capacidad de carga del relé determina la capacidad de carga en Amperios del dispositivo, para el prototipo se usa el más básico de los relés controlados por 5 VDC y contactor a 110VAC nominalmente a 10A. No se usará la capacidad máxima del relé.

Para la operación del Relé se usa un optoacoplador que permite acoplar la salida digital del ESP8266 con la corriente demandada por la operación del Relé de aproximadamente 10mA.

El relé se activa con una señal de control de 5VDC que es diferente al voltaje de operación del controlador de 3.3VDC. La diferencia de voltajes se maneja por medio de un optoacoplador como una simplificación para separar los circuitos. Dado que la corriente del optoacoplador disponible no es suficiente para manejar el relé, se usa un Transistor NPN para impulsar la bobina del relé.

El relé tiene dos salidas en estado normalmente cerrado (NC)y la otra normalmente abierto (NO). La alimentación de estas salidas se realiza por medio de la línea de alimentación, por lo que éste dispositivo tienen un conector de 3 entradas para cada actuador. Seleccione la salida que sea de interés para el control del aparato (COSA) con el dispositivo.

1.2 Controlador

Centrado en ESP8266-01 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-01.

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.2.1 Modo Ejecución

La operación predeterminada es «Ejecutar Programa» por medio de R3 hacia estado ALTO (pullup HIGH) y un jumper entre los Pines Sensor-RX. El Jumper conecta el Pin RXD a la entrada del sensor magnético.

Para tomar la lectura de estado del sensor, se usa el pin RX configurado como entrada y estado predeterminado en ALTO con R5. El capacitor C2 se usa para minimizar las señales de rebote que se presentan en los interruptores.

1.2.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 al quitar el jumper de ejecución entre los Pines Sensor-RX.

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.3 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.

 

Para el desarrollo de la placa se condideró pasar al siguiente dispositivo, al combinar un interruptor con un tomacorriente que requieren un sensor y un actuador para trabajar en conjunto.

3.3 Interruptor-Tomacorriente: Archivo.ino

1. Instrucciones en Arduino IDE

Como la versión del ESP8266-01 no dispone de muchos pines de trabajo, se define el uso de los pines como:

  • monitor de operación del dispositivo: LED interno, GPIO1 (TXD)
  • lectura de sensor en GPIO3, pin 7, mismo que es configurado como RXD en modo PROG.
  • control Actuador en GPIO2, pin 3, que es usado para la modo de operación al iniciar el dispositivo. Luego de iniciado se lo puede reconfigurar.

Por el uso en operación de los pines de comunicación Serial (GPIO1 y GPIO3) se descartan las lineas Serial.print() convirtiendolas en comentarios //.

El diseño realizado permite conectar un módulo USB-TTL a la placa PCB. Revise la configuración de las botoneras Reset, PROG y los Jumpers para realizar la carga del archivo.ino. Si la subida del archivo.ino al módulo ESP01  se realiza fuera de la placa PCB revise nuevamente la configuración de PCB para que trabaje en modo «Ejecutar» luego de insertar el módulo ESP01.

2. Funciones repetitivas

Para las acciones repetitivas como la conexión a WIFI y comunicación por MQTT se realizan en funciones para simplificar las instrucciones en la configuración inicial (setup) y la ejecución principal (loop).

Al inicio se definen las librerías y los valores para la conexión WIFI y los datos para comunicarse con el servidor MQTT-Mosquitto implementado en el Raspberry. Revisar de ser necesario al sección Broker.

2.1 función para actuador

Para procesar las instrucciones enviadas por el Broker en MQTT se añade la función callback().

Para el control del Relé se usa la función ACTUADORactivaestado() que realiza acciones semejantes a la de activar el monitor LED, y permite en futuro mantener separadas las acciones sobre el ACTUADOR o Relé.

2.2 Función para sensor

Para monitorear sensor se utiliza interrupciones para sensar cambios de estado. Por el control de rebotes, se considera los intervalos entre cambios implementado en la función SensorActivado(). De confirmarse el cambio se pasa a publicar el estado en el broker MQTT con SENSORpublicaestado()

/*
 TOMACORRIENTE E INTERRUPTOR | AC outlet and wall switch
 Basic ESP8266 MQTT example with the ESP8266 board/library.
 Actuador/Sensor Binario, para control de estado de una Luz.
 Para usar, se debe actualizar las secciones de:
 - WIFI datos para conexión a Router
 - MQTT: Servidor MQTT 
 - MQTT: identificador de dispositivo y topics
 Al usar ESP8266-01 se toman los pines TX para LED y RX para el sensor, GPI02 actuador
 por lo que se no se usa Serial.print(), con mesajes usado para depuración.
*/

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

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

// MQTT: Servidor MQTT 
const PROGMEM char* MQTT_SERVER_IP = "192.168.x.x";
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 = "luz1";
const PROGMEM char* MQTT_SENSOR_TOPIC = "oficina/luz1/contact";
const PROGMEM char* MQTT_SENSOR_COMMAND_TOPIC = "oficina/luz1/switch";
const PROGMEM char* SENSOR_ON  = "ON";
const PROGMEM char* SENSOR_OFF = "OFF";
char MQTT_SENSOR_STATE[10] = "OFF"; // inicializa

// Sensor Switch Luz
const PROGMEM uint8_t SENSOR_pin = 3;
volatile boolean SENSOR_estado = false;
volatile boolean SENSOR_bandera = false;

// Actuador Switch Luz
const PROGMEM uint8_t ACTUADOR_pin = 2;

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

// Control de tiempos
unsigned long antes = 0; 
const long intervalo = 300;

WiFiClient wifiClient;
PubSubClient client(wifiClient);

void setup() {
    // Conexion serial
    // Serial.begin(115200);

    // SENSOR Binario
    pinMode(SENSOR_pin, INPUT);
    attachInterrupt(digitalPinToInterrupt(SENSOR_pin),SensorActivado,CHANGE);
    
    // ACTUADOR Binario
    pinMode(ACTUADOR_pin, OUTPUT);
    digitalWrite(ACTUADOR_pin, HIGH);
    ACTUADORactivaestado();
    
    // LED monitor
    pinMode(LED_pin, OUTPUT);
    LEDactivaestado();
    
    // conexión WIFI y MQTT
    inicia_wifi();
    inicia_mqtt();
}

void loop() {
    if(WiFi.status() != WL_CONNECTED){
        inicia_wifi();
        }
    if (!client.connected()){
        inicia_mqtt();
        }
    client.loop();
    if (SENSOR_bandera){
        SENSOR_estado = digitalRead(SENSOR_pin);
        
        // Serial.println("Actualiza LED");
        LEDactivaestado();
        ACTUADORactivaestado();
        
        // actualiza estado del Sensor en MQTT
        if (SENSOR_estado){
            snprintf (MQTT_SENSOR_STATE,10, SENSOR_ON);
        }else{
            snprintf (MQTT_SENSOR_STATE,10, SENSOR_OFF);
        }
        // Serial.print("Sensor, estado: ");
        // Serial.println(MQTT_SENSOR_STATE);
        
        client.publish(MQTT_SENSOR_TOPIC,MQTT_SENSOR_STATE);
        client.subscribe(MQTT_SENSOR_COMMAND_TOPIC);

        SENSOR_bandera=false;
    }
    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);
            }
        }
    }
    client.publish(MQTT_SENSOR_TOPIC, MQTT_SENSOR_STATE);
    client.subscribe(MQTT_SENSOR_COMMAND_TOPIC);
}

// 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]);
        }
    // 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();
                ACTUADORactivaestado();
                SENSORpublicaestado();
                }
        } else if (payload.equals(String(SENSOR_OFF))) {
            if (SENSOR_estado != false) {
                SENSOR_estado = false;
                LEDactivaestado();
                ACTUADORactivaestado();
                SENSORpublicaestado();
                }
        }
    }
}

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

// establece estado LED monitor en ESP8266
void LEDactivaestado(){
    if (SENSOR_estado){
        // LED interno enciende en LOW
        digitalWrite(LED_pin, LOW);
    }else{
        digitalWrite(LED_pin, HIGH);
    }
}
// establece estado LED monitor en ESP8266
void ACTUADORactivaestado(){
    if (SENSOR_estado){
        // ACTURADOR ACTIVA EN LOW
        digitalWrite(ACTUADOR_pin, LOW);
    }else{
        digitalWrite(ACTUADOR_pin, HIGH);
    }
}

// ISR interrupción activada
void SensorActivado(){
    // Serial.println("ISR activada");
    unsigned long ahora = millis();
    if((ahora - antes)> intervalo) {
        antes = ahora;
        SENSOR_bandera = true;
    }
}

 

3.2 Interruptor-Tomacorriente: Esquemático ESP01

1. Esquemático con ESP01

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

1.1 Sensor

El sensor es un interruptor eléctrico de pared ensamblado en conjunto con un tomacorriente controlado por el actuador.

Se puede sensar el estado de encendido o apagado, o los cambios de estado de subida (0 a 1) o bajada (1 a 0).

El interruptor se usa como sensor, por lo que no va conectado a la energía AC.

Considere cambiar a un pulsador que podría resultar más económico, pero habría que adaptarlo al conjunto de caja y tapa eléctrica usada.

1.2 Actuador

Para controlar el estado de un tomacorriente y la carga conectada se usa un relé. El actuador es muy semejante a lo usado en el dispositivo de solo tomacorriente.

La capacidad de carga del relé determina la capacidad de carga en Amperios del dispositivo, para el prototipo se usa el más básico de los relés controlados por 5 VDC y contactor a 110VAC nominalmente a 10A. No se usará la capacidad máxima del relé.

Para la operación del Relé se usa un optoacoplador que permite acoplar la salida digital del ESP8266 con la corriente demandada por la operación del Relé de aproximadamente 10mA.

El optoacoplador opera un transistor que controla la corriente que activa el Relé. La configuración permite acoplar otros Relés con otros voltajes de operación usados para aplicaciones de mayor carga, incluso con fuentes de alimentación se mayor voltaje y separadas del circuito.

1.2 Controlador

Centrado en ESP8266-01 se requiere un conector para el sensor y otro para el actuador.

El pin para el sensor es RXD que también se usó con el sensor magnético de puerta -ventana.

El pin para el actuador, dado que es configurado como salida de alta impedancia se usa el GIPO2.   El diseño considera mantener GPIO2 en  el estado ALTO al inicio del dispositivo, luego en las instrucciones de configuración se establece en modo de salida (output).

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-01.

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.2.1 Modo Ejecución

La operación predeterminada es «Ejecutar Programa» por medio de R3 hacia estado ALTO (pullup HIGH) y un jumper entre los Pines Sensor-RX. El Jumper conecta el Pin RXD a la entrada del sensor magnético.

Para tomar la lectura de estado del sensor, se usa el pin RX configurado como entrada y estado predeterminado en ALTO con R5. El capacitor C2 se usa para minimizar las señales de rebote que se presentan en los interruptores.

1.2.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 al quitar el jumper de ejecución entre los Pines Sensor-RX.

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.3 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.


2. Ensamble en Protoboard

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

Considere que solo por Esquema se incluye la parte de conexión AC, que se debe realizar separada y tomando las precauciones de aislamiento que correspondan.


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-.

Para el archivo de producción de placa, escribir al email de contacto al final de la página.

Alternativas durante el proceso de desarrollo

Durante el desarrollo del prototipo se usó placas perforadas de circuito impreso de 4×7 cm.

Luego de algunas pruebas, se dispondrá del diseño mejorado y se actualizará la versión 2 del circuito impreso.