Controle remoto universal IR com ESP32: aprenda, salve e envie códigos de TV e ar-condicionado
Monte um controle remoto universal IR com ESP32: aprenda códigos de TV e ar-condicionado com IRremoteESP8266, salve-os e envie pelo celular. Tabela de protocolos, driver do LED IR e alcance.
Um controle remoto universal IR com ESP32 junta os controles da TV, do ar-condicionado, da fita de LED e do aparelho de som em um único dispositivo que você comanda por uma página web no celular. A ideia é simples: com um receptor infravermelho, o ESP32 aprende o código que o controle original envia, salva na memória permanente e envia o mesmo código por um LED IR sempre que você pedir. Como a biblioteca IRremoteESP8266 reconhece mais de cem protocolos, ela decodifica tanto as teclas da TV quanto as longas mensagens do ar-condicionado, que levam temperatura e ajustes de ventilação.
Neste guia você vai ver primeiro como funcionam os controles infravermelhos e como diferem os protocolos NEC, Sony, Samsung, RC5 e os de ar-condicionado. Depois vai aprender a acionar o LED IR com um transistor, calcular os valores dos resistores e o alcance, ler os códigos do seu controle, salvá-los no ESP32 e enviá-los pelo celular e, por fim, controlar um ar-condicionado direto pela temperatura, sem aprender nada. Os sketches funcionam com as versões 2.x e 3.x do core do ESP32.

Como funciona um controle remoto universal IR?
Um controle usa um LED IR que emite luz invisível em 940 nm. Como o sol e as lâmpadas também emitem infravermelho, o controle não deixa o LED aceso; ele o pisca 38.000 vezes por segundo (uma portadora de 38 kHz) e leva a informação na duração dessas rajadas. Módulos receptores como o VS1838B ou o TSOP38238 só respondem a essa frequência: eles retiram a portadora e colocam a saída em LOW a cada rajada. O ESP32 então lê o código cronometrando os pulsos e os intervalos em microssegundos. O envio é o contrário: o ESP32 aplica os mesmos tempos ao LED IR com modulação de 38 kHz. Vimos o básico do receptor em receptor IR e controle remoto.
| Protocolo | Portadora | Tamanho | Usado em | Observação |
|---|---|---|---|---|
| NEC | 38 kHz | 32 bits | Muitas TVs, controles de fitas de LED, os controles dos kits de Arduino | Envia um código curto de repetição enquanto a tecla fica pressionada |
| Samsung | 38 kHz | 32 bits | TVs Samsung | Parecido com o NEC, com outro pulso inicial |
| Sony SIRC | 40 kHz | 12, 15 ou 20 bits | TVs e aparelhos de som Sony | O comando precisa ser enviado pelo menos 3 vezes seguidas |
| RC5 / RC6 | 36 kHz | 13–20 bits ou mais | Philips e algumas marcas europeias | Um bit de alternância muda a cada novo toque |
| LG | 38 kHz | 28 bits | TVs e ares-condicionados LG | A biblioteca o trata como protocolo separado |
| Ar-condicionado (Daikin, Mitsubishi, Gree, Midea, Fujitsu etc.) | Quase sempre 38 kHz | 24–280 bits | Ares-condicionados split | Cada toque envia o estado completo, incluindo modo, temperatura e ventilação |
A maior diferença da tabela está entre a TV e o ar-condicionado. O controle da TV envia um código de tecla: "aumentar volume" é sempre o mesmo número de 32 bits, e a própria TV sabe qual é o volume atual. Já o controle do ar-condicionado envia o estado inteiro que aparece no visor: ligado, refrigeração, 24 °C, ventilação automática, oscilação. Um código aprendido de um ar-condicionado é, portanto, uma foto da configuração do momento; quando você o envia de novo, o aparelho vai exatamente para essa configuração. Mudar a temperatura grau a grau exige uma gravação por grau, ou então você gera a mensagem no código, como verá adiante.
Peças e circuito
- Placa de desenvolvimento ESP32 (ESP32 DevKit, 30 ou 38 pinos)
- Módulo receptor IR de 38 kHz (VS1838B ou TSOP38238)
- LED IR de 940 nm e 5 mm (um modelo de ângulo estreito, como o TSAL6100, aumenta o alcance)
- Transistor NPN: 2N2222, BC337 ou S8050
- Resistores de 470 Ω (base) e 33 Ω (LED), 1/4 W
- Capacitor eletrolítico de 100 µF
- Protoboard, jumpers e um adaptador USB de 5 V



| Peça e pino | Ligação no ESP32 | Observação |
|---|---|---|
| OUT do receptor IR | GPIO 15 | O módulo tem o próprio resistor de pull-up |
| VCC / GND do receptor IR | 3V3 / GND | Não use 5 V: a saída também subiria para 5 V |
| Base do transistor | GPIO 4 por meio de 470 Ω | Corrente de base de cerca de 5,5 mA |
| Emissor do transistor | GND | — |
| Coletor do transistor | Catodo do LED IR (perna curta) | — |
| Anodo do LED IR (perna longa) | 5V (VIN) por meio de 33 Ω | Corrente de pulso de cerca de 100 mA |
| Capacitor de 100 µF | Entre 5V e GND, perto do LED | Absorve os pulsos de corrente |
Transistor de acionamento do LED IR: cálculo dos resistores
Aqui o transistor funciona como chave: quando o GPIO 4 vai para HIGH, passa corrente de base, o transistor satura e a corrente do LED vem da linha de 5V, e não do ESP32. O resistor do LED sai da lei de Ohm: R = (5 − 1,4 − 0,2) / 0,1 ≈ 34 Ω. Aqui, 1,4 V é a tensão direta do LED IR a 100 mA e 0,2 V é a queda no transistor saturado; o valor padrão mais próximo é 33 Ω. Pelo resistor de base passam (3,3 − 0,7) / 470 ≈ 5,5 mA, o que satura o transistor com folga para uma corrente de coletor de 100 mA. A potência instantânea do resistor é 0,1² × 33 ≈ 0,33 W, mas o LED só fica aceso metade do tempo a 38 kHz e não continuamente durante uma mensagem, então a potência média fica abaixo de 0,1 W e um resistor de 1/4 W basta. Você pode testar outros valores com a calculadora de resistor para LED e a ferramenta de transistores.
| Corrente do LED | Um LED (5 V) | Dois LEDs em série (5 V) | Observação |
|---|---|---|---|
| 50 mA | 68 Ω | 39 Ω | Alcance curto, consumo baixo |
| 100 mA | 33 Ω | 22 Ω | Recomendado; seguro para uso contínuo |
| 200 mA (só pulsado) | 15 Ω | 8,2 Ω | Maior alcance; confira o limite de corrente de pulso do LED |
Cálculo do alcance: até onde o controle chega?
A luz enfraquece com o quadrado da distância: a irradiância no receptor é E = Ie / d². Ie é a intensidade radiante do LED por esferorradiano (mW/sr), indicada no datasheet. A irradiância mínima que um receptor da classe do TSOP38238 precisa para funcionar (Ee min) é de cerca de 0,25 mW/m². Isolando a distância, temos d = √(Ie / Ee min). Um LED de ângulo estreito de ±10°, como o TSAL6100, dá cerca de 130 mW/sr a 100 mA: d = √(130 / 0,25) = √520 ≈ 23 m. Esse é o limite teórico com o LED apontado direto para o receptor em um cômodo escuro; com luz do sol, lâmpadas fluorescentes e ângulo, conte com cerca de metade na prática. Dobrar a corrente só aumenta o alcance em √2 ≈ 1,4, então, para uma sala grande, um segundo LED apontado para outra direção costuma ser mais eficaz.
| Corrente e acionamento do LED | Intensidade radiante (LED de ângulo estreito) | Alcance teórico | Alcance prático |
|---|---|---|---|
| 20 mA, direto de um GPIO | Cerca de 26 mW/sr | Cerca de 10 m | 3–5 m |
| 100 mA, transistor e 33 Ω | Cerca de 130 mW/sr | Cerca de 23 m | 8–12 m |
| 200 mA pulsado, transistor e 15 Ω | Cerca de 260 mW/sr | Cerca de 32 m | 12–16 m |
| 2 LEDs × 100 mA, direções diferentes | 130 mW/sr cada | 23 m por direção | Cobertura ampla em toda a sala |
Instalando a biblioteca IRremoteESP8266
- Na Arduino IDE, instale o pacote do ESP32 pelo Gerenciador de Placas e selecione ESP32 Dev Module; a configuração está em O que é o ESP32?.
- No Gerenciador de Bibliotecas, procure IRremoteESP8266 e instale a biblioteca de David Conran e equipe.
- Se você usa a versão 3.x do core do ESP32, escolha a versão 2.9.0 ou mais nova da biblioteca; a 2.8.6 e anteriores não compilam no core 3.x, com um erro de timer.
- A biblioteca de nome parecido IRremote é outra biblioteca; os sketches deste guia são para a IRremoteESP8266.
Passo 1: lendo as teclas do seu controle
O primeiro sketch decodifica todo sinal que chega ao receptor e mostra três coisas no Monitor Serial: o protocolo e o código, uma linha de estado legível se for um ar-condicionado e, por fim, os tempos brutos. O buffer de captura está em 1024 posições e o timeout em 50 ms; as mensagens de ar-condicionado têm centenas de pulsos e chegam em várias partes, então os valores padrão as cortariam. Carregue o código, abra o Monitor Serial a 115200 baud, aponte o controle para o receptor e aperte uma tecla.
1#include <Arduino.h>
2#include <IRremoteESP8266.h>
3#include <IRrecv.h>
4#include <IRutils.h>
5#include <IRac.h>
6
7const uint16_t RECV_PIN = 15; // IR alıcı OUT / IR receiver OUT
8const uint16_t CAPTURE_SIZE = 1024; // klima mesajları uzundur / AC messages are long
9const uint8_t MSG_TIMEOUT = 50; // klimalar için 50 ms / 50 ms for AC units
10
11IRrecv irrecv(RECV_PIN, CAPTURE_SIZE, MSG_TIMEOUT, true);
12decode_results results;
13
14void setup() {
15 Serial.begin(115200);
16 irrecv.setUnknownThreshold(12); // çok kısa gürültüyü yok say / ignore very short noise
17 irrecv.enableIRIn();
18 Serial.println(F("Kumandayi aliciya tut ve bir tusa bas / point a remote at the receiver and press a key"));
19}
20
21void loop() {
22 if (irrecv.decode(&results)) {
23 Serial.println(resultToHumanReadableBasic(&results)); // protokol, kod, bit / protocol, code, bits
24 String ac = IRAcUtils::resultAcToString(&results); // klimaysa durum metni / AC state as text
25 if (ac.length()) Serial.println(ac);
26 Serial.println(resultToSourceCode(&results)); // ham süreler / raw timings
27 Serial.println();
28 irrecv.resume(); // sonraki koda hazırlan / ready for the next code
29 }
30}Na tecla de ligar de uma TV LG você verá uma linha como Protocol : NEC, Code : 0x20DF10EF (32 Bits), e em uma TV Samsung SAMSUNG 0xE0E040BF. Com um controle de ar-condicionado, o nome do protocolo será algo como DAIKIN, GREE ou COOLIX, seguido de uma linha com modo, temperatura e ventilação. Se você segurar uma tecla, os controles NEC enviam um código curto de repetição em vez do código real; ele precisa ser ignorado no aprendizado. Quando a biblioteca não reconhece um protocolo, mostra UNKNOWN; esses códigos ainda podem ser salvos com os tempos brutos e reenviados exatamente como eram.
Passo 2: salvando códigos e enviando pelo celular
O controle universal de verdade é o código abaixo. O ESP32 entra na sua rede Wi-Fi e serve uma página web com seis teclas; cada linha tem um botão Aprender e um botão Enviar. Depois de apertar Aprender, você tem 10 segundos para apertar a tecla no controle original; o ESP32 decodifica o código e o grava na memória permanente (NVS) com a biblioteca Preferences, então os códigos sobrevivem a uma queda de energia. Os códigos de TV são guardados como protocolo, número de bits e um valor de 64 bits, os de ar-condicionado com todos os bytes de estado e os desconhecidos com os tempos brutos. Para o básico de servidor web, veja servidor web no ESP32.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <Preferences.h>
4#include <IRremoteESP8266.h>
5#include <IRrecv.h>
6#include <IRsend.h>
7#include <IRutils.h>
8
9const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
10const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
11const uint16_t RECV_PIN = 15; // IR alıcı OUT / IR receiver OUT
12const uint16_t SEND_PIN = 4; // transistör bazı (470 ohm) / transistor base (470 ohm)
13const uint8_t SLOT_COUNT = 6;
14const uint16_t MAX_RAW = 300; // ham kodda en fazla 300 süre / up to 300 timings in a raw code
15const char* NAMES[SLOT_COUNT] = {"TV Power", "Volume +", "Volume -", "Channel +", "AC 24C", "AC Off"};
16
17struct IrCode { // bir tuşun kaydı / one key's record
18 int16_t protocol; // decode_type_t, -1 = boş / empty
19 uint16_t bits;
20 uint64_t value; // TV gibi kısa kodlar / short codes such as TV keys
21 uint8_t state[kStateSizeMax]; // klimanın tüm durumu / the AC's full state
22 uint16_t rawLen; // tanınmayan kodlarda ham uzunluk / raw length for unknown codes
23};
24
25IRrecv irrecv(RECV_PIN, 1024, 50, true);
26IRsend irsend(SEND_PIN);
27WebServer server(80);
28Preferences prefs;
29decode_results results;
30IrCode codes[SLOT_COUNT];
31int learningSlot = -1; // öğrenilen tuş, -1 = yok / slot being learned, -1 = none
32unsigned long learnStart = 0;
33String lastInfo = "-";
34
35void slotKey(char* key, char type, uint8_t s) { // NVS anahtarı: c0, r0 ... / NVS key
36 key[0] = type;
37 key[1] = '0' + s;
38 key[2] = 0;
39}
40
41void storeResult(uint8_t s) {
42 IrCode& c = codes[s];
43 c.protocol = results.decode_type;
44 c.bits = results.bits;
45 c.rawLen = 0;
46 char key[3];
47 if (hasACState(results.decode_type)) {
48 memcpy(c.state, results.state, results.bits / 8); // klima: durum baytları / AC: state bytes
49 } else {
50 c.value = results.value; // TV: tuş kodu / TV: key code
51 }
52 if (results.decode_type == UNKNOWN) { // tanınmadı: ham süreleri sakla / unknown: keep raw timings
53 uint16_t* raw = resultToRawArray(&results);
54 uint16_t len = getCorrectedRawLength(&results);
55 if (len > MAX_RAW) len = MAX_RAW;
56 slotKey(key, 'r', s);
57 prefs.putBytes(key, raw, len * sizeof(uint16_t));
58 c.rawLen = len;
59 delete[] raw; // kütüphane new ile ayırır / allocated with new
60 }
61 slotKey(key, 'c', s);
62 prefs.putBytes(key, &c, sizeof(IrCode)); // elektrik kesilse de kalır / survives power loss
63 lastInfo = String(NAMES[s]) + ": " + typeToString(results.decode_type) + " " + String(results.bits) + " bit";
64}
65
66void sendSlot(uint8_t s) {
67 IrCode& c = codes[s];
68 if (c.protocol < 0) return;
69 decode_type_t type = (decode_type_t)c.protocol;
70 irrecv.disableIRIn(); // kendi sinyalimizi okumayalım / don't read our own signal
71 if (type == UNKNOWN && c.rawLen > 0) {
72 uint16_t raw[MAX_RAW];
73 char key[3];
74 slotKey(key, 'r', s);
75 size_t n = prefs.getBytes(key, raw, sizeof(raw)) / sizeof(uint16_t);
76 irsend.sendRaw(raw, n, 38); // 38 kHz taşıyıcı / 38 kHz carrier
77 } else if (hasACState(type)) {
78 irsend.send(type, c.state, c.bits / 8); // klima durum mesajı / AC state message
79 } else {
80 irsend.send(type, c.value, c.bits); // TV tuş kodu / TV key code
81 }
82 irrecv.enableIRIn();
83 lastInfo = String("Sent: ") + NAMES[s];
84}
85
86void handleRoot() {
87 String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width,initial-scale=1'>"
88 "<title>IR Remote</title><style>body{font-family:sans-serif;margin:16px}"
89 "button{padding:10px 14px;margin:3px}td{padding:5px}</style></head>"
90 "<body><h2>ESP32 IR Remote</h2><p id='st'>-</p><table>";
91 for (uint8_t i = 0; i < SLOT_COUNT; i++) {
92 html += "<tr><td>" + String(NAMES[i]) + "</td><td>";
93 html += codes[i].protocol < 0 ? String("empty") : typeToString((decode_type_t)codes[i].protocol);
94 html += "</td><td><button onclick='go(\"send\"," + String(i) + ")'>Send</button>";
95 html += "<button onclick='go(\"learn\"," + String(i) + ")'>Learn</button></td></tr>";
96 }
97 html += "</table><script>function go(a,i){fetch('/'+a+'?s='+i)}"
98 "setInterval(()=>fetch('/status').then(r=>r.text()).then(t=>document.getElementById('st').textContent=t),1000)"
99 "</script></body></html>";
100 server.send(200, "text/html", html);
101}
102
103int slotArg() { // ?s= parametresi / the ?s= parameter
104 int s = server.hasArg("s") ? server.arg("s").toInt() : -1;
105 return (s >= 0 && s < SLOT_COUNT) ? s : -1;
106}
107
108void handleSend() {
109 int s = slotArg();
110 if (s >= 0) sendSlot(s);
111 server.send(200, "text/plain", "ok");
112}
113
114void handleLearn() {
115 learningSlot = slotArg();
116 learnStart = millis();
117 if (learningSlot >= 0) lastInfo = String("Press the key for ") + NAMES[learningSlot];
118 server.send(200, "text/plain", "ok");
119}
120
121void setup() {
122 Serial.begin(115200);
123 prefs.begin("irremote", false);
124 for (uint8_t i = 0; i < SLOT_COUNT; i++) { // kayıtlı kodları yükle / load saved codes
125 char key[3];
126 slotKey(key, 'c', i);
127 if (prefs.getBytes(key, &codes[i], sizeof(IrCode)) != sizeof(IrCode)) codes[i].protocol = -1;
128 }
129 irsend.begin();
130 irrecv.setUnknownThreshold(12);
131 irrecv.enableIRIn();
132 WiFi.begin(ssid, password);
133 while (WiFi.status() != WL_CONNECTED) delay(300);
134 Serial.print(F("IP: "));
135 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this on your phone
136 server.on("/", handleRoot);
137 server.on("/send", handleSend);
138 server.on("/learn", handleLearn);
139 server.on("/status", []() { server.send(200, "text/plain", lastInfo); });
140 server.begin();
141}
142
143void loop() {
144 server.handleClient();
145 if (irrecv.decode(&results)) {
146 if (learningSlot >= 0 && !results.repeat) { // NEC tekrar kodunu atla / skip NEC repeat codes
147 storeResult(learningSlot);
148 learningSlot = -1;
149 }
150 irrecv.resume();
151 }
152 if (learningSlot >= 0 && millis() - learnStart > 10000) { // 10 sn içinde kod yoksa vazgeç / give up after 10 s
153 learningSlot = -1;
154 lastInfo = "Timeout";
155 }
156}| Parte do código | O que faz |
|---|---|
| Estrutura IrCode | Guarda o protocolo de uma tecla, o número de bits, o código da TV ou os bytes de estado do ar-condicionado e o tamanho bruto |
| storeResult() | Copia o sinal recebido para a estrutura; grava os tempos brutos dos códigos desconhecidos em uma chave separada |
| sendSlot() | Chama sendRaw() para códigos brutos, send(type, state, bytes) para um ar-condicionado ou send(type, value, bits) para uma TV |
| Preferences (NVS) | Guarda as teclas em c0–c5 e os tempos brutos em r0–r5 |
| disableIRIn() / enableIRIn() | Desliga o receptor durante o envio, para o ESP32 não aprender o próprio sinal |
| /learn, /send e /status | Os endereços chamados pelos botões da página; a linha de status se atualiza a cada segundo |
- Coloque o nome e a senha da sua rede, carregue o código e abra o endereço IP mostrado no Monitor Serial em um celular na mesma rede.
- Aperte Aprender na linha TV Power; a mensagem "Press the key for TV Power" aparece no topo da página.
- Em até 10 segundos, aponte o controle da TV para o receptor e aperte ligar uma vez; a linha de status mostra algo como "TV Power: NEC 32 bit".
- Para o ar-condicionado, primeiro deixe o controle original na configuração desejada (refrigeração, 24 °C, por exemplo), depois aperte Aprender na linha AC 24C e aperte a tecla de ligar do controle.
- Recarregue a página; os nomes dos protocolos aparecem na tabela. Teste os seus aparelhos com os botões Enviar, apontando o LED IR para eles.
Controle do ar-condicionado: ajustando a temperatura sem aprender
Em vez de aprender cada temperatura do seu ar-condicionado, você pode gerar a mensagem no código. A classe IRac da IRremoteESP8266 monta as mensagens de dezenas de marcas, incluindo Daikin, Mitsubishi, Fujitsu, Gree, Midea, Samsung, LG, Toshiba e Panasonic, a partir de uma estrutura comum: você preenche modo, temperatura, ventilação e oscilação, e o sendAc() envia tudo de uma vez. Descubra o nome do protocolo do seu ar-condicionado com o sketch de leitura do passo 1 e coloque-o no código abaixo. No Monitor Serial, o liga e desliga o ar-condicionado e + e - mudam a temperatura entre 16 e 30 °C.
1#include <Arduino.h>
2#include <IRremoteESP8266.h>
3#include <IRac.h>
4#include <IRutils.h>
5
6const uint16_t SEND_PIN = 4; // transistör bazı / transistor base
7IRac ac(SEND_PIN);
8
9void setup() {
10 Serial.begin(115200);
11 ac.next.protocol = decode_type_t::DAIKIN; // okuma kodunda gördüğün protokol / protocol from the dump sketch
12 ac.next.model = 1; // çoğu markada 1 / 1 for most brands
13 ac.next.mode = stdAc::opmode_t::kCool; // soğutma / cooling
14 ac.next.celsius = true;
15 ac.next.degrees = 24;
16 ac.next.fanspeed = stdAc::fanspeed_t::kAuto;
17 ac.next.swingv = stdAc::swingv_t::kAuto;
18 ac.next.power = false; // kapalı başla / start switched off
19 Serial.println(F("o: ac/kapa on/off | +/-: derece / degrees"));
20}
21
22void loop() {
23 if (!Serial.available()) return;
24 char key = Serial.read();
25 if (key == '+' && ac.next.degrees < 30) ac.next.degrees++;
26 else if (key == '-' && ac.next.degrees > 16) ac.next.degrees--;
27 else if (key == 'o') ac.next.power = !ac.next.power;
28 else return; // diğer tuşları yok say / ignore other keys
29 ac.sendAc(); // tüm durumu tek mesajda gönder / send the full state in one message
30 Serial.printf("Power %d, %.0f C\n", ac.next.power, ac.next.degrees);
31}Algumas marcas têm mais de um modelo; se o ar-condicionado não responder, tente colocar model em 2 ou 3. A grande vantagem desse método é poder ligar a temperatura a um sensor: um termostato simples que liga o ar acima de 26 °C e desliga abaixo de 22 °C leva só algumas linhas. A lógica é a mesma do controle com histerese em termostato com Arduino. Como a estrutura da mensagem é comum, você só troca a linha do protocolo ao mudar de ar-condicionado.
Ideias de projetos
- Ar-condicionado programado: use a hora via NTP para ligar o ar meia hora antes de você chegar em casa.
- Ar-condicionado pela temperatura: meça o cômodo com um DHT11 ou DHT22 e acione o ar automaticamente com o IRac.
- Controle pelo Telegram: ligue o ar quando estiver fora com uma mensagem para um bot do Telegram.
- Integração com o Home Assistant: adicione as teclas ao Home Assistant via MQTT e use-as com um assistente de voz.
- TV desligada em cômodo vazio: se um sensor PIR não detectar movimento por 30 minutos, envie à TV o código de desligar.
- Controle de fita de LED: aprenda os controles NEC de 24 ou 44 teclas das fitas RGB e mude as cores de uma fita de LED RGB pelo celular.
Erros comuns e como resolver
| Sintoma | Causa provável | Solução |
|---|---|---|
| Nada aparece no Monitor Serial | Pino do receptor errado, receptor que não é de 38 kHz ou fio solto | Confira se o OUT está no GPIO 15; teste o controle a 20–50 cm |
| O código do ar-condicionado chega cortado ou como UNKNOWN | Buffer pequeno demais ou timeout curto demais | Suba o buffer para 1024 e o timeout para 50 ms (como nos sketches) |
| O código é aprendido, mas o aparelho não responde | LED fraco ou mal apontado, ou foi aprendido um código de repetição | Confira o LED com a câmera e aprenda de novo com um toque curto |
| Alcance de só 1–2 metros | LED acionado direto pelo GPIO ou resistor grande demais | Forneça 100 mA com o transistor e 33 Ω, use um LED de ângulo estreito |
| Uma TV Sony não reage na primeira vez | O protocolo Sony precisa de repetições | O send() já acrescenta pelo menos duas repetições; aprenda a tecla de novo |
| Erro de timer ao compilar | Biblioteca antiga com o core 3.x do ESP32 | Atualize a IRremoteESP8266 para a versão 2.9.0 ou mais nova |
| O ar-condicionado pula para outra configuração a cada envio | Códigos aprendidos com configurações diferentes estão misturados | Aprenda cada configuração em uma linha própria ou gere a mensagem com o IRac |
| O receptor aprende um código novo depois de um envio | O ESP32 está lendo o próprio sinal | Use disableIRIn() durante o envio e posicione o receptor atrás do LED |
Um controle universal é o jeito mais barato de deixar inteligentes os aparelhos antigos de casa, juntando o Wi-Fi do ESP32 com um circuito IR simples. Primeiro identifique os seus controles com o sketch de leitura, depois aprenda e salve os códigos e use o IRac para controlar a temperatura do ar-condicionado diretamente. No app BlueGrays você encontra a leitura de códigos de controle com receptor IR, o controle de um LED e de uma lâmpada de 220 V pelo controle remoto, um receptor IR com ESP32 e LCD e o ESP32 Controle Remoto Universal IR com display OLED, cada um com esquema de ligação passo a passo e código pronto.
Perguntas frequentes
Como fazer um controle remoto universal com ESP32?
Ligue ao ESP32 um receptor IR de 38 kHz e um LED IR acionado por transistor. A biblioteca IRremoteESP8266 decodifica os códigos dos controles, você os salva na memória permanente com Preferences e os envia de volta pelos botões da página web que o ESP32 serve. Assim você controla TV, ar-condicionado e fitas de LED pelo celular.
Quais marcas de ar-condicionado a IRremoteESP8266 suporta?
A biblioteca reconhece mais de cem protocolos, incluindo Daikin, Mitsubishi, Fujitsu, Gree, Midea, Samsung, LG, Toshiba, Panasonic e Haier. O sketch de leitura mostra qual protocolo o seu ar-condicionado usa. Mesmo que o protocolo não seja reconhecido, o código pode ser salvo com os tempos brutos e reenviado sem alterações.
Como aumentar o alcance de um LED IR?
Acione o LED com cerca de 100 mA por um transistor NPN em vez de um GPIO, escolha um LED de 940 nm de ângulo estreito e aponte-o para o aparelho. O alcance cresce com a raiz quadrada da corrente, então dobrar a corrente só dá cerca de 1,4 vez mais. Em salas grandes, acrescentar um segundo LED virado para outra direção é mais eficaz.
Por que o código do meu controle aparece como UNKNOWN?
Ou a biblioteca não conhece esse protocolo, ou o sinal foi capturado só em parte. Primeiro suba o buffer de captura para 1024 e o timeout para 50 ms e tente de novo. Se continuar UNKNOWN, salvar o código com os tempos brutos e enviá-lo com sendRaw() a 38 kHz funciona com a maioria dos aparelhos.
Posso alimentar o receptor IR com 5 V no ESP32?
Não é recomendado. Alimentado com 5 V, a saída do receptor também vai a 5 V e pode danificar a entrada de 3,3 V do ESP32. Os módulos VS1838B e TSOP38238 funcionam perfeitamente em 3,3 V, então ligue o VCC no pino 3V3.
Os códigos IR salvos se perdem quando a energia cai?
Não. O sketch deste guia grava as teclas aprendidas na partição NVS da memória flash do ESP32 com a biblioteca Preferences e as carrega de novo ao ligar. Para apagar um código, basta aprender um novo na mesma linha ou chamar prefs.clear().
Projetos para montar depois desta leitura
Ver todos os projetos
Controle remoto universal IR com ESP32 (receptor IR + controle remoto + 3 LEDs + buzzer + OLED)
Com o ESP32, você pode ler os sinais de um controle remoto IR comum e usá-lo para controlar seu próprio dispositivo! Neste projeto, usamos um receptor infravermelho (protocolo NEC, 38 kHz) para captar os sinais de um controle IR de 20 botões. Definimos ações diferentes para cada botão: os botões 1, 2 e 3 ligam e desligam três LEDs separados; o botão PWR apaga todos; e os números 4–9 exibem indicações especiais no OLED.

Controle remoto com receptor IR, ESP32 e display LCD
Neste projeto, usamos o módulo receptor IR TSOP4838 para captar sinais de um controle remoto de TV, ar-condicionado ou outro controle infravermelho com o ESP32. Com a biblioteca IRremote v4, exibimos os códigos brutos decodificados diferentes de zero no display LCD I2C. Este exemplo serve para identificar os códigos do controle remoto; não inclui ligar ou desligar um LED nem ajustar seu brilho pelo controle. É um ótimo ponto de partida para usar controles antigos em uma casa inteligente.

Leitura de códigos de controle remoto IR
Cada botão do controle remoto da sua TV envia um código secreto usando uma luz que você não consegue ver.

Ligar e desligar LEDs com receptor IR e controle remoto
É como controlar três lâmpadas separadas sem sair da poltrona: os botões 1, 2 e 3 do controle remoto acendem os LEDs azul, vermelho e verde, e os botões 4, 5 e 6 os apagam na mesma ordem.

Tocar melodias com receptor IR, controle remoto e buzzer
Monte uma caixinha de música que toca melodias com os botões de um controle de TV.

Acender uma lâmpada de 220V com controle remoto
Ligue e desligue uma lâmpada de casa com o controle da TV, sem sair do sofá. O Arduino lê o sinal de luz invisível do controle; o botão de ligar aciona o relé e acende a lâmpada, e o botão de…

Servidor web assíncrono com ESP32 (IP no LCD)
Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.
Mais artigos
- Receptor IR e controle remoto: projetos controlados à distância com Arduino
- O que é ESP32? Características, configuração na Arduino IDE e seu primeiro projeto com Wi-Fi
- Servidor web assíncrono no ESP32 com WebSocket: painel de controle em tempo real
- O que é um transistor? Como funciona, NPN vs PNP e uso com Arduino
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

