GIRNI

Grupo de Investigación de Redes de iNformación Inalámbricas

Categoría: WiFi-Control Remoto IR

  • WiFi - 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 botón 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);
    }
  }

  • WiFi - Control Remoto IR: Esquemático

    1. WiFi - Control Remoto IR

    Control Remoto IR

    Disponer de un dispositivo que permita controlar el encendido o apagado de un artefacto(cosa) que usa control remoto infrarrojo, por ejemplo: un acondicionador de aire.

    El dispositivo es un control remoto alterno al tradicional que viene con el equipo acondicionador de aire.

    Como meta se propone realiza  la acción de: encendido y apagado, para luego extenderla 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 un factor a considerar para encender el aparato. El valor de temperatura se obtiene al incorporar un sensor de temperatura, tomando como base el dispositivo desarrollado en la sección

    WiFi - Temperatura y Humedad: Esquemático

    Premisas para desarrollo 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
    • Dispone de 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.

    implementación versión 1

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

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

    En el broker Home-Assistant, la configuración de acción para la activación de la señal LED y Receptor infrarrojo se establece con  un "switch" (ver figura) al inicio. Para los detalles, revise la sección correspondiente a MQTT-HA para el broker.

    Las pruebas del dispositivo se hicieron con un acondicionador de aire marca genérica (ECOX), también con un TV (Sony), comprobando que se pueda replicar las señales de cada control remoto del artefacto. Las señales replicadas fueron de 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 

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

    2. Esquemático con ESP01

    El esquemático se divide en las secciones para el controlador, sensores y actuadores y fuente de alimentación.

    El diseño para sensores y actuadores agrupa partes de ejercicios previos individuales para  Receptor, Emisor infrarrojo y sensor de temperatura/humedad, por lo que tenemos un diseño sumativo de experiencias previas.

    2.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 infrarrojo con detección y demodulación simplifica el circuito a un pin digital configurado como entrada en el módulo de control a usar, además de alimentación de energía Vcc y Gnd.

    En un control remoto IR convencional, cuando se presiona una tecla de control, se genera un código único que es detectado y copiado en el dispositivo con el sensor.

    La temperatura y humedad es información complementaria para operar un acondicionador de aire, por lo que se añade otro sensor al dispositivo para sensar temperatura y Humedad.

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

    2.2 Actuador

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

    Considere que algunos LEDs infrarrojos son también vienen con empaquetado transparente. La operación del LED se puede comprobar al conectarlo como un LED normal y observarlo con la cámara de un teléfono móvil donde se observa la luminocidad.

    2.3 Controlador

    Se desarrolla centrado en ESP8266 modelo ESP-07 que incluye pines acondicionados para sensores infrarrojo. La activación del módulo se realiza de acuerdo a lo descrito en el manual del módulo, también descrita en la sección «Módulos» ESP8266 versión ESP-07.

    En el esquema se observa que el reinicio del dispositivo se controla con la botonera «Reset» que cambia el pin a estado BAJO (GND); el estado predeterminado es ALTO por medio de R1 y C1 minimiza los rebotes del pulsador.

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

    2.3.2 Modo Cargar Programa

    Para «Cargar Programa» también se usa una botonera etiquetada como «PROG» hacia estado BAJO (GND), el programa se transfiere con un módulo USB-TTL al computador desde el Arduino IDE. Los módulos ESP-07 y USB-TTL se conectan mediante 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. Para minimizar los rebotes del pulsador, Reset se conecta con R1 hacia estado predeterminado ALTO y se complementa con C1 .

    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.

    2.4 Fuente DC

    Se conforma con el Regulador d 110VAC  a 5VDC seguido por el Regulador de 5VDC a 3.3VDC usando el módulo AMS1117. Se usan dos voltajes, 5V y 3.3V, en conocimiento que el uso de los sensores de temperatura DHT11 funcionan mejor a 5V (Ver referencia).

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

    3. Ensamble en Protoboard

    Para pruebas y ajustes, se ensamblan las partes en un protoboard teniendo como guía el diagrama del circuito del punto anterior.

    4. 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 conectores +5VDC-.

    Observe la polaridad 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 y como comprobación de distribución de espacio entre los componentes se usan placas perforadas para circuito impreso de 5×7 cm.

    El cableado previo permite como ejercicio visualizar mejoras al recorrido de las pistas.

    Referencias: [SOLVED] DHT11/DHT22 – Failed to read from DHT sensor.  https://randomnerdtutorials.com/solved-dht11-dht22-failed-to-read-from-dht-sensor/

  • WiFi - Control Remoto IR: MQTT-HA

    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 observar los valores de temperatura y humedad en 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 intervalo regular para sensar los valores de temperatura está configurado cada 5 min o más en la sección archivo.ino