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 boton config_IR, una vez presionado espera hasta recibir una señal infraroja que se lee, y graba.
  • el Envío de la señal se realiza con la instrucción MQTT o  desde Home Assistant
  • Usa el LED_LeeIR  como indicador de estado de lectura o activación de 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
/* ESP8266 IRremoteESP8266: Receptor Infrarojo
 * edelros@espol.edu.ec
 * Debe usar un sensor detector/demodulador conectado al Receptor_Pin.
 *   Based on Mark Szabo's Version 0.2 June, 2017 and
 *   Ken Shirriff's IrsendDemo Version 0.1 July, 2009
 *   https://github.com/markszabo/IRremoteESP8266 
*  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>

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

#include <EEPROM.h>

#include <DHT.h>

// WIFI: conexión a Router
char* ssid = "giotirni20";
char* password = "Anera2020@";

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

// MQTT: Dispositivo Interruptor
char* MQTT_ID = "oficina_CtrlIR01";
char* MQTT_TOPIC = "oficina/CtrlIR01/estado";
char* MQTT_COMMAND = "oficina/CtrlIR01/cambia";

char* MQTT_TOPIC_T = "oficina/CtrlIR01/temperatura";
char* MQTT_TOPIC_H = "oficina/CtrlIR01/humedad";
char* MQTT_COMMAND_DHT = "oficina/CtrlIR01/actualiza";

char* MQTT_TOPIC_LeeIR = "oficina/CtrlIR01/leer";
char* MQTT_COMMAND_LeeIR = "oficina/CtrlIR01/grabar";

char MQTT_SensorEstado[10] = "OFF";
char MQTT_ActuadorEstado[10] = "OFF";
char MQTT_DHT_T[6] = "25"; // inicializa
char MQTT_DHT_H[6] = "50"; // inicializa
char MQTT_LeeIR[6] = "0"; // inicializa
volatile boolean mqtt_desconectado = true;

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

// Actuador Control Remoto Emisor LED-IR en GPIO14
const uint8_t emisorIR_pin = 14;
uint32_t senal_ONOFF = 0xFF5AA5; // código de control
volatile boolean actuador_estado = false;
volatile boolean actuador_bandera = false;

// Sensor IR en GPIO05
const uint8_t receptorIR_pin = 5;
volatile boolean LeerIR_estado = false;
volatile boolean LeerIR_bandera = false;

// Boton de lectura y emitir IR
const uint8_t config_pin = 12;
const uint8_t emitir_pin = 0;

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

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

// Control de tiempo transcurrido entre lecturas temperatura
unsigned long ahora = millis();
const long intervalo = 5*60*1000;//minutos*60s*1000ms
unsigned long antes = ahora-intervalo-1; //leer al inicio

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

// Receptor y Emisor Infrarojos
IRrecv irrecv(receptorIR_pin);
decode_results lecturaIR;
IRsend irsend(emisorIR_pin);

// Sensor de Temperatura&Humedad
#define DHTPIN 4
#define DHTTYPE   DHT11
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(74880);//74880, 115200
  while (!Serial){delay(50);}
  
  // SENSOR IR // inicia receptor IR
  irrecv.enableIRIn(); 
  pinMode(LED_LeerIR, OUTPUT);
  Leer_Activaestado();
    
  // ACTUADOR IR // inicia emisor IR
  pinMode(emisorIR_pin, OUTPUT); 
  irsend.begin();

  // SENSOR Temperatura&Humedad
  dht.begin();
  
  // LED monitor, Enciende en LOW
  pinMode(LED_pin, OUTPUT);

  // Memoria lectura y escritura
  EEPROM.begin(64); //eeprom maximo 512 posiciones
  codigo_leermem();

  // Boton de lectura de código IR
  pinMode(config_pin, INPUT);
  attachInterrupt(digitalPinToInterrupt(config_pin),LeerActivado,CHANGE);

  // Boton de Emisor de código IR
  pinMode(emitir_pin, INPUT);
  attachInterrupt(digitalPinToInterrupt(emitir_pin),IR_Activado,CHANGE);
  
  // conexión WIFI y MQTT
  inicia_wifi();
  if (WiFi.status() == WL_CONNECTED){
    inicia_mqtt();
    }
  }

void loop() {
  // enviar señal IR
  if (actuador_bandera){
    irsend.sendNEC(senal_ONOFF ,32);
    // parpadeo
    digitalWrite(LED_LeerIR, LOW);
    delay(300);
    digitalWrite(LED_LeerIR, HIGH);
    delay(200);
    digitalWrite(LED_LeerIR, LOW);
    delay(300);
    digitalWrite(LED_LeerIR, HIGH);
    delay(200);
    // deja en estado anterior el LED Leer_IR
    Leer_Activaestado();
    publica_estado();
    actuador_bandera = false;
    
    if (serial_msg==true){
      Serial.print("\n Señal IR enviada: ");
      serialPrintUint64(senal_ONOFF, HEX);
      Serial.println("");
      }

    }
  yield(); // procesa wifi

  // Sensor IR, leer código
  if(LeerIR_bandera){
    if (irrecv.decode(&lecturaIR)) {
      // conversión a texto
      uint64_t numero = lecturaIR.value;
      unsigned long parte1 = (unsigned long)((numero & 0xFFFF0000) >> 16 );
      unsigned long parte2 = (unsigned long)((numero & 0x0000FFFF));
      String texto = String(parte1, HEX) + String(parte2, HEX);
      texto.toUpperCase();
      senal_ONOFF = lecturaIR.value;
      
      // Escribe a memoria EEPROM    
      // escribe a eeprom
      texto = texto+";"; //marca fin de texto
      int n = texto.length();
      int posicion = 0;
      int i = posicion;
      while(i<n){
        EEPROM.write(i,texto[i]);
        i=i+1;
        }
      EEPROM.commit();
      irrecv.resume();
       
      LeerIR_bandera = false;
      LeerIR_estado = false;

      publica_estado();
      Leer_Activaestado();
      
      if (serial_msg==true){
        Serial.print("\n lecturaIR:       ");
        // print() & println() no maneja enteros largos(uint64_t)
        serialPrintUint64(lecturaIR.value, HEX);
        Serial.println("");
        Serial.print(" grabado en memoria:   ");
        Serial.println(texto);
        }
    }
  }

  yield(); // procesa wifi
  
  // lectura Temperatura,Humedad
  unsigned long ahora = millis();
  unsigned long transcurre = ahora-antes;
  if (transcurre>=intervalo){
    antes = ahora;
    delay(50);
    // calibrar con una referencia más precisa
    // modo simple: resta factor de corrección=5
    float temperatura = dht.readTemperature();
    float humedad = dht.readHumidity();
    // convierte a texto mqtt; a 4 dígitos, 2 decimales
    dtostrf(temperatura, 4, 2, MQTT_DHT_T);  
    dtostrf(humedad, 4, 2, MQTT_DHT_H);
    publica_estado();
    
    if (serial_msg==true){
      Serial.print("\n tiempo: ");
      Serial.println(transcurre);
      Serial.print(" Temperatura,Humedad: ");
      Serial.print(MQTT_DHT_T);
      Serial.print(" , ");
      Serial.println(MQTT_DHT_H);
      Serial.println();
      }
    }
    
  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
}

void codigo_leermem(){
  // lectura desde eeprom, codigo on/off
  int posicion = 0;
  int n = posicion+10;
  String codigotxt = "";
  char simbolo;
  int i = posicion;
  while(i<n){
    simbolo = char(EEPROM.read(i));
    if (simbolo!=';'){
      codigotxt = codigotxt+String(simbolo);
      }else{
        i=n; // terminar lectura antes
      }
    i=i+1;
    }
  // conversión de codigotxt a HEX
  char codigochar[64];
  codigotxt.toCharArray(codigochar, n);
  uint32_t codigoIRhex = strtoul(codigochar, 0, 16);
  // actualiza variable
  senal_ONOFF = codigoIRhex;
  if (serial_msg==true){
    Serial.print("texto leido:     ");
    Serial.println(codigotxt);
    Serial.print("codigo IR eprom: ");
    // print() & println() no maneja enteros largos(uint64_t)
    serialPrintUint64(senal_ONOFF, HEX);
    Serial.println("\n");
    }
  }

// ISR interrupción activada
ICACHE_RAM_ATTR void LeerActivado(){
  // evita repeticiones por rebotes del botonera
  if (LeerIR_bandera==false){
    LeerIR_bandera = true;
    LeerIR_estado = true;
    Leer_Activaestado();
    publica_estado();
    if (serial_msg){
      Serial.println(" Leer IR activado...");
      }
    }
  }
ICACHE_RAM_ATTR void IR_Activado(){
  // evita repeticionese por rebotes del botonera
  if (actuador_bandera ==false){
    actuador_bandera = true;
    if (actuador_estado == true) {
      actuador_estado = false;
      }else{
      actuador_estado = true;
      }
    publica_estado();
    if (serial_msg){
      Serial.println(" IR_envío activado...");
      }
    }
  }

// Actuador activar estado
void Leer_Activaestado(){
    if (LeerIR_estado){
      // ACTUADOR ACTIVA EN LOW
      // LED actuador ilumina en apagado
      digitalWrite(LED_LeerIR, LOW);
    }else{
      digitalWrite(LED_LeerIR, HIGH);
    }
  }

// 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 (LeerIR_estado){
      snprintf (MQTT_LeeIR,10, sensor_ON);
    }else{
      snprintf (MQTT_LeeIR,10, sensor_OFF);
    }
    if (mqttclient.connected()==true){
      mqttclient.publish(MQTT_TOPIC,MQTT_ActuadorEstado,true);
      mqttclient.publish(MQTT_TOPIC_LeeIR,MQTT_LeeIR,true);
      mqttclient.publish(MQTT_TOPIC_T,MQTT_DHT_T,true);
      mqttclient.publish(MQTT_TOPIC_H,MQTT_DHT_H,true);
    }else{
      mqtt_desconectado = true;
    }
}

void inicia_wifi(){
  int intentos = 10;
  int cuenta = 0;

  if (serial_msg){
    Serial.print(" WIFI Conectando a ");
    Serial.println(ssid);
    }
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  
  while ((WiFi.status() != WL_CONNECTED) && (cuenta<intentos)){
    if (serial_msg){
      Serial.print(".");
      }
    cuenta = cuenta+1;
    // Parpadeo de Monitor enciende en LOW
    digitalWrite(LED_pin, LOW);
    delay(300);
    digitalWrite(LED_pin, HIGH);
    delay(200);
    }
  if (serial_msg){
    //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();
      }
    }
  }

void inicia_mqtt(){
  int intentos = 2;
  int cuenta = 0;
  
  if (serial_msg){
    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 (serial_msg){
      Serial.print(".");
    }
    
    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);
  mqttclient.subscribe(MQTT_COMMAND_LeeIR);
  mqttclient.subscribe(MQTT_COMMAND_DHT);
  
  if (serial_msg){
    //Fin de "..."
    Serial.println();
    Serial.print(" MQTT Conectado: ");
    Serial.println(mqttclient.connected());
    Serial.print(" MQTT Estado: ");
    Serial.println(mqttclient.state());
    }
  }

// 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;
        }
      }
    Leer_Activaestado();
    publica_estado();
    actuador_bandera = true;
    }

  if (String(MQTT_COMMAND_LeeIR).equals(p_topic)) {
    if (payload.equals(String(sensor_ON))) {
      if (LeerIR_estado != true) {
        LeerIR_estado = true;
        }
      }
    if (payload.equals(String(sensor_OFF))) {
      if (LeerIR_estado != false) {
          LeerIR_estado = false;
        }
      }
    LeerIR_bandera = true;
    Leer_Activaestado();
    publica_estado();
    }
  if (String(MQTT_COMMAND_DHT).equals(p_topic)) {
    antes = antes-(intervalo+2);
    }
  }

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

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.

5.4 Control Remoto IR: MQTT-HA

1. Incorporar el dispositivo en Home Assistant

Actualizar el archivo de configuration.yaml:

/homeassistant/.homeassistant/configuration.yaml

Se modifica el archivo de configuración, añadiendo los datos del sensor en el servidor MQTT y se actualiza  la página de gestión luego de reiniciar el programa. (configuration, restart)

switch:
  - platform: mqtt
    name: 'oficina_ctrlIR01'
    state_topic: 'oficina/CtrlIR01/estado'
    command_topic: 'oficina/CtrlIR01/cambia'
    optimistic: false

  - platform: mqtt
    name: 'oficina_ctrlIRlee'
    state_topic: 'oficina/CtrlIR01/leer'
    command_topic: 'oficina/CtrlIR01/grabar'
    optimistic: false

  - platform: mqtt
    name: 'oficina_LeeTemperatura01'
    command_topic: 'oficina/CtrlIR01/actualiza'
    optimistic: false

sensor:
  - platform: mqtt
    name: 'oficina_temperatura1'
    unit_of_measurement: '°C'
    state_topic: 'oficina/CtrlIR01/temperatura'

  - platform: mqtt
    name: 'oficina_humedad1'
    unit_of_measurement: '%'
    state_topic: 'oficina/CtrlIR01/humedad'

además de lo necesario para incorporar la parte del sensor de temperatura y humedad.

Como resultado, se puede visualizar los valores de temperatura y humedad ene la parte superior de la ventana de Home Assistant.

La sección de interruptores tiene el orden de:

1. Emitir la señal IR
2. Activar estado para leer un código IR
3. Tomar una lectura de temperatura fuera del intervalo regular\

El interevalo regular para sensar los valores de temperatura está configurado cada 5 min o más en la sección archivo.ino

5.1 Sensor Actuador: Control Remoto IR

Presentación

Se busca disponer de un dispositivo que permita controlar el encendido o apagado de aparato (cosa) que usa control remoto, por ejemplo: un acondicionador de aire. El dispositivo ese un control remoto alterno al tradicional.

Como meta se propone realiza una acción: encendido y apagado, para luego extendera a otras realizadas por otros botones del control remoto.

Para el encendido remoto del acondicionador de aire es conveniente conocer la temperatura de la habitación como factor para decidir encender el aparato. Por lo que se considera necesario incorporar un sensor de temperatura al dispositivo, combinando funciones de otros dispositivos ya desarrollados.

Premisas para desarrrollo en la versión 1

  • Independencia del equipo acondicionador de aire, no invasivo en los circuitos del aparato
  • Reconocimiento o lectura del código de encendido/apagado desde el control remoto IR del equipo, para así soportar diferentes marcas de control remoto
  • Monitoreo remoto del estado del medio ambiente, temperatura, como factor de estado antes de encender/apagar

otras premisas planteadas para todos los dispositivos:

  • Diseño de dispositivos con conexión inalámbrica WIFI
  • Conoce los datos para conexión a la red a WIFI y broker MQTT
  • 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.

El desarrollo se realiza a partir de los ejemplos:

ESP07 IR detector/demodulador

ESP07 IR Emisor

4. Sensor Temperatura/Humedad ESP-01

implementación versión 1

Por la necesidad de usar más entradas/salidas de control se usó el módulo ESP07, que en el manual indica pines dedicados para sensores y actuadores infrarojos. El pin 5 se usa para emisor y el 14 para receptor. Sección 4.4.Interfaces, página 12.

El encendido del LED infrarojo se realiza por medio de un transistor para manejar más corriente que la salida del ESP8266

La configuración en el broker para activar la señal LED y Receptor infrarojo se establece como un switch. Revisar la sección correspondiente en el broker.

Se realizaron pruebas con un acondicionador de aire marca genérica (ECOX), también con un TV Sony; ambas para encendido y apagado.

Temas para desarrollo posterior

  • Aumentar la cantidad de botones/actividades que se puedan manejar
  • Incorporar la configuración de red mediante SmartConfig.

Referencias 

ESP8266-ESP07. https://www.mikrocontroller.net/attachment/338570/Ai-thinker_ESP-07_WIFI_Module-EN.pdf