Neste artigo, aprenderá como controlar um Ar Condicionado via IR com um microcontrolador ESP32 ou ESP8266.
A maioria das unidades modernas de Ar Condicionado vem com um comando que envia sinais de Infravermelhos (IR) para controlar a unidade. No entanto, frequentemente a funcionalidade do comando e do Ar Condicionado é limitada. E se quiser ligar o Ar Condicionado a uma hora específica? E se quiser regular o Ar Condicionado dependendo da previsão do tempo? Ou se quiser controlar o Ar Condicionado a partir de outra divisão? Talvez tenha simplesmente perdido o comando e queira construir um substituto mais potente?
Note que, a partir de janeiro de 2024, o IRRemoteESP8266 library usado para gerar os sinais IR para controlar um Ar Condicionado does not compile for the ESP32 and Arduino 3.0.0. Tentei, mas não consegui fazê-lo funcionar. No entanto, assim que a biblioteca for corrigida, o código deste artigo deverá funcionar novamente para o ESP32.
Tudo isto e muito mais pode ser alcançado se usarmos um microcontrolador para controlar o Ar Condicionado nós próprios. Vamos começar.
Peças Necessárias
Esta secção lista as peças necessárias. Para além de um ESP32 ou ESP8266 e algumas peças menores, vai precisar de um Ar Condicionado que possa ser controlado com sinais de Infravermelhos. Pode encontrar a lista de Aircons suportados aqui.
Quanto ao microcontrolador, vou usar especificamente o ESP8266 ESP-12F Mini (WEMOS LOLIN D1 mini) listado abaixo, mas a maioria das placas ESP8266 e ESP32 deverá funcionar também. Também listei o ESP32 lite devido ao baixo preço e ao conector de bateria com capacidade de recarga. Isso seria útil se quiser construir o seu próprio comando que funcione a bateria.
Dependendo da versão do projeto que está a construir, vai precisar apenas de um subconjunto das peças listadas aqui.
ESP8266 ESP-12F Mini
ESP32 lite
Cabo USB de Dados
Conjunto de Fios Dupont
Breadboard
Kit de Resistores & LEDs
Kit de Transistores
Receptor e Transmissor IR
Díodo Transmissor 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.
Tecnologia Infravermelha e Ar Condicionados
A tecnologia de Infravermelhos (IR) é amplamente usada em várias aplicações, incluindo comandos para dispositivos eletrónicos como televisores, leitores de DVD e ar condicionados. Permite comunicação sem fios entre dispositivos através da transmissão de sinais na forma de luz infravermelha.
Os ar condicionados, sendo um dos eletrodomésticos mais comuns, frequentemente vêm com um comando que utiliza tecnologia IR. Estes comandos enviam sinais IR específicos para a unidade do ar condicionado para controlar as suas funções, como ajustar a temperatura, a velocidade do ventilador e o modo.
Os ar condicionados estão equipados com um receptor IR que pode detetar e interpretar estes sinais. Quando um comando é recebido, o ar condicionado responde em conformidade, seja alterando a temperatura, ajustando a velocidade do ventilador ou executando qualquer outra ação associada ao comando.
Se quiser aprender mais sobre sinais infravermelhos e como os gerar, dê uma vista de olhos aos nossos tutoriais sobre How to build a universal, programmable IR remote, How to control an ESP32 with an IR Remote, e How to Control a Servo with an IR Remote.
Ar Condicionados Suportados
É importante notar que diferentes modelos e marcas de ar condicionado podem usar diferentes protocolos e códigos IR. Portanto, antes de avançar com o projeto, deve identificar a marca do seu ar condicionado. Vamos usar o IRRemoteESP8266 library e a lista de Aircons suportados pode ser encontrada aqui.
Depois de verificar que o seu Ar Condicionado é suportado, pode prosseguir com a ligação do ESP32/ESP8266 a um díodo IR e programá-lo para enviar os sinais apropriados. Isto permitirá controlar o seu ar condicionado remotamente usando uma interface web.
Sistema Global
A imagem abaixo mostra o sistema global que vamos construir. Uma página web a correr num navegador que controla o ESP32/ESP8266 via Wi-Fi, que por sua vez controla o Ar Condicionado usando sinais IR.
Na próxima secção, vou mostrar como ligar o ESP32/ESP8266 a um transmissor IR
Ligação do ESP32/ESP8266 a um transmissor IR
Para enviar sinais de Infravermelhos (IR) precisamos de ligar o ESP32 ou ESP8266 a um transmissor IR. A seguir, vou mostrar três formas diferentes de fazer isso. A primeira é a mais simples e usa um daqueles módulos transmissores IR práticos. Para o segundo circuito, usaremos um díodo transmissor IR e um resistor, o que é um pouco mais trabalhoso mas pode dar-nos maior alcance. O último circuito usa um MOSFET adicional, que nos permite aumentar ainda mais o alcance.
Módulo Transmissor IR
A forma mais fácil é usar um módulo transmissor IR. Estes módulos são muito simples e normalmente consistem num díodo IR e um resistor numa placa breakout. Geralmente têm três pinos: terra (GND ou ‘-‘), alimentação (VCC ou ‘+’) e sinal (S ou DAT). Veja o módulo abaixo.
Ligação do módulo transmissor IR
Ligar o módulo é simples. Ligue o terra (G) do seu ESP32/ESP8266 ao pino menos (-/GND) do módulo (fio preto). Depois ligue um pino GPIO (aqui usamos o D2) ao pino de sinal (S/DAT) do módulo (fio amarelo). Finalmente, ligue +5V (ou +3.3V) do seu microcontrolador ao pino do meio (+/VCC) do módulo (fio vermelho). Nota: não ligue o módulo aos pinos TX ou RX. Isso pode interferir com a comunicação serial.
No circuito de exemplo acima, estou a usar um Wemos Lolin D1 mini que oferece uma saída de 5V ou 3.3V. Qual deles usar para alimentar o módulo normalmente não importa. A entrada de 5V ou 3.3V no módulo IR às vezes nem é usada ou é apenas para indicar alimentação ou transferência de sinal. Geralmente não afeta o alcance do transmissor IR.
Embora isto funcione e seja bom para testar a função, o alcance é bastante limitado. Obtenho entre 1 e 2 metros de alcance e isso dependerá do resistor no módulo. Alguns módulos dão muito maior alcance, mas provavelmente usam o circuito errado. Veja a próxima secção.
Módulos sem resistor limitador de corrente
Cuidado! Alguns módulos baratos não têm resistor limitador de corrente, o que faz com que o díodo IR consuma cerca de 180mA de corrente. Isto é demasiado alto para uma saída GPIO de um ESP8266, que deve ser cerca de 10mA! Se ligar estas placas, obtém excelente alcance, mas há grandes hipóteses de danificar a sua placa!
Aqui está uma imagem de um módulo assim. Se olhar atentamente para a imagem abaixo, pode ver que o resistor R1 está em falta e a placa tem apenas um díodo IR. Pode usar estas placas, mas tem de adicionar um resistor ao circuito.
Na próxima secção, mostro como ligar o díodo transmissor IR e um resistor você mesmo. Isso dá-nos melhor controlo sobre a corrente e o alcance.
Díodo Transmissor IR e Resistor
Como pode ver abaixo, o circuito que usa um díodo transmissor IR e um resistor é ainda muito simples. Ligue o pino mais curto do díodo IR ao terra e o pino mais longo ao resistor. O outro pino do resistor é ligado a uma saída GPIO, aqui escolho o D2.
Podemos calcular o valor do resistor necessário da seguinte forma. Temos 3.3 Volts na saída GPIO, queremos consumir no máximo 10 mA, e o díodo IR tem uma tensão direta de 1.2V a 1.5V (vamos usar 1.3V). Assim, para um resistor de 220Ω obtemos uma corrente de 9mA:
(3.3V – 1.3V)/220Ω = 9mA
Como o sinal IR é um pulso curto, poderíamos usar um resistor tão baixo quanto 100Ω, para o qual obteríamos (3.3V – 1.3V)/100Ω = 20mA. Isso aumentaria um pouco o alcance, mas é arriscado. Uma solução melhor seria alimentar o díodo IR através de um transistor ou MOSFET. E é isso que vamos fazer na próxima secção.
Díodo Transmissor IR e MOSFET
O alcance do nosso transmissor IR é limitado porque só podemos fornecer com segurança 10mA ao díodo IR, quando usamos uma saída GPIO do ESP8266 diretamente. O díodo IR em si poderia ser alimentado com até 100mA, o que aumentaria dramaticamente o alcance do nosso transmissor. O esquema seguinte mostra como podemos fazer isso.
Neste circuito, o díodo IR está ligado a uma bateria de 9V com um resistor limitador de corrente R1 de 100Ω. Isso dá uma corrente de (9V-1.3V)/100Ω = 77mA através do díodo IR, que está dentro do seu limite de 100mA. Com esta configuração, obtenho um alcance de cerca de 8 a 10 metros.
O MOSFET atua como um interruptor. Se a saída GPIO (D2) do ESP8266 ficar alta, o Gate (G) do MOSFET abre a ligação do Drain (D) ao Source (S) e a corrente pode fluir da bateria de 9V, através do díodo IR até ao terra (GND).
O 2N7000 MOSFET, que estou a usar aqui, pode comutar até 60V e 200mA continuamente. Isso é suficiente para os 70mA de corrente que o nosso díodo IR consome.
O resistor de 100Ω (R2) no circuito é apenas mais um resistor limitador de corrente para proteger o GPIO. O segundo resistor (R1) com valor de 10KΩ é um resistor de pull-down que garante que o MOSFET desliga quando o gate não está ligado. Se quiser aprender mais sobre MOSFETs e como usá-los para controlar cargas elétricas, veja o nosso tutorial How To a Control Fan using Arduino.
Circuito Completo na Breadboard
A imagem abaixo mostra o circuito completo numa breadboard.
O circuito na breadboard segue o esquema apresentado acima. Comece por inserir o MOSFET e o díodo IR na breadboard. Atenção à orientação correta do 2N7000 e do díodo IR. Ligue a bateria de 9V por último e tenha cuidado com a polaridade correta. Também não se esqueça que a bateria e o ESP8266 devem ter terra comum (fio terra do ESP8266 ligado à bateria)!
Para testar o circuito, pode usar o blink sketch e um LED normal primeiro antes de executar o programa muito mais complexo que vamos discutir nas próximas secções. Vamos começar pela página web que precisamos para controlar o nosso Ar Condicionado.
Página Web para Controlo Remoto
Queremos controlar o nosso ESP32/ESP8266 via uma página web. As páginas web são tipicamente construídas usando a linguagem HTML. O código HTML seguinte descreve o layout, cores e conteúdo da nossa 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>
Se copiar este código HTML para um ficheiro chamado “test.html” e depois o carregar no seu navegador via Drag&Drop, verá a seguinte página web.
Pode identificar facilmente os elementos no código HTML e os elementos correspondentes na página web. O título está na tag “h1“, “p” define o parágrafo, que contém o texto “Power” e dois elementos “button” com hiperligações “a“. A secção “style” especifica as cores e o layout da página. Se quiser aprender mais sobre HTML, aqui está um bom HTML Tutorial.
Para mostrar esta página web num navegador, precisamos de executar um servidor web que sirva esta página ao navegador. Este servidor web vai correr no nosso ESP32/ESP8266 e vamos discutir esse código na próxima secção.
Programação do ESP32/ESP8266 para Controlo do Ar Condicionado
Abaixo está o código completo que permite controlar um Ar Condicionado por infravermelhos usando uma página web servida por um servidor web a correr no seu ESP32 ou ESP8266. É um código grande, mas vamos dividi-lo em partes geríveis e explicar em detalhe. Dê uma vista de olhos primeiro para ter uma visão geral.
Note que este código é para um DAIKIN ar condicionado. Mas pode ajustar o código facilmente ao seu ar condicionado alterando o protocolo de comunicação relevante (procure a variável ac.next.protocol no código). Pode encontrar uma lista dos Aircons suportados aqui.
// 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 o código em detalhe, vamos dividi-lo em partes.
Bibliotecas
Primeiro, install e incluímos as bibliotecas necessárias para o ESP32 e funcionalidade IR. Dependendo do microcontrolador (ESP32 ou ESP8266) precisamos incluir uma biblioteca Wi-Fi diferente. Conseguimos isso usando um 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"
Apesar do nome, a biblioteca IRremoteESP8266.h funciona para ESP8266 e ESP32 – pelo menos em teoria. Como mencionado na introdução, atualmente (jan 2024) a library does not compile for ESP32.
Constantes e Variáveis
De seguida definimos a constante irPin que especifica a que pino está ligado o transmissor IR. Também definimos as variáveis ssid e password para as credenciais da rede Wi-Fi. Terá de inserir o SSID e a password da sua rede Wi-Fi local aqui. O SSID é o nome da sua rede Wi-Fi doméstica, por exemplo “my_home_wifi”, e a password é a que normalmente usa para se ligar a essa rede (com o seu telemóvel ou computador).
const int irPin = D2; const char* ssid = "*****"; const char* password = "*****";
Código HTML para a Página Web
Já apresentámos esta parte do código antes. É o código HTML que será servido pelo servidor web. Descreve os elementos, cores e layout da 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>
)"""";
Preste especial atenção à secção que define os botões. Se quiser adicionar mais botões e mais funcionalidades à sua página web, este é o local para o fazer (também terá de adicionar código mais abaixo). Por exemplo, se também quiser ligar ou desligar as luzes do Ar Condicionado, isto é o que adicionaria:
<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>
Configuração Wi-Fi
A função setup_wifi() é responsável por ligar o ESP32 à rede Wi-Fi. Chamamos WiFi.begin(ssid, password) para iniciar a ligação Wi-Fi com as credenciais fornecidas (SSID, password). Depois esperamos num ciclo até conseguir ligar, verificando 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();
}
Uma vez ligado, imprimimos o endereço IP do servidor web (a correr no nosso ESP8266). Será impresso no Monitor Serial e terá de o copiar, pois precisa dele para se ligar à página web a partir do seu computador.
Finalmente, chamamos server.begin(), que inicia o servidor web. Se não conseguir ligar ao Wi-Fi, verifique o seu SSID e password!
Configuração do Ar Condicionado
Na função setup_ac(), primeiro definimos o pino do transmissor IR como saída (pinMode(irPin, OUTPUT)). Depois definimos o estado inicial do ar condicionado. Como pode ver, há muitas funções do Ar Condicionado que pode ligar ou desligar. Estas são para um ar condicionado DAIKIN, que é um modelo muito comum.
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.
}
Altere a variável ac.next.protocol = decode_type_t::DAIKIN para o modelo do seu Ar Condicionado. Os nomes dos diferentes modelos estão listados here e as constantes correspondentes podem ser encontradas here. Procure este trecho de código:
enum decode_type_t {
UNKNOWN = -1,
UNUSED = 0,
RC5,
RC6,
NEC,
SONY,
PANASONIC,
...
}
Dependendo do seu modelo, algumas destas funções podem não estar disponíveis e pode não precisar de definir todas estas variáveis. O código acima baseia-se na biblioteca this example of the IRremoteESP8266. Vai encontrar muitos mais exemplos e informações lá.
Especialmente, veja os wrappers para alguns dos Ar Condicionados. Usá-los pode dar-lhe menos opções, mas simplifica o seu código. Por exemplo, para o Ar Condicionado DAIKIN existe a classe wrapper ir_Daikin.h, que fornece funções para controlar o Ar Condicionado. Aqui um example:
ac.on(); ac.setFan(1); ac.setTemp(25);
Usar estas funções significa que não teria de escrever as suas próprias, como fazemos na próxima secção.
Controlo do Ar Condicionado
De seguida definimos a função ac_power() que é responsável por ligar ou desligar o ar condicionado definindo a propriedade power do objeto ac e enviando o sinal IR.
void ac_power(bool isOn) {
ac.next.power = isOn;
ac.sendAc();
}
Se quiser controlar mais funções do seu Ar Condicionado, adicionaria funções adicionais. Por exemplo, uma função para ligar ou desligar as luzes do Ar Condicionado seria assim:
void ac_light(bool isOn) {
ac.next.light = isOn;
ac.sendAc();
}
Execução de Comandos
De seguida temos a função execute() que processa o comando HTTP recebido e executa a ação correspondente. Neste caso, liga ou desliga o ar condicionado com base no comando. Note que as strings em “GET /power/on” devem corresponder às hiperligações href="/power/on" na página web. É isso que liga o botão à função que é executada quando o botão é pressionado.
void execute(String& command) {
if (command.endsWith("GET /power/on")) {
ac_power(true);
}
if (command.endsWith("GET /power/off")) {
ac_power(false);
}
}
Se quiser controlar as luzes além da energia, adicionaria a função ac_light() assim:
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
A função run_server() trata dos pedidos dos clientes e serve a página HTML. Também chama a função execute() para processar os comandos.
O código abaixo baseia-se largamente no exemplo SimpleWiFiServer fornecido pelo WiFi library. Se precisar de informações ou aplicações mais detalhadas, consulte lá.
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 e Loop
Finalmente, na função setup(), inicializamos a comunicação serial, configuramos o ar condicionado e ligamos à rede Wi-Fi.
void setup() {
Serial.begin(9600);
setup_ac();
setup_wifi();
}
E a função loop() executa o servidor web continuamente para tratar dos pedidos recebidos.
void loop() {
run_server();
}
E é isso! Agora tem um controlador totalmente funcional baseado na web para o seu Ar Condicionado. Na próxima secção, mostro como usá-lo na prática.
Usar o Servidor Web
Se reiniciar o seu ESP32/ESP8266 e abrir o Monitor Serial, deverá ver um texto que mostra o endereço IP do seu ESP32/ESP8266. No meu caso, para o meu ESP32, é 192.168.1.168, por exemplo.
Verá um endereço IP diferente; o que foi atribuído à sua placa ESP32/ESP8266. Copie esse endereço para a barra de pesquisa do seu navegador. Deve ver a página web que o servidor web no seu ESP32/ESP8266 cria:
Agora, pode pressionar os botões para ligar ou desligar o seu Ar Condicionado a partir de uma página web.
Para resumir, é assim que o sistema global funciona. O ESP8266/ESP32 executa um servidor web que é servido a um navegador web. O navegador e o servidor comunicam via Wi-Fi através do seu router Wi-Fi. O ESP8266/ESP32 controla o Ar Condicionado via sinais infravermelhos (IR) que imitam os comandos que o seu comando original enviaria. Isto também significa que ainda pode usar o seu comando.
Note que a página web é bastante segura, pois só pode ser acedida dentro da sua rede Wi-Fi local. Não é acessível publicamente pela internet! Se quiser isso, vai requerer mais trabalho e medidas de segurança, pois é arriscado abrir a sua rede Wi-Fi à internet!
Caso contrário, é tudo!
Conclusão
Neste artigo, aprendemos como controlar um ar condicionado usando sinais infravermelhos (IR) e um microcontrolador ESP32/ESP8266. Seguindo o guia passo a passo fornecido, pode automatizar o seu sistema de arrefecimento e desfrutar da conveniência do controlo remoto.
O código deste tutorial é apenas o começo. Há muito mais que pode fazer! Começando por controlar mais funções do seu Ar Condicionado, pode adicionar sensores adicionais (movimento, temperatura, humidade) para controlar automaticamente o Ar Condicionado dependendo das condições ambientais. Praticamente qualquer função que falte no seu Ar Condicionado, pode construir você mesmo.
Divirta-se!
Perguntas Frequentes
Aqui estão algumas perguntas frequentes sobre controlar um ar condicionado usando sinais infravermelhos e um microcontrolador ESP32/ESP8266:
P: Posso usar qualquer placa ESP32/ESP8266 para este projeto?
R: Sim, pode usar qualquer placa ESP32/ESP8266 para este projeto, desde que tenha os pinos GPIO necessários para ligar o díodo IR e tenha um módulo Wi-Fi integrado.
P: Como é que o ESP32/ESP8266 controla o ar condicionado usando sinais infravermelhos?
R: O ESP32/ESP8266 é programado para gerar os sinais infravermelhos necessários que imitam os sinais do comando do ar condicionado. Ligando o díodo IR ao ESP32/ESP8266 e programando-o adequadamente, pode enviar comandos infravermelhos específicos ao ar condicionado, como alterar a temperatura, modo ou velocidade do ventilador.
P: Posso controlar vários ar condicionados com um único ESP32/ESP8266?
R: Sim, pode controlar vários ar condicionados com um único ESP32/ESP8266 usando códigos IR diferentes para cada ar condicionado. Programando o ESP32/ESP8266 para enviar os códigos IR apropriados para cada ar condicionado, pode controlá-los individualmente ou simultaneamente.
P: Como posso aumentar o alcance do transmissor IR?
R: Pode usar dois (ou mais) transmissores IR controlados em paralelo mas ligados a dois pinos GPIO diferentes do seu ESP8266 ou ESP32. A melhor opção é alimentar o transmissor IR separadamente e usar um MOSFET (ou transistor) para o controlar. Se isso ainda não for suficiente, pode ligar um segundo díodo IR e controlar ambos através do MOSFET. Ainda assim, só precisaria de uma saída GPIO. Aqui está um esquema de exemplo:
Estas são algumas das perguntas frequentes sobre controlar um ar condicionado usando sinais infravermelhos e um microcontrolador ESP32/ESP8266. Se tiver mais perguntas, sinta-se à vontade para perguntar na secção de comentários abaixo.
