Telecomando universale ESP32: impara, salva e invia codici IR
Crea un telecomando universale ESP32: impara i codici di TV e condizionatore con IRremoteESP8266, salvali e inviali dal telefono. Protocolli, LED IR e portata.
Un telecomando universale ESP32 riunisce in un solo dispositivo i telecomandi di TV, condizionatore, striscia LED e stereo, e li gestisci tutti da una pagina web sul telefono. Il principio è semplice: con un ricevitore a infrarossi l'ESP32 impara il codice inviato dal telecomando originale, lo salva nella memoria permanente e lo reinvia quando vuoi tramite un LED infrarosso. Poiché la libreria IRremoteESP8266 riconosce più di cento protocolli, decodifica sia i tasti di un televisore sia i lunghi messaggi dei climatizzatori, che contengono temperatura e velocità della ventola.
In questa guida vedrai prima come funzionano i telecomandi a infrarossi e in cosa differiscono i protocolli NEC, Sony, Samsung, RC5 e quelli dei condizionatori. Poi imparerai a pilotare il LED IR con un transistor, a calcolare resistenze e portata, a leggere i codici del tuo telecomando, a salvarli nell'ESP32 e a inviarli dal telefono, e infine a comandare il condizionatore direttamente con la temperatura, senza apprendere nulla. Gli sketch funzionano con le versioni 2.x e 3.x del core ESP32.

Come funziona un telecomando IR universale?
Un telecomando usa un LED IR che emette luce invisibile a 940 nm. Poiché anche il sole e le lampade emettono infrarossi, il telecomando non tiene il LED acceso: lo fa lampeggiare 38.000 volte al secondo (portante a 38 kHz) e codifica l'informazione nella durata di questi treni di impulsi. I moduli ricevitori come il VS1838B o il TSOP38238 rispondono solo a quella frequenza: eliminano la portante e portano l'uscita a LOW durante ogni treno. L'ESP32 legge quindi il codice misurando in microsecondi la durata di impulsi e pause. In trasmissione avviene il contrario: l'ESP32 applica gli stessi tempi al LED IR con una modulazione a 38 kHz. Le basi del ricevitore le abbiamo spiegate in ricevitore IR e telecomando.
| Protocollo | Portante | Lunghezza | Dove si usa | Nota |
|---|---|---|---|---|
| NEC | 38 kHz | 32 bit | Molti televisori, telecomandi delle strisce LED, il telecomando dei kit Arduino | Tenendo premuto il tasto invia un breve codice di ripetizione |
| Samsung | 38 kHz | 32 bit | Televisori Samsung | Simile al NEC, con un impulso iniziale diverso |
| Sony SIRC | 40 kHz | 12, 15 o 20 bit | TV e impianti audio Sony | Il comando va inviato almeno 3 volte di fila |
| RC5 / RC6 | 36 kHz | 13–20 bit e oltre | Philips e alcune marche europee | Un bit (toggle) cambia a ogni nuova pressione |
| LG | 38 kHz | 28 bit | TV e condizionatori LG | La libreria lo riconosce come protocollo a sé |
| Condizionatore (Daikin, Mitsubishi, Gree, Midea, Argo, ecc.) | Quasi sempre 38 kHz | 24–280 bit | Climatizzatori split | Ogni pressione invia lo stato completo: modo, temperatura e ventola |
La differenza più importante della tabella è quella tra TV e condizionatore. Il telecomando del televisore invia un codice tasto: "volume su" è sempre lo stesso numero a 32 bit, ed è la TV a sapere a che volume si trova. Il telecomando del climatizzatore invece invia tutto lo stato che vedi sul suo display: acceso, raffreddamento, 24 °C, ventola automatica, aletta in movimento. Un codice appreso da un condizionatore è quindi una fotografia dell'impostazione di quel momento; quando lo reinvii, l'apparecchio passa esattamente a quell'impostazione. Per cambiare la temperatura grado per grado serve una registrazione per ogni grado, oppure generi il messaggio nel codice, come vedrai più avanti.
Materiali e circuito
- Scheda di sviluppo ESP32 (ESP32 DevKit a 30 o 38 pin)
- Modulo ricevitore IR a 38 kHz (VS1838B o TSOP38238)
- LED IR da 940 nm e 5 mm (un modello ad angolo stretto come il TSAL6100 aumenta la portata)
- Transistor NPN: 2N2222, BC337 o S8050
- Resistenze da 470 Ω (base) e 33 Ω (LED), 1/4 W
- Condensatore elettrolitico da 100 µF
- Breadboard, cavetti jumper e un alimentatore USB da 5 V



| Componente e pin | Collegamento all'ESP32 | Nota |
|---|---|---|
| OUT del ricevitore IR | GPIO 15 | Il modulo ha già la sua resistenza di pull-up |
| VCC / GND del ricevitore IR | 3V3 / GND | Niente 5 V: anche l'uscita salirebbe a 5 V |
| Base del transistor | GPIO 4 tramite 470 Ω | Corrente di base di circa 5,5 mA |
| Emettitore del transistor | GND | — |
| Collettore del transistor | Catodo del LED IR (piedino corto) | — |
| Anodo del LED IR (piedino lungo) | 5V (VIN) tramite 33 Ω | Corrente di impulso di circa 100 mA |
| Condensatore da 100 µF | Tra 5V e GND, vicino al LED | Assorbe i picchi di corrente |
Transistor di pilotaggio del LED IR: calcolo delle resistenze
Qui il transistor fa da interruttore: quando GPIO 4 va a HIGH scorre la corrente di base, il transistor va in saturazione e la corrente del LED arriva dalla linea dei 5V e non dall'ESP32. La resistenza del LED si ricava con la legge di Ohm: R = (5 − 1,4 − 0,2) / 0,1 ≈ 34 Ω. Qui 1,4 V è la tensione diretta del LED IR a 100 mA e 0,2 V la caduta sul transistor saturo; il valore commerciale più vicino è 33 Ω. Nella resistenza di base scorrono (3,3 − 0,7) / 470 ≈ 5,5 mA, più che sufficienti per saturare il transistor con 100 mA di collettore. La potenza istantanea sulla resistenza è 0,1² × 33 ≈ 0,33 W, ma a 38 kHz il LED è acceso solo metà del tempo e non per tutto il messaggio, quindi la potenza media resta sotto 0,1 W e basta una resistenza da 1/4 W. Puoi provare altri valori con il calcolatore della resistenza per LED e lo strumento transistor.
| Corrente del LED | Un LED (5 V) | Due LED in serie (5 V) | Nota |
|---|---|---|---|
| 50 mA | 68 Ω | 39 Ω | Portata breve, consumi bassi |
| 100 mA | 33 Ω | 22 Ω | Consigliato; sicuro nell'uso continuo |
| 200 mA (solo impulsivo) | 15 Ω | 8,2 Ω | Portata massima; controlla il limite di corrente impulsiva del LED |
Calcolo della portata: fin dove arriva il telecomando?
La luce si indebolisce con il quadrato della distanza: l'irradianza che arriva al ricevitore è E = Ie / d². Ie è l'intensità radiante del LED per steradiante (mW/sr) e la trovi nel datasheet. L'irradianza minima di cui ha bisogno un ricevitore della famiglia TSOP38238 (Ee min) è di circa 0,25 mW/m². Ricavando la distanza si ottiene d = √(Ie / Ee min). Un LED ad angolo stretto di ±10° come il TSAL6100 fornisce circa 130 mW/sr a 100 mA: d = √(130 / 0,25) = √520 ≈ 23 m. È il limite teorico, con il LED puntato dritto sul ricevitore e la stanza al buio; tra luce del sole, lampade fluorescenti e angolazione, in pratica conta su circa la metà. Raddoppiare la corrente aumenta la portata solo di √2 ≈ 1,4 volte, quindi in una stanza grande spesso conviene un secondo LED rivolto in un'altra direzione.
| Corrente e pilotaggio del LED | Intensità radiante (LED ad angolo stretto) | Portata teorica | Portata pratica |
|---|---|---|---|
| 20 mA, direttamente dal GPIO | Circa 26 mW/sr | Circa 10 m | 3–5 m |
| 100 mA, transistor e 33 Ω | Circa 130 mW/sr | Circa 23 m | 8–12 m |
| 200 mA impulsivi, transistor e 15 Ω | Circa 260 mW/sr | Circa 32 m | 12–16 m |
| 2 LED × 100 mA, in direzioni diverse | 130 mW/sr ciascuno | 23 m per direzione | Ampia copertura della stanza |
Installare la libreria IRremoteESP8266
- Nell'IDE Arduino installa il pacchetto ESP32 dal Gestore schede e scegli la scheda ESP32 Dev Module; l'installazione è spiegata in Che cos'è l'ESP32?.
- Nel Gestore librerie cerca IRremoteESP8266 e installa la libreria di David Conran e del suo team.
- Se usi la versione 3.x del core ESP32, scegli la versione 2.9.0 o successiva della libreria; la 2.8.6 e precedenti non compilano sul core 3.x per un errore del timer.
- La libreria IRremote, dal nome simile, è un'altra libreria; gli sketch di questa guida sono per IRremoteESP8266.
Passo 1: leggere i tasti del telecomando
Il primo sketch decodifica ogni segnale che arriva al ricevitore e stampa tre informazioni nel Monitor seriale: protocollo e codice, una riga leggibile con lo stato se si tratta di un condizionatore e infine i tempi grezzi. Il buffer di cattura è impostato a 1024 elementi e il timeout a 50 ms; i messaggi dei climatizzatori contengono centinaia di impulsi e arrivano in più parti, e con i valori predefiniti verrebbero troncati. Carica il codice, apri il Monitor seriale a 115200 baud, punta il telecomando verso il ricevitore e premi un tasto.
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 il tasto di accensione di una TV LG vedrai una riga come Protocol : NEC, Code : 0x20DF10EF (32 Bits), con una Samsung SAMSUNG 0xE0E040BF. Con il telecomando di un condizionatore il nome del protocollo sarà per esempio DAIKIN, ARGO o COOLIX, seguito da una riga con modo, temperatura e ventola. Se tieni premuto un tasto, i telecomandi NEC inviano un breve codice di ripetizione al posto del codice vero; durante l'apprendimento va ignorato. Quando la libreria non riconosce il protocollo scrive UNKNOWN; questi codici si possono comunque salvare con i loro tempi grezzi e reinviare identici.
Passo 2: salvare i codici e inviarli dal telefono
Il vero telecomando universale è il codice qui sotto. L'ESP32 si collega alla rete Wi-Fi e offre una pagina web con sei tasti; ogni riga ha un pulsante Learn (impara) e uno Send (invia). Dopo aver premuto Learn hai 10 secondi per premere il tasto del telecomando originale; l'ESP32 decodifica il codice e lo scrive nella memoria permanente (NVS) con la libreria Preferences, così i codici restano anche se manca la corrente. I codici TV vengono salvati come protocollo, numero di bit e valore a 64 bit, quelli dei condizionatori con tutti i byte di stato e quelli sconosciuti con i tempi grezzi. Per le basi del web server guarda web server 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 codice | A cosa serve |
|---|---|
| Struttura IrCode | Conserva protocollo, numero di bit, codice TV o byte di stato del condizionatore e lunghezza grezza di un tasto |
| storeResult() | Copia il segnale ricevuto nella struttura; scrive i tempi grezzi dei codici sconosciuti in una chiave separata |
| sendSlot() | Chiama sendRaw() per i codici grezzi, send(tipo, stato, byte) per un condizionatore o send(tipo, valore, bit) per una TV |
| Preferences (NVS) | Salva i tasti nelle chiavi c0–c5 e i tempi grezzi in r0–r5 |
| disableIRIn() / enableIRIn() | Spegne il ricevitore durante l'invio, così l'ESP32 non impara il proprio segnale |
| /learn, /send, /status | Gli indirizzi richiamati dai pulsanti della pagina; la riga di stato si aggiorna ogni secondo |
- Inserisci nome e password della rete, carica il codice e apri su un telefono connesso alla stessa rete l'indirizzo IP mostrato nel Monitor seriale.
- Premi Learn nella riga TV Power; in cima alla pagina compare "Press the key for TV Power".
- Entro 10 secondi punta il telecomando della TV verso il ricevitore e premi una volta il tasto di accensione; la riga di stato mostra per esempio "TV Power: NEC 32 bit".
- Per il condizionatore, imposta prima sul telecomando originale la regolazione che vuoi (per esempio raffreddamento a 24 °C), poi premi Learn nella riga AC 24C e il tasto di accensione del telecomando.
- Ricarica la pagina; nella tabella compaiono i nomi dei protocolli. Prova i dispositivi con i pulsanti Send, puntando il LED IR verso di loro.
Telecomando del condizionatore: impostare la temperatura senza apprendimento
Invece di imparare ogni temperatura del condizionatore, puoi generare il messaggio nel codice. La classe IRac di IRremoteESP8266 costruisce i messaggi di decine di marche, tra cui Daikin, Mitsubishi, Argo, Gree, Midea, Samsung, LG, Toshiba e Panasonic, partendo da una struttura comune: imposti modo, temperatura, ventola e aletta e sendAc() invia tutto in un colpo solo. Scopri il protocollo del tuo condizionatore con lo sketch di lettura del passo 1 e scrivilo nel codice qui sotto. Nel Monitor seriale o accende e spegne il condizionatore, + e - cambiano la temperatura tra 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}Alcune marche hanno più modelli; se il condizionatore non risponde, prova a impostare model a 2 o 3. Il grande vantaggio di questo metodo è che puoi legare la temperatura a un sensore: un semplice termostato che accende il condizionatore sopra i 26 °C e lo spegne sotto i 22 °C si scrive in poche righe. La logica è la stessa del controllo con isteresi dell'articolo termostato con Arduino. Siccome la struttura del messaggio è comune, se cambi condizionatore modifichi solo la riga del protocollo.
Idee di progetto
- Condizionatore programmato: con l'ora NTP accendi il condizionatore mezz'ora prima di rientrare.
- Condizionatore in base alla temperatura: misura la stanza con un DHT11 o un DHT22 e gestisci il condizionatore in automatico con IRac.
- Comando da Telegram: accendi il condizionatore quando sei fuori con un messaggio a un bot Telegram.
- Integrazione con Home Assistant: aggiungi i tasti a Home Assistant tramite MQTT e usali con un assistente vocale.
- TV spenta nella stanza vuota: se un sensore PIR non rileva movimento per 30 minuti, invia alla TV il codice di spegnimento.
- Telecomando per strisce LED: impara i telecomandi NEC a 24 o 44 tasti delle strisce RGB e cambia i colori della striscia LED RGB dal telefono.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Nel Monitor seriale non compare nulla | Pin del ricevitore sbagliato, ricevitore non a 38 kHz o filo allentato | Controlla che OUT sia su GPIO 15; prova il telecomando a 20–50 cm |
| Il codice del condizionatore arriva troncato o come UNKNOWN | Buffer troppo piccolo o timeout troppo breve | Porta il buffer a 1024 e il timeout a 50 ms (come negli sketch) |
| Il codice viene appreso ma il dispositivo non risponde | LED debole o puntato male, oppure è stato appreso un codice di ripetizione | Controlla il LED con la fotocamera e riapprendi con una pressione breve e singola |
| Portata di soli 1–2 metri | LED collegato direttamente al GPIO o resistenza troppo grande | Fornisci 100 mA con il transistor e 33 Ω, usa un LED ad angolo stretto |
| La TV Sony non risponde al primo colpo | Il protocollo Sony richiede ripetizioni | send() aggiunge da solo almeno due ripetizioni; riapprendi il tasto |
| Errore del timer in compilazione | Libreria vecchia con il core ESP32 3.x | Aggiorna IRremoteESP8266 alla versione 2.9.0 o successiva |
| Il condizionatore cambia impostazione a ogni invio | Si sono mescolati codici appresi con impostazioni diverse | Impara ogni impostazione su una riga a sé o genera il messaggio con IRac |
| Dopo un invio il ricevitore impara un nuovo codice | L'ESP32 sta leggendo il proprio segnale | Usa disableIRIn() durante l'invio e metti il ricevitore dietro il LED |
Un telecomando universale è il modo più economico per rendere smart i vecchi elettrodomestici di casa, unendo il Wi-Fi dell'ESP32 a un semplice circuito IR. Prima riconosci i tuoi telecomandi con lo sketch di lettura, poi impara e salva i codici e gestisci direttamente la temperatura del condizionatore con IRac. Nell'app BlueGrays trovi la lettura dei codici di un telecomando con ricevitore IR, il comando di un LED e di una lampada a 220 V con il telecomando, un ricevitore IR per ESP32 con display LCD e il progetto ESP32 IR Universal Remote con display OLED, ognuno con schema del circuito passo passo e codice pronto.
Domande frequenti
Come si fa un telecomando universale con ESP32?
Colleghi all'ESP32 un ricevitore IR a 38 kHz e un LED IR pilotato da un transistor. La libreria IRremoteESP8266 decodifica i codici dei telecomandi, li salvi nella memoria permanente con Preferences e li reinvii con i pulsanti della pagina web servita dall'ESP32. Così comandi TV, condizionatore e strisce LED dal telefono.
Quali marche di condizionatori supporta IRremoteESP8266?
La libreria riconosce più di cento protocolli, tra cui Daikin, Mitsubishi, Argo, Gree, Midea, Samsung, LG, Toshiba, Panasonic e Haier. Lo sketch di lettura ti mostra quale protocollo usa il tuo condizionatore. Anche se il protocollo non è riconosciuto, il codice si può salvare con i tempi grezzi e reinviare identico.
Come aumentare la portata di un LED infrarosso?
Pilota il LED con un transistor NPN a circa 100 mA invece che dal GPIO, scegli un LED a 940 nm ad angolo stretto e puntalo verso il dispositivo. La portata cresce con la radice quadrata della corrente, quindi raddoppiarla dà solo circa 1,4 volte in più. Nelle stanze grandi è più efficace aggiungere un secondo LED rivolto in un'altra direzione.
Perché il codice del mio telecomando compare come UNKNOWN?
O la libreria non conosce quel protocollo, o il segnale è stato catturato solo in parte. Per prima cosa porta il buffer di cattura a 1024 e il timeout a 50 ms e riprova. Se resta UNKNOWN, salvare il codice con i tempi grezzi e inviarlo con sendRaw() a 38 kHz funziona con la maggior parte dei dispositivi.
Posso alimentare il ricevitore IR dell'ESP32 a 5 V?
Meglio di no. Alimentato a 5 V, anche l'uscita del ricevitore sale a 5 V e può danneggiare l'ingresso a 3,3 V dell'ESP32. I moduli VS1838B e TSOP38238 funzionano senza problemi a 3,3 V, quindi collega il VCC al pin 3V3.
I codici IR salvati si cancellano se manca la corrente?
No. Lo sketch di questa guida scrive i tasti appresi nella partizione NVS della memoria flash dell'ESP32 con la libreria Preferences e li ricarica all'avvio. Per cancellare un codice basta impararne uno nuovo sulla stessa riga o chiamare prefs.clear().
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Telecomando universale ESP32 IR (ricevitore IR + telecomando + 3 LED + cicalino + OLED)
Leggi un telecomando IR qualsiasi con l'ESP32 e controlla il tuo dispositivo! Il ricevitore a infrarossi (protocollo NEC, 38kHz) cattura i segnali di un telecomando a 20 tasti: i tasti 1/2/3 accendono e spengono tre LED, PWR li spegne tutti. Se premi un tasto sconosciuto, l'OLED mostra il suo codice HEX, così puoi aggiungere facilmente al codice i tasti del tuo telecomando.

Telecomando con ricevitore IR ESP32 (con schermo LCD)
Con il modulo ricevitore IR TSOP4838 l'ESP32 cattura i segnali del telecomando della TV, del condizionatore o di qualsiasi telecomando a infrarossi. I codici grezzi diversi da zero, decodificati con la libreria IRremote v4, compaiono sul display LCD I2C. L'esempio serve a riconoscere i codici; non include accensione, spegnimento o regolazione di un LED. Un ottimo inizio per trasformare vecchi telecomandi in controlli smart home.

Leggere i codici di un telecomando IR
Ogni tasto del telecomando della TV invia un codice segreto con una luce che non puoi vedere.

Accendere e spegnere LED con ricevitore IR e telecomando
Come comandare tre lampade senza alzarti dalla poltrona: i tasti 1, 2 e 3 del telecomando accendono i LED blu, rosso e verde, e i tasti 4, 5 e 6 li spengono nello stesso ordine.

Suonare melodie con telecomando IR e cicalino
Costruisci un carillon che suona melodie con i tasti del telecomando della TV. Un ricevitore a infrarossi cattura il segnale del telecomando; un tasto fa suonare al cicalino una vivace musica da…

Accendere una lampadina 220V con il telecomando
Accendi e spegni una vera lampadina di casa con un telecomando, senza alzarti dal divano.

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

Connessione Wi-Fi STA con ESP32 (con display LCD)
In questo progetto colleghiamo l'ESP32 alla rete Wi-Fi domestica in modalità Station (STA) in modo sicuro e tollerante agli errori. Separiamo SSID e password in un file secrets.h per impedire fughe su Git, impostiamo un meccanismo di riconnessione automatica e visualizziamo il livello del segnale RSSI e l'indirizzo IP su un display LCD I2C. Il LED interno funge da indicatore di stato.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

