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.

 

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:

  • Lectura del sensor interruptor en GPIO1, que también es TXD configurado (setup) como entrada (INPUT).
  • Control actuador con relay en GPIO3,  que también es RXD configurado en modo de salida (OUTPUT).
  • Monitor de operación del dispositivo: LED actuador GPIO2
  • Monitor de conexión a la red: LED conexión GPIO0

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

Si la subida del archivo.ino al módulo ESP01  se realiza fuera de la placa PCB.
Si el diseño realizado permite conectar un módulo USB-TTL a la placa PCB. Revise la configuración de las botoneras Reset, PROG o DIP-switch para realizar la carga del archivo.ino.

2. Funciones repetitivas

La conexión a WIFI y comunicación por MQTT  al ser repetitivas entre algoritmos se separan en funciones,  simplificando la configuración inicial (setup) y el bloque 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 la sección «Broker».

2.1 función para actuador

Para procesar las instrucciones enviadas por el broker MQTT se dispne de la función callback().

Para el control del Relé se usa la función ACTUADORactivaestado().

2.2 Función para sensor

Para monitorear sensor se usa una interrupción 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()


/* 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 = "xxxx";
char* password = "xxxx";

// MQTT: Servidor
char* MQTT_IP = "192.168.xx.xx";
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;

// Sensor Interruptor
const uint8_t sensor_pin = 1;
volatile boolean sensor_estado = false;
volatile boolean sensor_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() {
  // SENSOR Interruptor
  pinMode(sensor_pin, INPUT);
  attachInterrupt(digitalPinToInterrupt(sensor_pin),sensorActivado,CHANGE);
  
  // 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 (sensor_bandera){
      delay(10);
      sensor_estado = digitalRead(sensor_pin);
    if (sensor_estado==LOW){
      actuador_estado = true;
      }
    if (sensor_estado ==HIGH){
      actuador_estado = false;
      }
    ACTUADORactivaestado();
    publica_estado();
    sensor_bandera = false;
    }
  yield(); // procesa wifi
  
  if (WiFi.status() != WL_CONNECTED){
    inicia_wifi();
    }else{
    if (mqttclient.connected()==false){
        mqtt_desconectado = true;
        inicia_mqtt(); // reintento
      }
    if (mqttclient.connected()==true){
      if (mqtt_desconectado==true){
        publica_estado();
        mqtt_desconectado=false;
        }
      mqttclient.loop();
      }
    }
  yield(); // procesa wifi
}

// ISR interrupción activada
ICACHE_RAM_ATTR void sensorActivado(){
  sensor_bandera = true;
  }

// 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);
    }
    if (mqttclient.connected()==true){
      mqttclient.publish(MQTT_TOPIC,MQTT_ActuadorEstado,true);
    }else{
      mqtt_desconectado = true;
    }
}

void inicia_wifi(){
  int intentos = 10;
  int cuenta = 0;
  WiFi.mode(WIFI_STA);
  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(300);
    digitalWrite(LED_pin, HIGH);
    delay(200);
    }
  }

void inicia_mqtt(){
  int intentos = 2;
  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(200);
    digitalWrite(LED_pin, HIGH);
    delay(200);
    }
  publica_estado();
  mqttclient.subscribe(MQTT_COMMAND);
  }

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

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 actuador es GPIO3, RXD, que también se usó con el sensor magnético de puerta -ventana, configurado como salida (OUTPUT).

El pin para el sensor es GIPO1, TXD, configurado como entrada (INPUT).

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

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.

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

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 5×7 cm.

3.4 Interruptor-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» y se complementa con la instrucción de identificación en el formato: lugar/cosa/acción.

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

Se añade la la instrucción de control para el dispositivo (command_topic) también con el formato indicado, «oficina/luz1/cambia».

otra forma de presentación en Home-Assistant. editando las tarjetas por dispositivo (Cards):

 

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

En el caso de control del actuador, se utiliza una intruccion semejante para publicar:

mosquitto_pub -h 192.168.10.100 -t oficina/luz1/cambia -m on

Dispositivo como interuptor

Se aplica el mismo concepto del dispositivo para el caso de un interruptor, no necesariamente de luz. Para el caso de interruptor, hay que observar la capacidad máxima de manejo de corriente del Relay usado, para evitar sobrecargas.

Como ejemplo, se presenta el formato para interruptor en Home-Assistant, lo que requiere también realizar un cambio en el archivo.ino en la sección MQTT. Sin embargo no afecta al resto de las instrucciones.

switch:
  - platform: mqtt
    name: 'oficina_Interruptor1'
    state_topic: 'oficina/switch1/estado'
    command_topic: 'oficina/switch1/cambia'
    optimistic: false


Entre algunas de las cosas que se pueden realiza con un dispositivo tipo binario.

3.1 Sensor-Actuador: Interruptor-Tomacorriente

Presentación

El dispositivo inalámbrico se usa para controlar el estado encendido o apagado (actuador) de un aparato eléctrico AC (lámpara) de baja potencia.

El control se lo puede realizar físicamente al pulsar un interruptor tradicional (sensor) o por medio de una instrucción MQTT.

El sensor de interruptor y el actuador de control AC trabajan en conjunto desde el mismo dispositivo. Éste dispositivo es la integración de los dos dispositivos anteriores: Sensor Puerta-Ventana y Actuador tomacorriente, ambos de estado binario (ON/OFF).

implementación versión 1

La versión 1 mostrada en la imagen se ha instalado en una caja sobrepuesta plástica. Para pruebas, se ha conectado una lámpara al tomacorriente.

El control se realiza tanto por el interruptor como por la página en la computadora, ambos marcados en rojo en la imagen.

La carga máxima AC de control depende del Relé  seleccionado.

Se ha usado una placa perforada para ensamblar el prototipo, sin embargo al final del tema en Placas PCB se presenta el diseño de la placa de circuito.

Premisas para desarrrollo en la versión 1

  • Diseño de dispositivos con conexión inalámbrica WIFI
  • Conoce los datos para conexión a la red a WIFI y broker MQTT
  • Dispone de acceso a un broker MQTT local
  • Dispone de Arduino IDE para cargar las instrucciones en el ESP8266
  • Emplea diseños abiertos tipo: Open Hardware y Open Software
  • Dispone de los componentes en el mercado local
  • Considera componentes alternos a los no disponibles en el mercado local
  • Identifica las etapas de desarrollo e inconvenientes en la implementación

Temas para desarrollo posterior

Incorporar Sensor para medir consumo de energía.

Sensores Analógicos
Ampliar la forma de carga de scripts en el tablero, de forma alámbrica o inalámbrica.

Revisar el uso de los canales WIFI para evitar desconexiones por saturación de canal.