Control remoto universal con ESP32: aprende y envía códigos IR
Haz un control remoto universal con ESP32: aprende códigos de tele y aire acondicionado con IRremoteESP8266, guárdalos y envíalos desde el celular.
Un control remoto universal con ESP32 junta en un solo aparato los controles de la tele, el aire acondicionado, la tira LED y el equipo de sonido, y los manejas todos desde una página web en tu celular. La idea es sencilla: con un receptor infrarrojo el ESP32 aprende el código que envía el control original, lo guarda en su memoria permanente y lo vuelve a enviar por un LED infrarrojo cuando quieras. Como la librería IRremoteESP8266 reconoce más de cien protocolos, decodifica tanto las teclas de un televisor como los mensajes largos de un minisplit, que incluyen la temperatura y la velocidad del ventilador.
En esta guía primero verás cómo funcionan los controles infrarrojos y en qué se diferencian los protocolos NEC, Sony, Samsung, RC5 y los de aire acondicionado. Después aprenderás a manejar el LED IR con un transistor, a calcular las resistencias y el alcance, a leer los códigos de tu control, a guardarlos en el ESP32 y enviarlos desde el celular, y por último a controlar el aire acondicionado directamente por temperatura, sin aprender nada. Los programas funcionan con las versiones 2.x y 3.x del core ESP32.

¿Cómo funciona un control remoto IR universal?
Un control usa un LED IR que emite luz invisible de 940 nm. Como el sol y las lámparas también emiten infrarrojo, el control no deja el LED encendido: lo hace parpadear 38 000 veces por segundo (portadora de 38 kHz) y transmite la información con la duración de esas ráfagas. Los módulos receptores como el VS1838B o el TSOP38238 solo responden a esa frecuencia: quitan la portadora y ponen su salida en LOW durante cada ráfaga. Así el ESP32 lee el código midiendo en microsegundos la duración de pulsos y espacios. Al enviar pasa lo contrario: el ESP32 aplica los mismos tiempos al LED IR con una modulación de 38 kHz. Explicamos lo básico del receptor en receptor IR y control remoto.
| Protocolo | Portadora | Longitud | Dónde se usa | Nota |
|---|---|---|---|---|
| NEC | 38 kHz | 32 bits | Muchas teles, controles de tiras LED, el control de los kits de Arduino | Envía un código de repetición corto al mantener la tecla |
| Samsung | 38 kHz | 32 bits | Televisores Samsung | Parecido al NEC, con otro pulso de inicio |
| Sony SIRC | 40 kHz | 12, 15 o 20 bits | Teles y equipos de audio Sony | El comando se debe enviar al menos 3 veces seguidas |
| RC5 / RC6 | 36 kHz | 13–20 bits o más | Philips y algunas marcas europeas | Un bit (toggle) cambia con cada nueva pulsación |
| LG | 38 kHz | 28 bits | Teles y aires acondicionados LG | La librería lo reconoce como protocolo aparte |
| Aire acondicionado (Daikin, Mitsubishi, Gree, Midea, Carrier, etc.) | Casi siempre 38 kHz | 24–280 bits | Minisplits | Cada pulsación envía todo el estado: modo, temperatura y ventilador |
La diferencia más importante de la tabla está entre la tele y el aire acondicionado. El control de una tele envía un código de tecla: "subir volumen" siempre es el mismo número de 32 bits y la tele sabe por sí sola en qué volumen está. El control de un minisplit, en cambio, envía todo el estado que ves en su pantalla: encendido, frío, 24 °C, ventilador automático, aleta oscilando. Por eso un código aprendido de un aire acondicionado es una foto del ajuste de ese momento; cuando lo vuelves a enviar, el equipo pasa exactamente a ese ajuste. Para cambiar la temperatura grado por grado necesitas una grabación por grado, o generar el mensaje en el código, como verás más abajo.
Materiales y circuito
- Placa de desarrollo ESP32 (ESP32 DevKit de 30 o 38 pines)
- Módulo receptor IR de 38 kHz (VS1838B o TSOP38238)
- LED IR de 940 nm y 5 mm (un modelo de ángulo estrecho como el TSAL6100 aumenta el alcance)
- Transistor NPN: 2N2222, BC337 o S8050
- Resistencias de 470 Ω (base) y 33 Ω (LED), de 1/4 W
- Capacitor electrolítico de 100 µF
- Protoboard, cables jumper y un cargador USB de 5 V



| Componente y pin | Conexión al ESP32 | Nota |
|---|---|---|
| OUT del receptor IR | GPIO 15 | El módulo trae su propia resistencia pull-up |
| VCC / GND del receptor IR | 3V3 / GND | No uses 5 V: la salida también subiría a 5 V |
| Base del transistor | GPIO 4 a través de 470 Ω | Corriente de base de unos 5,5 mA |
| Emisor del transistor | GND | — |
| Colector del transistor | Cátodo del LED IR (pata corta) | — |
| Ánodo del LED IR (pata larga) | 5V (VIN) a través de 33 Ω | Corriente de pulso de unos 100 mA |
| Capacitor de 100 µF | Entre 5V y GND, cerca del LED | Absorbe los picos de corriente |
Transistor para el LED IR: cálculo de resistencias
Aquí el transistor trabaja como interruptor: cuando GPIO 4 se pone en HIGH circula corriente de base, el transistor se satura y la corriente del LED sale de la línea de 5V y no del ESP32. La resistencia del LED sale de la ley de Ohm: R = (5 − 1,4 − 0,2) / 0,1 ≈ 34 Ω. Aquí 1,4 V es el voltaje directo del LED IR a 100 mA y 0,2 V la caída del transistor saturado; el valor comercial más cercano es 33 Ω. Por la resistencia de base circulan (3,3 − 0,7) / 470 ≈ 5,5 mA, de sobra para saturar el transistor con 100 mA de colector. La potencia instantánea en la resistencia es 0,1² × 33 ≈ 0,33 W, pero el LED solo está encendido la mitad del tiempo a 38 kHz y tampoco durante todo el mensaje, así que la potencia media queda por debajo de 0,1 W y alcanza con una resistencia de 1/4 W. Puedes probar otros valores con la calculadora de resistencia para LED y la herramienta de transistores.
| Corriente del LED | Un LED (5 V) | Dos LED en serie (5 V) | Nota |
|---|---|---|---|
| 50 mA | 68 Ω | 39 Ω | Poco alcance, bajo consumo |
| 100 mA | 33 Ω | 22 Ω | Recomendado; seguro para uso continuo |
| 200 mA (solo en pulsos) | 15 Ω | 8,2 Ω | Máximo alcance; revisa el límite de corriente de pulso del LED |
Cálculo del alcance: ¿hasta dónde llega el control?
La luz se debilita con el cuadrado de la distancia: la irradiancia que llega al receptor es E = Ie / d². Ie es la intensidad radiante del LED por estereorradián (mW/sr) y viene en su hoja de datos. La irradiancia mínima que necesita un receptor tipo TSOP38238 para funcionar (Ee mín) es de unos 0,25 mW/m². Despejando la distancia queda d = √(Ie / Ee mín). Un LED de ángulo estrecho de ±10° como el TSAL6100 da unos 130 mW/sr a 100 mA: d = √(130 / 0,25) = √520 ≈ 23 m. Ese es el límite teórico, con el LED apuntando justo al receptor y el cuarto a oscuras; por la luz del sol, los tubos fluorescentes y el ángulo, en la práctica cuenta con la mitad. Duplicar la corriente solo multiplica el alcance por √2 ≈ 1,4, así que en una sala grande suele funcionar mejor un segundo LED apuntando hacia otro lado.
| Corriente y manejo del LED | Intensidad radiante (LED de ángulo estrecho) | Alcance teórico | Alcance práctico |
|---|---|---|---|
| 20 mA, directo del GPIO | Unos 26 mW/sr | Unos 10 m | 3–5 m |
| 100 mA, transistor y 33 Ω | Unos 130 mW/sr | Unos 23 m | 8–12 m |
| 200 mA en pulsos, transistor y 15 Ω | Unos 260 mW/sr | Unos 32 m | 12–16 m |
| 2 LED × 100 mA, en distintas direcciones | 130 mW/sr cada uno | 23 m por dirección | Cobertura amplia en todo el cuarto |
Instalar la librería IRremoteESP8266
- En el IDE de Arduino instala el paquete ESP32 desde el Gestor de tarjetas y elige la placa ESP32 Dev Module; la instalación está explicada en ¿Qué es el ESP32?.
- En el Gestor de librerías busca IRremoteESP8266 e instala la librería de David Conran y su equipo.
- Si usas la versión 3.x del core ESP32, elige la versión 2.9.0 o más nueva de la librería; la 2.8.6 y anteriores no compilan en el core 3.x por un error de timer.
- La librería IRremote, de nombre parecido, es otra distinta; los programas de esta guía son para IRremoteESP8266.
Paso 1: leer las teclas del control
El primer programa decodifica cada señal que llega al receptor y muestra tres cosas en el Monitor Serie: el protocolo y el código, una línea legible con el estado si es un aire acondicionado y, al final, los tiempos crudos. El búfer de captura está en 1024 elementos y el tiempo de espera en 50 ms; los mensajes de un minisplit tienen cientos de pulsos y llegan en varias partes, y con los valores por defecto se cortarían. Sube el código, abre el Monitor Serie a 115200 baudios, apunta el control al receptor y presiona una 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}Con la tecla de encendido de una tele LG verás una línea como Protocol : NEC, Code : 0x20DF10EF (32 Bits), y con una Samsung SAMSUNG 0xE0E040BF. Con el control de un minisplit, el nombre del protocolo será algo como DAIKIN, GREE o COOLIX, seguido de una línea con el modo, la temperatura y el ventilador. Si mantienes presionada una tecla, los controles NEC envían un código de repetición corto en lugar del código real; hay que saltarlo al aprender. Cuando la librería no reconoce el protocolo escribe UNKNOWN; esos códigos igual se pueden guardar con sus tiempos crudos y reenviar tal cual.
Paso 2: guardar los códigos y enviarlos desde el celular
El control universal de verdad es el código de abajo. El ESP32 se conecta a tu red Wi-Fi y sirve una página web con seis teclas; cada fila tiene un botón Learn (aprender) y otro Send (enviar). Después de presionar Learn tienes 10 segundos para apretar la tecla del control original; el ESP32 decodifica el código y lo escribe en la memoria permanente (NVS) con la librería Preferences, así que los códigos no se pierden aunque se vaya la luz. Los códigos de tele se guardan como protocolo, cantidad de bits y valor de 64 bits; los de aire acondicionado, con todos sus bytes de estado, y los desconocidos, con sus tiempos crudos. Para lo básico del servidor web, mira servidor web con 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 del código | Qué hace |
|---|---|
| Estructura IrCode | Guarda el protocolo, la cantidad de bits, el código de tele o los bytes de estado del aire y la longitud cruda de una tecla |
| storeResult() | Copia la señal recibida en la estructura; escribe los tiempos crudos de los códigos desconocidos en una clave aparte |
| sendSlot() | Llama a sendRaw() para códigos crudos, a send(tipo, estado, bytes) para un aire o a send(tipo, valor, bits) para una tele |
| Preferences (NVS) | Guarda las teclas en las claves c0–c5 y los tiempos crudos en r0–r5 |
| disableIRIn() / enableIRIn() | Apaga el receptor mientras envía, así el ESP32 no aprende su propia señal |
| /learn, /send, /status | Las direcciones que llaman los botones de la página; la línea de estado se actualiza cada segundo |
- Escribe el nombre y la contraseña de tu red, sube el código y abre en un celular conectado a la misma red la dirección IP que aparece en el Monitor Serie.
- Presiona Learn en la fila TV Power; arriba en la página aparece "Press the key for TV Power".
- Antes de 10 segundos apunta el control de la tele al receptor y presiona una vez el botón de encendido; la línea de estado muestra, por ejemplo, "TV Power: NEC 32 bit".
- Para el aire acondicionado, primero pon en el control original el ajuste que quieras (por ejemplo frío y 24 °C), luego presiona Learn en la fila AC 24C y aprieta el botón de encendido del control.
- Recarga la página; en la tabla aparecen los nombres de los protocolos. Prueba los equipos con los botones Send, apuntando el LED IR hacia ellos.
Control del aire acondicionado: ajustar la temperatura sin aprender
En lugar de aprender cada temperatura del aire acondicionado, puedes generar el mensaje en el código. La clase IRac de IRremoteESP8266 arma los mensajes de decenas de marcas, entre ellas Daikin, Mitsubishi, Carrier, Gree, Midea, Samsung, LG, Toshiba y Panasonic, a partir de una estructura común: completas el modo, la temperatura, el ventilador y la aleta, y sendAc() lo envía todo de una vez. Averigua el protocolo de tu equipo con el programa de lectura del paso 1 y escríbelo en el código de abajo. En el Monitor Serie, o enciende o apaga el aire y + y - cambian la temperatura entre 16 y 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}Algunas marcas tienen varios modelos; si el equipo no responde, prueba con model en 2 o 3. La gran ventaja de este método es que puedes ligar la temperatura a un sensor: un termostato sencillo que prende el aire por encima de 26 °C y lo apaga por debajo de 22 °C se escribe en unas pocas líneas. La lógica es la misma que el control con histéresis del artículo termostato con Arduino. Como la estructura del mensaje es común, si cambias de aire acondicionado solo cambias la línea del protocolo.
Ideas de proyectos
- Aire con horario: con la hora NTP, enciende el aire media hora antes de llegar a casa.
- Aire según la temperatura: mide el cuarto con un DHT11 o un DHT22 y maneja el aire automáticamente con IRac.
- Control por Telegram: prende el aire cuando no estás con un mensaje a un bot de Telegram.
- Integración con Home Assistant: agrega las teclas a Home Assistant con MQTT y úsalas con un asistente de voz.
- Apagar la tele en un cuarto vacío: si un sensor PIR no detecta movimiento durante 30 minutos, envía a la tele el código de apagado.
- Control para tiras LED: aprende los controles NEC de 24 o 44 teclas de las tiras RGB y cambia los colores de la tira LED RGB desde el celular.
Errores comunes y cómo resolverlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| No aparece nada en el Monitor Serie | Pin del receptor equivocado, receptor que no es de 38 kHz o cable flojo | Revisa que OUT esté en GPIO 15; prueba el control a 20–50 cm |
| El código del aire llega cortado o como UNKNOWN | Búfer muy chico o tiempo de espera muy corto | Sube el búfer a 1024 y el tiempo de espera a 50 ms (como en los programas) |
| El código se aprende pero el equipo no responde | LED débil o mal apuntado, o se aprendió un código de repetición | Revisa el LED con la cámara y vuelve a aprender con una pulsación corta y única |
| Alcance de solo 1–2 metros | LED conectado directo al GPIO o resistencia demasiado grande | Dale 100 mA con el transistor y 33 Ω, usa un LED de ángulo estrecho |
| La tele Sony no responde a la primera | El protocolo Sony exige repeticiones | send() agrega por sí solo al menos dos repeticiones; vuelve a aprender la tecla |
| Error de timer al compilar | Librería vieja con el core ESP32 3.x | Actualiza IRremoteESP8266 a la versión 2.9.0 o más nueva |
| El aire cambia a otro ajuste con cada envío | Se mezclaron códigos aprendidos con ajustes distintos | Aprende cada ajuste en una fila propia o genera el mensaje con IRac |
| Después de enviar, el receptor aprende un código nuevo | El ESP32 está leyendo su propia señal | Usa disableIRIn() al enviar y pon el receptor detrás del LED |
Un control remoto universal es la forma más barata de volver inteligentes los aparatos viejos de la casa, juntando el Wi-Fi del ESP32 con un circuito IR sencillo. Primero identifica tus controles con el programa de lectura, después aprende y guarda los códigos, y maneja directamente la temperatura del aire con IRac. En la app BlueGrays encontrarás la lectura de códigos de un control con receptor IR, el manejo de un LED y de un foco de 220 V con control remoto, un receptor IR con ESP32 y pantalla LCD y el proyecto ESP32 IR Universal Remote con pantalla OLED, cada uno con diagrama paso a paso y código listo para usar.
Preguntas frecuentes
¿Cómo hacer un control remoto universal con ESP32?
Conectas al ESP32 un receptor IR de 38 kHz y un LED IR manejado por un transistor. La librería IRremoteESP8266 decodifica los códigos de los controles, los guardas en la memoria permanente con Preferences y los vuelves a enviar con los botones de la página web que sirve el ESP32. Así manejas la tele, el aire acondicionado y las tiras LED desde el celular.
¿Qué marcas de aire acondicionado soporta IRremoteESP8266?
La librería reconoce más de cien protocolos, entre ellos Daikin, Mitsubishi, Carrier, Gree, Midea, Samsung, LG, Toshiba, Panasonic y Haier. El programa de lectura te muestra qué protocolo usa tu equipo. Aunque el protocolo no se reconozca, el código se puede guardar con sus tiempos crudos y reenviar tal cual.
¿Cómo aumentar el alcance de un LED infrarrojo?
Maneja el LED con un transistor NPN a unos 100 mA en lugar de conectarlo al GPIO, elige un LED de 940 nm de ángulo estrecho y apúntalo hacia el equipo. El alcance crece con la raíz cuadrada de la corriente: duplicarla solo da unas 1,4 veces más. En salas grandes funciona mejor agregar un segundo LED hacia otra dirección.
¿Por qué el código de mi control aparece como UNKNOWN?
La librería no conoce ese protocolo o la señal se capturó incompleta. Primero sube el búfer de captura a 1024 y el tiempo de espera a 50 ms y vuelve a probar. Si sigue saliendo UNKNOWN, guardar el código con sus tiempos crudos y enviarlo con sendRaw() a 38 kHz funciona con la mayoría de los equipos.
¿Puedo alimentar el receptor IR del ESP32 con 5 V?
Mejor no. Con 5 V, la salida del receptor también sube a 5 V y puede dañar la entrada de 3,3 V del ESP32. Los módulos VS1838B y TSOP38238 funcionan sin problema a 3,3 V, así que conecta el VCC al pin 3V3.
¿Los códigos IR guardados se borran si se va la luz?
No. El programa de esta guía escribe las teclas aprendidas en la partición NVS de la memoria flash del ESP32 con la librería Preferences y las vuelve a cargar al encender. Para borrar un código basta con aprender uno nuevo en la misma fila o llamar a prefs.clear().
Proyectos para hacer después de leer esto
Ver todos los proyectos
Mando a distancia universal ESP32 IR (receptor de infrarrojos + mando + 3 LED + zumbador + pantalla OLED)
¡Lee un mando IR cualquiera con el ESP32 y controla tu propio dispositivo! El receptor infrarrojo (protocolo NEC, 38kHz) capta las señales de un mando de 20 teclas: las teclas 1/2/3 encienden y apagan tres LED distintos y PWR los apaga todos. Si pulsas una tecla desconocida, la OLED muestra su código HEX, así puedes añadir fácilmente los botones de tu propio mando al código.

Mando a distancia con receptor IR ESP32 (con pantalla LCD)
Con el módulo receptor IR TSOP4838, el ESP32 capta las señales del mando de la tele, del aire acondicionado o de cualquier mando infrarrojo. Los códigos en bruto distintos de cero, decodificados con la biblioteca IRremote v4, aparecen en la LCD I2C. Este ejemplo sirve para identificar códigos de mando; no incluye encender, apagar ni regular un LED. Un gran punto de partida para convertir mandos viejos en control domótico.

Leer los códigos de un mando IR
Cada botón del mando de la tele envía un código secreto con una luz que no puedes ver.

Encendido y apagado de leds con receptor de infrarrojos y mando a distancia
Como manejar tres lámparas distintas sin levantarte del sillón: las teclas 1, 2 y 3 del mando encienden los LED azul, rojo y verde, y las teclas 4, 5 y 6 los apagan en el mismo orden.

Reproducir melodías con mando IR y zumbador
Construye una caja de música que toca melodías con los botones del mando de la tele.

Encender una bombilla de 220 V con mando a distancia
Enciende y apaga una bombilla de verdad de tu casa con un mando a distancia, sin levantarte del sofá.

Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
En este proyecto, convertimos el ESP32 en un servidor web asíncrono que puedes controlar desde tu teléfono o tu ordenador, siempre que estén conectados a la misma red Wi-Fi. Gracias a la biblioteca ESPAsyncWebServer, el servidor puede procesar varias solicitudes al mismo tiempo (a diferencia del clásico WebServer.h, que se bloquea con una sola solicitud).

Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

