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

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

/* ESP8266 Interruptor AC. edelros@espol.edu.ec
 *  Sensor-Actuador Binario, control de un Relay con Tomacorriente o foco.
 *  Para usar, actualice las secciones de:
 *  - WIFI:Router, MQTT:Servidor, MQTT:Dispositivo
 *  ESP-01 al usar GPIO1 y GPIO3,(Tx,Rx), NO USE Serial.print()
*/
#include <ESP8266WiFi.h>
#include <PubSubClient.h>

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

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

// MQTT: Dispositivo Interruptor
char* MQTT_ID = "oficina_luz1";
char* MQTT_TOPIC = "oficina/luz1/estado";
char* MQTT_COMMAND = "oficina/luz1/cambia";
char MQTT_SensorEstado[10] = "OFF";
char MQTT_ActuadorEstado[10] = "OFF";
volatile boolean mqtt_desconectado = true;

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

// Actuador Tomacorriente-Luz
const uint8_t actuador_pin = 3;
volatile boolean actuador_estado = false;
volatile boolean actuador_bandera = true;

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

// Clientes WiFi y MQTT
WiFiClient wifiClient;
PubSubClient mqttclient(wifiClient);

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

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

void loop() {
  // Revisa cambios en interruptor
  if (actuador_bandera){
    ACTUADORactivaestado();
    if (mqttclient.connected()){
      publica_estado();
      }
    actuador_bandera = false;
    }
  yield(); // procesa wifi
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi();
    }else{
      if (!mqttclient.connected()){
        mqtt_desconectado = true;
        inicia_mqtt();
      }else{
        mqttclient.loop();
        if (mqtt_desconectado==true){
          publica_estado();
          mqtt_desconectado==false;
          }
        }
    }
    yield(); // procesa wifi
}

// Actuador activar estado
void ACTUADORactivaestado(){
  if (actuador_estado){
      // ACTUADOR ACTIVA EN LOW
      // LED actuador ilumina en apagado
      digitalWrite(actuador_pin, LOW);
      digitalWrite(LED_actuador, HIGH);
    }else{
      digitalWrite(actuador_pin, HIGH);
      digitalWrite(LED_actuador, LOW);
    }
}

// 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);
}

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

void inicia_mqtt(){
  int intentos = 4;
  int cuenta = 0;
  mqttclient.setServer(MQTT_IP, MQTT_puerto);
  mqttclient.connect(MQTT_ID, MQTT_usuario, MQTT_contrasena);
  mqttclient.setCallback(callback);
  
  while (!mqttclient.connected() && (cuenta<=intentos)) {
    cuenta = cuenta + 1;
    // Parpadeo de Monitor enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(600);
    digitalWrite(LED_pin, HIGH);
    delay(400);
    }
  if (mqttclient.connected()){
      publica_estado();
  }
  }

// llega mensaje MQTT
void callback(char* p_topic, byte* p_payload, unsigned int p_length) {
  // convierte a texto
  String payload;
  for (uint8_t i = 0; i < p_length; i++) {
    payload.concat((char)p_payload[i]);
    }
  // revisa mensaje por topico
  if (String(MQTT_COMMAND).equals(p_topic)) {
    if (payload.equals(String(sensor_ON))) {
      if (actuador_estado != true) {
        actuador_estado = true;
        }
      }
    if (payload.equals(String(sensor_OFF))) {
      if (actuador_estado != false) {
          actuador_estado = false;
        }
      }
    actuador_bandera = true;
    }
  }

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

El pin para el actuador es GPIO3, RXD, que también se usó con el sensor magnético de puerta -ventana, configurado como salida (OUTPUT).

Se usa un LED monitor para el estado del interruptor/actuador en GPIO2 y un LED monitor para mostrar el estado durante conexión a la red en GIPO0. El diseño considera mantener GPIO0 y GPIO2 en el estado ALTO al inicio del dispositivo, luego establecer el modo de salida (OUTPUT, INPUT) en las instrucciones de configuración (setup()).

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.

La placa del circuito permite solo el estado de operación del ESP-01, la programación del módulo ESP-01 se debe realizar fuera del tablero. Revise la opción de programar con la «Conexión USB-TTL».

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.

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. Circuito impreso – PCB

3.1 PCB de 4.5x4.5cm. Ocupa el menor espacio posible considerando el tamaño de los componentes.

3.2 Placa de 5x7. Usa el espacio y partes distribuidas considerando el tamaño de las placas perforadas para realizar prototipos. Es la versión simplificada del prototipo de interruptor que controla un tomacorriente o foco.