En este artículo aprenderás cómo controlar un aire acondicionado vía IR con un microcontrolador ESP32 o ESP8266.
La mayoría de las unidades modernas de aire acondicionado vienen con un mando a distancia que envía señales infrarrojas (IR) para controlar la unidad. Sin embargo, a menudo la funcionalidad del mando y del aire acondicionado es limitada. ¿Qué pasa si quieres encender el aire acondicionado a una hora específica? ¿O si quieres regularlo según el pronóstico del tiempo? ¿O si quieres controlarlo desde otra habitación? ¿O simplemente perdiste el mando y quieres construir un reemplazo más potente?
Ten en cuenta que a partir de enero de 2024 el IRRemoteESP8266 library usado para generar las señales IR para controlar un aire acondicionado does not compile for the ESP32 and Arduino 3.0.0. Lo intenté, pero no pude hacerlo funcionar. Sin embargo, una vez que la biblioteca esté arreglada, el código de este artículo debería funcionar de nuevo para el ESP32.
Todo esto y más se puede lograr si usamos un microcontrolador para controlar el aire acondicionado nosotros mismos. Vamos a empezar.
Partes necesarias
Esta sección lista las partes necesarias. Aparte de un ESP32 o ESP8266 y algunos componentes pequeños, necesitarás un aire acondicionado que pueda ser controlado con señales infrarrojas. Puedes encontrar la lista de Aircons aquí.
En cuanto al microcontrolador, usaré específicamente el ESP8266 ESP-12F Mini (WEMOS LOLIN D1 mini) listado a continuación, pero la mayoría de las placas ESP8266 y ESP32 deberían funcionar también. También menciono el ESP32 lite por su bajo precio y el conector de batería con capacidad de recarga. Esto sería útil si quieres construir tu propio mando a distancia que funcione con batería.
Dependiendo de la versión del proyecto que estés construyendo, solo necesitarás un subconjunto de las partes listadas aquí.
ESP8266 ESP-12F Mini
ESP32 lite
Cable USB de datos
Juego de cables Dupont
Protoboard
Kit de resistencias y LEDs
Kit de transistores
Receptor y transmisor IR
Diodo transmisor IR
Arduino IDE
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Tecnología infrarroja y aires acondicionados
La tecnología infrarroja (IR) se usa ampliamente en diversas aplicaciones, incluyendo mandos a distancia para dispositivos electrónicos como televisores, reproductores de DVD y aires acondicionados. Permite la comunicación inalámbrica entre dispositivos transmitiendo señales en forma de luz infrarroja.
Los aires acondicionados, siendo uno de los electrodomésticos más comunes, suelen venir con un mando a distancia que utiliza tecnología IR. Estos mandos envían señales IR específicas a la unidad para controlar funciones como ajustar la temperatura, la velocidad del ventilador y el modo.
Los aires acondicionados están equipados con un receptor IR que puede detectar e interpretar estas señales. Cuando se recibe un comando, el aire acondicionado responde en consecuencia, ya sea cambiando la temperatura, ajustando la velocidad del ventilador o realizando cualquier otra acción asociada al comando.
Si quieres aprender más sobre señales infrarrojas y cómo generarlas, echa un vistazo a nuestros tutoriales sobre How to build a universal, programmable IR remote, How to control an ESP32 with an IR Remote y How to Control a Servo with an IR Remote.
Aires acondicionados compatibles
Es importante notar que diferentes modelos y marcas de aire acondicionado pueden usar distintos protocolos y códigos IR. Por lo tanto, antes de continuar con el proyecto, debes identificar la marca de tu aire acondicionado. Usaremos el IRRemoteESP8266 library y la lista de Aircons compatibles se encuentra aquí.
Una vez verificado que tu aire acondicionado es compatible, puedes proceder a conectar el ESP32/ESP8266 a un diodo IR y programarlo para enviar las señales adecuadas. Esto te permitirá controlar tu aire acondicionado remotamente usando una interfaz web.
Sistema general
La imagen a continuación muestra el sistema general que vamos a construir. Una página web que se ejecuta en un navegador y controla el ESP32/ESP8266 vía Wi-Fi, que a su vez controla el aire acondicionado usando señales IR.
En la siguiente sección, te mostraré cómo conectar el ESP32/ESP8266 a un transmisor IR
Conectando el ESP32/ESP8266 a un transmisor IR
Para enviar señales infrarrojas (IR) necesitamos conectar el ESP32 o ESP8266 a un transmisor IR. A continuación te mostraré tres formas diferentes de hacerlo. La primera es la más sencilla y usa uno de esos prácticos módulos transmisores IR. Para el segundo circuito usaremos un diodo transmisor IR y una resistencia, que requiere un poco más de trabajo pero puede darnos mejor alcance. El último circuito usa un MOSFET adicional, que nos permite aumentar aún más el alcance.
Módulo transmisor IR
La forma más fácil es usar un módulo transmisor IR. Estos módulos son muy simples y típicamente consisten en un diodo IR y una resistencia en una placa breakout. Usualmente tienen tres pines: tierra (GND o ‘-‘), alimentación (VCC o ‘+’) y señal (S o DAT). Mira el módulo abajo.
Conectando el módulo transmisor IR
Conectar el módulo es sencillo. Conecta tierra (G) de tu ESP32/ESP8266 al pin menos (-/GND) del módulo (cable negro). Luego conecta un pin GPIO (aquí usamos D2) al pin de señal (S/DAT) del módulo (cable amarillo). Finalmente conecta +5V (o +3.3V) de tu microcontrolador al pin central (+/VCC) del módulo (cable rojo). Nota: no conectes el módulo a los pines TX o RX, ya que puede interferir con la comunicación serial.
En el circuito de ejemplo arriba, uso un Wemos Lolin D1 mini que ofrece salida de 5V o 3.3V. Normalmente no importa cuál uses para alimentar el módulo. La entrada de 5V o 3.3V al módulo IR a veces ni se usa o solo indica alimentación o transferencia de señal. Generalmente no afecta el alcance del transmisor IR.
Aunque esto funciona y es bueno para probar la función, el alcance es bastante limitado. Obtengo entre 1 y 2 metros de alcance y dependerá de la resistencia en el módulo. Algunos módulos ofrecen mayor alcance pero probablemente usan un circuito incorrecto. Ver siguiente sección.
Módulos sin resistencia limitadora de corriente
¡Cuidado! Algunos módulos baratos no tienen resistencia limitadora de corriente, lo que hace que el diodo IR consuma unos 180mA. Esto es demasiado alto para un pin GPIO de un ESP8266, que debería ser alrededor de 10mA. Si conectas estas placas obtendrás un alcance excelente pero probablemente dañarás tu placa.
Aquí tienes una foto de un módulo así. Si miras bien, verás que falta la resistencia R1 y la placa solo tiene un diodo IR. Puedes usar estas placas pero debes añadir una resistencia al circuito.
En la siguiente sección te mostraré cómo conectar tú mismo el diodo transmisor IR y una resistencia. Esto nos da mejor control sobre la corriente y el alcance.
Diodo transmisor IR y resistencia
Como ves abajo, el circuito que usa un diodo transmisor IR y una resistencia sigue siendo muy simple. Conecta el pin más corto del diodo IR a tierra y el pin más largo a la resistencia. El otro pin de la resistencia se conecta a un pin GPIO, aquí elijo D2.
Podemos calcular el valor de la resistencia necesaria así. Tenemos 3.3 Voltios en la salida GPIO, queremos que la corriente no supere los 10 mA, y el diodo IR tiene una caída de tensión de 1.2V a 1.5V (pongamos 1.3V). Para una resistencia de 220Ω obtenemos una corriente de 9mA:
(3.3V – 1.3V)/220Ω = 9mA
Como la señal IR es un pulso corto, podríamos bajar hasta 100Ω, para lo que tendríamos (3.3V – 1.3V)/100Ω = 20mA. Esto aumentaría un poco el alcance pero es arriesgado. Una mejor solución es alimentar el diodo IR mediante un transistor o MOSFET. Y eso es lo que haremos en la siguiente sección.
Diodo transmisor IR y MOSFET
El alcance de nuestro transmisor IR está limitado porque solo podemos entregar con seguridad 10mA al diodo IR usando un pin GPIO del ESP8266 directamente. El diodo IR podría alimentarse con hasta 100mA, lo que aumentaría dramáticamente el alcance del transmisor. El siguiente esquema muestra cómo hacerlo.
En este circuito el diodo IR está conectado a una batería de 9V con una resistencia limitadora de corriente R1 de 100Ω. Esto nos da una corriente de (9V-1.3V)/100Ω = 77mA a través del diodo IR, que está dentro del límite de 100mA. Con esta configuración, obtengo un alcance de alrededor de 8 a 10 metros.
El MOSFET actúa como un interruptor. Si la salida GPIO (D2) del ESP8266 se pone en alto, la puerta (Gate, G) del MOSFET abre la conexión entre drenaje (Drain, D) y fuente (Source, S) y la corriente puede fluir desde la batería de 9V, a través del diodo IR hacia tierra (GND).
El 2N7000 MOSFET que uso aquí puede conmutar hasta 60V y 200mA continuamente. Eso es suficiente para los 70mA que consume nuestro diodo IR.
La resistencia de 100Ω (R2) en el circuito es otra resistencia limitadora para proteger el GPIO. La segunda resistencia (R1) de 10KΩ es una resistencia pull-down que asegura que el MOSFET se apague cuando la puerta no está conectada. Si quieres aprender más sobre MOSFETs y cómo usarlos para controlar cargas eléctricas, echa un vistazo a nuestro tutorial How To a Control Fan using Arduino.
Circuito completo en protoboard
La imagen abajo muestra el circuito completo en una protoboard.
El circuito en la protoboard sigue el esquema presentado arriba. Comienza insertando el MOSFET y el diodo IR en la protoboard. Presta atención a la orientación correcta del 2N7000 y del diodo IR. Conecta la batería de 9V al final y cuida la polaridad correcta. No olvides que la batería y el ESP8266 deben compartir tierra (cable de tierra del ESP8266 conectado a la batería).
Para probar el circuito podrías usar primero el blink sketch y un LED normal antes de ejecutar el programa mucho más complejo que discutiremos en las siguientes secciones. Empecemos por la página web que necesitamos para controlar nuestro aire acondicionado.
Página web para control remoto
Queremos controlar nuestro ESP32/ESP8266 vía una página web. Las páginas web se construyen típicamente usando el lenguaje HTML. El siguiente código HTML describe el diseño, colores y contenido de nuestra página web.
<!DOCTYPE html>
<html>
<head>
<title>Aircon</title>
<style>
body { text-align: center; font-family: Arial, sans-serif; }
button { background-color: slateblue; color: white; border: none; width: 50px; height: 30px; }
button:hover { background-color: darkslateblue; }
button:active { background-color: mediumslateblue; }
</style>
</head>
<body>
<h1>Aircon</h1>
<p>Power:
<a href="/power/on"><button>ON</button></a>
<a href="/power/off"><button>OFF</button></a>
</p>
</body>
</html>
Si copias este código HTML en un archivo llamado «test.html» y luego lo cargas en tu navegador mediante arrastrar y soltar, verás la siguiente página web.
Puedes identificar fácilmente los elementos en el código HTML y los elementos correspondientes en la página web. El título está en la etiqueta «h1«, «p» define el párrafo, que contiene el texto «Power» y dos elementos «button» con enlaces «a«. La sección «style» especifica los colores y el diseño de la página. Si quieres aprender más sobre HTML, aquí tienes un buen HTML Tutorial.
Para mostrar esta página web en un navegador necesitamos ejecutar un servidor web que sirva esta página al navegador. Este servidor web se ejecutará en nuestro ESP32/ESP8266 y discutiremos ese código en la siguiente sección.
Programando el ESP32/ESP8266 para controlar el aire acondicionado
A continuación está el código completo que te permite controlar un aire acondicionado por infrarrojos usando una página web servida por un servidor web que corre en tu ESP32 o ESP8266. Es un código grande, pero lo dividiremos en partes manejables y lo explicaremos en detalle. Primero échale un vistazo para tener una visión general.
Ten en cuenta que este código es para un DAIKIN aire acondicionado. Pero puedes ajustar el código fácilmente a tu aire acondicionado cambiando el protocolo de comunicación relevante (busca la variable ac.next.protocol en el código). Puedes encontrar una lista de los Aircons compatibles aquí.
// Control Aircon via Infrared Signals using a Webpage
// served by a Webserver running on an ESP32/ESP8266
#if defined(ESP8266)
#include "ESP8266WiFi.h"
#elif defined(ESP32)
#include "WiFi.h"
#else
#error "This ain't a ESP8266 or ESP32"
#endif
#include "Arduino.h"
#include "IRremoteESP8266.h" // ESP32 and ESP8266
#include "IRac.h"
#include "IRutils.h"
const int irPin = D2;
const char* ssid = "*****";
const char* password = "*****";
const char* html = R""""(
HTTP/1.1 200 OK
Content-type:text/html
<!DOCTYPE html>
<html>
<head>
<title>Aircon</title>
<style>
body { text-align: center; font-family: Arial, sans-serif; }
button { background-color: slateblue; color: white; border: none; width: 50px; height: 30px; }
button:hover { background-color: darkslateblue; }
button:active { background-color: mediumslateblue; }
</style>
</head>
<body>
<h1>Aircon</h1>
<p>Power:
<a href="/power/on"><button>ON</button></a>
<a href="/power/off"><button>OFF</button></a>
</p>
</body>
</html>
)"""";
WiFiServer server(80);
IRac ac(irPin);
void setup_wifi() {
delay(10);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}
void setup_ac() {
pinMode(irPin, OUTPUT);
ac.next.protocol = decode_type_t::DAIKIN; // Set a protocol to use. Here a DAIKIN Aircon
ac.next.model = 1; // Some A/Cs have different models. Try just the first.
ac.next.mode = stdAc::opmode_t::kCool; // Run in cool mode initially.
ac.next.celsius = true; // Use Celsius for temp units. False = Fahrenheit
ac.next.degrees = 25; // 25 degrees.
ac.next.fanspeed = stdAc::fanspeed_t::kMedium; // Start the fan at medium.
ac.next.swingv = stdAc::swingv_t::kOff; // Don't swing the fan up or down.
ac.next.swingh = stdAc::swingh_t::kOff; // Don't swing the fan left or right.
ac.next.light = false; // Turn off any LED/Lights/Display that we can.
ac.next.beep = false; // Turn off any beep from the A/C if we can.
ac.next.econo = false; // Turn off any economy modes if we can.
ac.next.filter = false; // Turn off any Ion/Mold/Health filters if we can.
ac.next.turbo = false; // Don't use any turbo/powerful/etc modes.
ac.next.quiet = false; // Don't use any quiet/silent/etc modes.
ac.next.sleep = -1; // Don't set any sleep time or modes.
ac.next.clean = false; // Turn off any Cleaning options if we can.
ac.next.clock = -1; // Don't set any current time if we can avoid it.
ac.next.power = false; // Initially start with the unit off.
}
void ac_power(bool isOn) {
ac.next.power = isOn;
ac.sendAc();
}
void execute(String& command) {
if (command.endsWith("GET /power/on")) {
ac_power(true);
}
if (command.endsWith("GET /power/off")) {
ac_power(false);
}
}
void run_server() {
WiFiClient client = server.accept();
if (client) {
String currentLine = "";
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n') {
if (currentLine.length() == 0) {
client.println(html);
break;
} else {
currentLine = "";
}
} else if (c != '\r') {
currentLine += c;
}
execute(currentLine);
}
}
client.stop();
}
}
void setup() {
Serial.begin(9600);
setup_ac();
setup_wifi();
}
void loop() {
run_server();
}
Para entender el código en detalle, vamos a dividirlo en partes.
Librerías
Primero, install e incluimos las librerías necesarias para el ESP32 y la funcionalidad IR. Dependiendo del microcontrolador (ESP32 o ESP8266) necesitamos incluir una librería Wi-Fi diferente. Lo logramos usando un conditional include (#if, #elif, #endif).
#if defined(ESP8266) #include "ESP8266WiFi.h" #elif defined(ESP32) #include "WiFi.h" #else #error "This is not a ESP8266 or ESP32" #endif #include "Arduino.h" #include "IRremoteESP8266.h" // ESP32 and ESP8266 #include "IRac.h" #include "IRutils.h"
A pesar de su nombre, la librería IRremoteESP8266.h funciona para ESP8266 y ESP32, al menos en teoría. Como mencioné en la introducción, actualmente (enero 2024) la library does not compile for ESP32.
Constantes y variables
Luego definimos la constante irPin que especifica a qué pin está conectado el transmisor IR. También definimos las variables ssid y password para las credenciales de la red Wi-Fi. Debes insertar el SSID y la contraseña de tu red Wi-Fi local aquí. El SSID es el nombre de tu Wi-Fi doméstico, por ejemplo «my_home_wifi», y la contraseña es la que usas normalmente para conectarte a esa red (con tu teléfono o computadora).
const int irPin = D2; const char* ssid = "*****"; const char* password = "*****";
Código HTML para la página web
Ya presentamos esta parte del código antes. Es el código HTML que será servido por el servidor web. Describe los elementos, colores y diseño de la página web.
const char* html = R""""(
HTTP/1.1 200 OK
Content-type:text/html
<!DOCTYPE html>
<html>
<head>
<title>Aircon</title>
<style>
body { text-align: center; font-family: Arial, sans-serif; }
button { background-color: slateblue; color: white; border: none; width: 50px; height: 30px; }
button:hover { background-color: darkslateblue; }
button:active { background-color: mediumslateblue; }
</style>
</head>
<body>
<h1>Aircon</h1>
<p>Power:
<a href="/power/on"><button>ON</button></a>
<a href="/power/off"><button>OFF</button></a>
</p>
</body>
</html>
)"""";
Presta especial atención a la sección que define los botones. Si quieres añadir más botones y funcionalidades a tu página web, aquí es donde hacerlo (también tendrás que añadir código más adelante). Por ejemplo, si quieres también encender o apagar las luces del aire acondicionado, esto es lo que añadirías:
<p>Power: <a href="/power/on"><button>ON</button></a> <a href="/power/off"><button>OFF</button></a> </p> <p>Lights: <a href="/light/on"><button>ON</button></a> <a href="/light/off"><button>OFF</button></a> </p>
Configuración Wi-Fi
La función setup_wifi() es responsable de conectar el ESP32 a la red Wi-Fi. Llamamos a WiFi.begin(ssid, password) para iniciar la conexión Wi-Fi con las credenciales proporcionadas (SSID, contraseña). Luego esperamos en un bucle hasta que se conecte comprobando WiFi.status().
void setup_wifi() {
delay(10);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}
Una vez conectado, imprimimos la dirección IP del servidor web (que corre en nuestro ESP8266). Se imprimirá en el Monitor Serial y tendrás que copiarla, ya que la necesitarás para conectarte a la página web desde tu ordenador.
Finalmente, llamamos a server.begin(), que inicia el servidor web. Si no puedes conectarte al Wi-Fi, revisa tu SSID y contraseña.
Configuración del aire acondicionado
En la función setup_ac(), primero configuramos el pin del transmisor IR como salida (pinMode(irPin, OUTPUT)). Luego establecemos el estado inicial del aire acondicionado. Como ves, hay muchas funciones del aire acondicionado que puedes activar o desactivar. Estas son para un aire acondicionado DAIKIN, que es un modelo muy común.
void setup_ac() {
pinMode(irPin, OUTPUT);
ac.next.protocol = decode_type_t::DAIKIN; // Set a protocol to use.
ac.next.model = 1; // Some A/Cs have different models. Try just the first.
ac.next.mode = stdAc::opmode_t::kCool; // Run in cool mode initially.
ac.next.celsius = true; // Use Celsius for temp units. False = Fahrenheit
ac.next.degrees = 25; // 25 degrees.
ac.next.fanspeed = stdAc::fanspeed_t::kMedium; // Start the fan at medium.
ac.next.swingv = stdAc::swingv_t::kOff; // Don't swing the fan up or down.
ac.next.swingh = stdAc::swingh_t::kOff; // Don't swing the fan left or right.
ac.next.light = false; // Turn off any LED/Lights/Display that we can.
ac.next.beep = false; // Turn off any beep from the A/C if we can.
ac.next.econo = false; // Turn off any economy modes if we can.
ac.next.filter = false; // Turn off any Ion/Mold/Health filters if we can.
ac.next.turbo = false; // Don't use any turbo/powerful/etc modes.
ac.next.quiet = false; // Don't use any quiet/silent/etc modes.
ac.next.sleep = -1; // Don't set any sleep time or modes.
ac.next.clean = false; // Turn off any Cleaning options if we can.
ac.next.clock = -1; // Don't set any current time if we can avoid it.
ac.next.power = false; // Initially start with the unit off.
}
Cambia la variable ac.next.protocol = decode_type_t::DAIKIN al modelo de tu aire acondicionado. Los nombres de los diferentes modelos están listados here y las constantes correspondientes se encuentran here. Busca este fragmento de código:
enum decode_type_t {
UNKNOWN = -1,
UNUSED = 0,
RC5,
RC6,
NEC,
SONY,
PANASONIC,
...
}
Dependiendo de tu modelo, algunas de estas funciones pueden no estar disponibles y puede que no necesites configurar todas estas variables. El código anterior está basado en la librería this example of the IRremoteESP8266. Allí encontrarás muchos más ejemplos e información.
Especialmente, echa un vistazo a los wrappers para algunos aires acondicionados. Usarlos puede darte menos opciones pero simplificará tu código. Por ejemplo, para el aire acondicionado DAIKIN existe la clase wrapper ir_Daikin.h, que proporciona funciones para controlar el aire acondicionado. Aquí un example:
ac.on(); ac.setFan(1); ac.setTemp(25);
Usar estas funciones significa que no tendríamos que escribir las nuestras propias como hacemos en la siguiente sección.
Control del aire acondicionado
Luego definimos la función ac_power() que se encarga de encender o apagar el aire acondicionado configurando la propiedad power del objeto ac y enviando la señal IR.
void ac_power(bool isOn) {
ac.next.power = isOn;
ac.sendAc();
}
Si quieres controlar más funciones de tu aire acondicionado, añadirías funciones adicionales. Por ejemplo, una función para encender o apagar las luces del aire acondicionado sería así:
void ac_light(bool isOn) {
ac.next.light = isOn;
ac.sendAc();
}
Ejecución de comandos
Luego tenemos la función execute() que procesa el comando HTTP recibido y realiza la acción correspondiente. En este caso, enciende o apaga el aire acondicionado según el comando. Ten en cuenta que las cadenas en «GET /power/on» deben coincidir con los enlaces href="/power/on" en la página web. Esto conecta el botón con la función que se ejecuta al pulsarlo.
void execute(String& command) {
if (command.endsWith("GET /power/on")) {
ac_power(true);
}
if (command.endsWith("GET /power/off")) {
ac_power(false);
}
}
Si quieres controlar las luces además del encendido, añadirías la función ac_light() así:
void execute(String& command) {
if (command.endsWith("GET /power/on")) {
ac_power(true);
}
if (command.endsWith("GET /power/off")) {
ac_power(false);
}
if (command.endsWith("GET /light/on")) {
ac_light(true);
}
if (command.endsWith("GET /light/off")) {
ac_light(false);
}
}
Servidor web
La función run_server() maneja las solicitudes entrantes de clientes y sirve la página HTML. También llama a la función execute() para procesar los comandos.
El código abajo está basado en gran parte en el ejemplo SimpleWiFiServer proporcionado por WiFi library. Si necesitas información más detallada o aplicaciones, échale un vistazo allí.
void run_server() {
WiFiClient client = server.accept();
if (client) {
String currentLine = "";
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n') {
if (currentLine.length() == 0) {
client.println(html);
break;
} else {
currentLine = "";
}
} else if (c != '\r') {
currentLine += c;
}
execute(currentLine);
}
}
client.stop();
}
}
Setup y loop
Finalmente, en la función setup() inicializamos la comunicación serial, configuramos el aire acondicionado y conectamos a la red Wi-Fi.
void setup() {
Serial.begin(9600);
setup_ac();
setup_wifi();
}
Y la función loop() ejecuta el servidor web continuamente para manejar las solicitudes entrantes.
void loop() {
run_server();
}
¡Y eso es todo! Ahora tienes un controlador web completamente funcional para tu aire acondicionado. En la siguiente sección te mostraré cómo usarlo realmente.
Usando el servidor web
Si reinicias tu ESP32/ESP8266 y abres el Monitor Serial, deberías ver un texto que muestra la dirección IP de tu ESP32/ESP8266. En mi caso, para mi ESP32 es 192.168.1.168, por ejemplo.
Verás una dirección IP diferente; la que se asignó a tu placa ESP32/ESP8266. Copia esa dirección en la barra de búsqueda de tu navegador. Deberías ver la página web que el servidor web en tu ESP32/ESP8266 crea:
Ahora puedes pulsar los botones para encender o apagar tu aire acondicionado desde una página web.
Para resumir, así es como funciona el sistema general. El ESP8266/ESP32 ejecuta un servidor web que se sirve a un navegador web. Navegador y servidor web se comunican vía Wi-Fi a través de tu router Wi-Fi. El ESP8266/ESP32 controla el aire acondicionado vía señales infrarrojas (IR) que imitan los comandos que enviaría tu mando a distancia. Esto también significa que aún puedes usar tu mando.
Ten en cuenta que la página web es bastante segura, ya que solo se puede acceder dentro de tu red Wi-Fi local. ¡No es accesible públicamente desde internet! Si quieres eso, requerirá más trabajo y medidas de seguridad, ya que es arriesgado abrir tu red Wi-Fi a internet.
¡Eso es todo!
Conclusión
En este post aprendimos cómo controlar un aire acondicionado usando señales infrarrojas (IR) y un microcontrolador ESP32/ESP8266. Siguiendo la guía paso a paso, puedes automatizar tu sistema de refrigeración y disfrutar de la comodidad del control remoto.
El código de este tutorial es solo un comienzo. ¡Hay mucho más que puedes hacer! Desde controlar más funciones de tu aire acondicionado, hasta añadir sensores adicionales (movimiento, temperatura, humedad) para controlar automáticamente el aire acondicionado según las condiciones ambientales. Prácticamente cualquier función que falte en tu aire acondicionado, puedes construirla tú mismo.
¡Diviértete!
Preguntas frecuentes
Aquí tienes algunas preguntas frecuentes sobre cómo controlar un aire acondicionado usando señales infrarrojas y un microcontrolador ESP32/ESP8266:
P: ¿Puedo usar cualquier placa ESP32/ESP8266 para este proyecto?
R: Sí, puedes usar cualquier placa ESP32/ESP8266 para este proyecto siempre que tenga los pines GPIO necesarios para conectar el diodo IR y un módulo Wi-Fi integrado.
P: ¿Cómo controla el ESP32/ESP8266 el aire acondicionado usando señales infrarrojas?
R: El ESP32/ESP8266 está programado para generar las señales infrarrojas necesarias que imitan las señales del mando a distancia del aire acondicionado. Al conectar el diodo IR al ESP32/ESP8266 y programarlo adecuadamente, puedes enviar comandos infrarrojos específicos al aire acondicionado, como cambiar la temperatura, el modo o la velocidad del ventilador.
P: ¿Puedo controlar varios aires acondicionados con un solo ESP32/ESP8266?
R: Sí, puedes controlar varios aires acondicionados con un solo ESP32/ESP8266 usando diferentes códigos IR para cada aire acondicionado. Programando el ESP32/ESP8266 para enviar los códigos IR apropiados para cada uno, puedes controlarlos individualmente o simultáneamente.
P: ¿Cómo aumento el alcance del transmisor IR?
R: Puedes usar dos (o más) transmisores IR controlados en paralelo pero conectados a dos pines GPIO diferentes de tu ESP8266 o ESP32. La mejor opción es alimentar el transmisor IR por separado y usar un MOSFET (o transistor) para controlarlo. Si eso aún no es suficiente, puedes conectar un segundo diodo IR y controlar ambos mediante el MOSFET. Solo necesitarías un pin GPIO. Aquí tienes un esquema de ejemplo:
Estas son algunas de las preguntas frecuentes sobre cómo controlar un aire acondicionado usando señales infrarrojas y un microcontrolador ESP32/ESP8266. Si tienes más preguntas, no dudes en preguntar en la sección de comentarios abajo.
