Guías · 11 min de lectura

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.

Módulo receptor infrarrojo VS1838B
Receptor infrarrojo de 38 kHz: demodula la señal del control y la convierte en pulsos digitales que el ESP32 puede leer.

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

ProtocoloPortadoraLongitudDónde se usaNota
NEC38 kHz32 bitsMuchas teles, controles de tiras LED, el control de los kits de ArduinoEnvía un código de repetición corto al mantener la tecla
Samsung38 kHz32 bitsTelevisores SamsungParecido al NEC, con otro pulso de inicio
Sony SIRC40 kHz12, 15 o 20 bitsTeles y equipos de audio SonyEl comando se debe enviar al menos 3 veces seguidas
RC5 / RC636 kHz13–20 bits o másPhilips y algunas marcas europeasUn bit (toggle) cambia con cada nueva pulsación
LG38 kHz28 bitsTeles y aires acondicionados LGLa librería lo reconoce como protocolo aparte
Aire acondicionado (Daikin, Mitsubishi, Gree, Midea, Carrier, etc.)Casi siempre 38 kHz24–280 bitsMinisplitsCada 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
ESP32
ESP32
IR kumanda
IR kumanda
Transistor NPN
Transistor NPN
Componente y pinConexión al ESP32Nota
OUT del receptor IRGPIO 15El módulo trae su propia resistencia pull-up
VCC / GND del receptor IR3V3 / GNDNo uses 5 V: la salida también subiría a 5 V
Base del transistorGPIO 4 a través de 470 ΩCorriente de base de unos 5,5 mA
Emisor del transistorGND—
Colector del transistorCá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 µFEntre 5V y GND, cerca del LEDAbsorbe los picos de corriente
No conectes el LED IR sin resistencia ni directo a un pin GPIO. El límite absoluto de los pines del ESP32 es de 40 mA y el valor seguro ronda los 20 mA; con esa corriente el LED solo llega a unos pocos metros y el pin sufre. El orden de las patas del transistor cambia según el modelo: visto de frente suele ser E-B-C en el 2N2222 y el S8050, pero C-B-E en el BC337. Revisa la distribución de pines de tu transistor antes de montarlo; los detalles están en ¿Qué es un transistor?.

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 LEDUn LED (5 V)Dos LED en serie (5 V)Nota
50 mA68 Ω39 ΩPoco alcance, bajo consumo
100 mA33 Ω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 LEDIntensidad radiante (LED de ángulo estrecho)Alcance teóricoAlcance práctico
20 mA, directo del GPIOUnos 26 mW/srUnos 10 m3–5 m
100 mA, transistor y 33 ΩUnos 130 mW/srUnos 23 m8–12 m
200 mA en pulsos, transistor y 15 ΩUnos 260 mW/srUnos 32 m12–16 m
2 LED × 100 mA, en distintas direcciones130 mW/sr cada uno23 m por direcciónCobertura amplia en todo el cuarto
Puedes comprobar si el LED IR realmente prende con la cámara del celular: apúntala al LED y presiona enviar; en la pantalla debe verse un brillo morado. Las cámaras traseras a veces tienen filtro infrarrojo; si no ves nada, prueba con la frontal.

Instalar la librería IRremoteESP8266

  1. 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?.
  2. En el Gestor de librerías busca IRremoteESP8266 e instala la librería de David Conran y su equipo.
  3. 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.
  4. 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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ódigoQué hace
Estructura IrCodeGuarda 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, /statusLas direcciones que llaman los botones de la página; la línea de estado se actualiza cada segundo
  1. 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.
  2. Presiona Learn en la fila TV Power; arriba en la página aparece "Press the key for TV Power".
  3. 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".
  4. 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.
  5. 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.

C++ (Arduino IDE)
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íntomaCausa probableSolución
No aparece nada en el Monitor SeriePin del receptor equivocado, receptor que no es de 38 kHz o cable flojoRevisa que OUT esté en GPIO 15; prueba el control a 20–50 cm
El código del aire llega cortado o como UNKNOWNBúfer muy chico o tiempo de espera muy cortoSube 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 respondeLED débil o mal apuntado, o se aprendió un código de repeticiónRevisa el LED con la cámara y vuelve a aprender con una pulsación corta y única
Alcance de solo 1–2 metrosLED conectado directo al GPIO o resistencia demasiado grandeDale 100 mA con el transistor y 33 Ω, usa un LED de ángulo estrecho
La tele Sony no responde a la primeraEl protocolo Sony exige repeticionessend() agrega por sí solo al menos dos repeticiones; vuelve a aprender la tecla
Error de timer al compilarLibrería vieja con el core ESP32 3.xActualiza IRremoteESP8266 a la versión 2.9.0 o más nueva
El aire cambia a otro ajuste con cada envíoSe mezclaron códigos aprendidos con ajustes distintosAprende cada ajuste en una fila propia o genera el mensaje con IRac
Después de enviar, el receptor aprende un código nuevoEl ESP32 está leyendo su propia señalUsa disableIRIn() al enviar y pon el receptor detrás del LED
Si prefieres escribir el nombre y la contraseña del Wi-Fi desde el celular en vez de en el código, usa la librería WiFiManager; si llevas el control a otra casa, no tendrás que volver a subir el programa.

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().

Ver todos los proyectos
Mando a distancia universal ESP32 IR (receptor de infrarrojos + mando + 3 LED + zumbador + pantalla OLED)
ES-39Avanzado
Premium

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.

4.5(9)
16
Mando a distancia con receptor IR ESP32 (con pantalla LCD)
ES-22Intermedio
Premium

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.

4.7(19)
30
Leer los códigos de un mando IR
AR-16Principiante
Premium

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.

4.5(39)
55
Encendido y apagado de leds con receptor de infrarrojos y mando a distancia
AR-17Intermedio
Premium

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.

4.7(45)
66
Reproducir melodías con mando IR y zumbador
AR-18Principiante
Premium

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.

4.8(58)
75
Encender una bombilla de 220 V con mando a distancia
AR-21Avanzado
Premium

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

4.4(23)
31
Servidor web asíncrono ESP32 (con indicación de IP en la pantalla LCD)
ES-27Avanzado

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

4.8(16)
26
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
ES-25Avanzado

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.

4.4(21)
38