Guide · 10 min di lettura

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.

Modulo ricevitore a infrarossi VS1838B
Ricevitore a infrarossi a 38 kHz: demodula il segnale del telecomando in impulsi digitali che l'ESP32 può leggere.

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.

ProtocolloPortanteLunghezzaDove si usaNota
NEC38 kHz32 bitMolti televisori, telecomandi delle strisce LED, il telecomando dei kit ArduinoTenendo premuto il tasto invia un breve codice di ripetizione
Samsung38 kHz32 bitTelevisori SamsungSimile al NEC, con un impulso iniziale diverso
Sony SIRC40 kHz12, 15 o 20 bitTV e impianti audio SonyIl comando va inviato almeno 3 volte di fila
RC5 / RC636 kHz13–20 bit e oltrePhilips e alcune marche europeeUn bit (toggle) cambia a ogni nuova pressione
LG38 kHz28 bitTV e condizionatori LGLa libreria lo riconosce come protocollo a sé
Condizionatore (Daikin, Mitsubishi, Gree, Midea, Argo, ecc.)Quasi sempre 38 kHz24–280 bitClimatizzatori splitOgni 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
ESP32
ESP32
IR kumanda
IR kumanda
Transistor NPN
Transistor NPN
Componente e pinCollegamento all'ESP32Nota
OUT del ricevitore IRGPIO 15Il modulo ha già la sua resistenza di pull-up
VCC / GND del ricevitore IR3V3 / GNDNiente 5 V: anche l'uscita salirebbe a 5 V
Base del transistorGPIO 4 tramite 470 ΩCorrente di base di circa 5,5 mA
Emettitore del transistorGND—
Collettore del transistorCatodo 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 µFTra 5V e GND, vicino al LEDAssorbe i picchi di corrente
Non pilotare il LED IR senza resistenza né direttamente da un pin GPIO. Il limite assoluto dei pin dell'ESP32 è di 40 mA e il valore sicuro è intorno ai 20 mA; con questa corrente il LED arriva solo a pochi metri e il pin viene sollecitato. L'ordine dei piedini dei transistor dipende dal modello: visto di fronte è di solito E-B-C per 2N2222 e S8050, ma C-B-E per il BC337. Controlla la piedinatura del tuo transistor prima di montarlo; i dettagli sono in Che cos'è un transistor?.

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 LEDUn LED (5 V)Due LED in serie (5 V)Nota
50 mA68 Ω39 ΩPortata breve, consumi bassi
100 mA33 Ω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 LEDIntensità radiante (LED ad angolo stretto)Portata teoricaPortata pratica
20 mA, direttamente dal GPIOCirca 26 mW/srCirca 10 m3–5 m
100 mA, transistor e 33 ΩCirca 130 mW/srCirca 23 m8–12 m
200 mA impulsivi, transistor e 15 ΩCirca 260 mW/srCirca 32 m12–16 m
2 LED × 100 mA, in direzioni diverse130 mW/sr ciascuno23 m per direzioneAmpia copertura della stanza
Puoi verificare se il LED IR si accende davvero con la fotocamera del telefono: inquadra il LED e premi invia; sullo schermo deve comparire un bagliore viola. Le fotocamere posteriori a volte hanno un filtro infrarosso: se non vedi nulla, prova con quella frontale.

Installare la libreria IRremoteESP8266

  1. 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?.
  2. Nel Gestore librerie cerca IRremoteESP8266 e installa la libreria di David Conran e del suo team.
  3. 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.
  4. 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.

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

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 codiceA cosa serve
Struttura IrCodeConserva 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, /statusGli indirizzi richiamati dai pulsanti della pagina; la riga di stato si aggiorna ogni secondo
  1. 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.
  2. Premi Learn nella riga TV Power; in cima alla pagina compare "Press the key for TV Power".
  3. 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".
  4. 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.
  5. 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.

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}

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

SintomoCausa probabileSoluzione
Nel Monitor seriale non compare nullaPin del ricevitore sbagliato, ricevitore non a 38 kHz o filo allentatoControlla che OUT sia su GPIO 15; prova il telecomando a 20–50 cm
Il codice del condizionatore arriva troncato o come UNKNOWNBuffer troppo piccolo o timeout troppo brevePorta il buffer a 1024 e il timeout a 50 ms (come negli sketch)
Il codice viene appreso ma il dispositivo non rispondeLED debole o puntato male, oppure è stato appreso un codice di ripetizioneControlla il LED con la fotocamera e riapprendi con una pressione breve e singola
Portata di soli 1–2 metriLED collegato direttamente al GPIO o resistenza troppo grandeFornisci 100 mA con il transistor e 33 Ω, usa un LED ad angolo stretto
La TV Sony non risponde al primo colpoIl protocollo Sony richiede ripetizionisend() aggiunge da solo almeno due ripetizioni; riapprendi il tasto
Errore del timer in compilazioneLibreria vecchia con il core ESP32 3.xAggiorna IRremoteESP8266 alla versione 2.9.0 o successiva
Il condizionatore cambia impostazione a ogni invioSi sono mescolati codici appresi con impostazioni diverseImpara ogni impostazione su una riga a sé o genera il messaggio con IRac
Dopo un invio il ricevitore impara un nuovo codiceL'ESP32 sta leggendo il proprio segnaleUsa disableIRIn() durante l'invio e metti il ricevitore dietro il LED
Se preferisci inserire nome e password del Wi-Fi dal telefono invece che nel codice, usa la libreria WiFiManager; se porti il telecomando in un'altra casa, non dovrai ricaricare lo sketch.

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

Vedi tutti i progetti
Telecomando universale ESP32 IR (ricevitore IR + telecomando + 3 LED + cicalino + OLED)
ES-39Avanzato
Premium

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.

4.5(9)
16
Telecomando con ricevitore IR ESP32 (con schermo LCD)
ES-22Intermedio
Premium

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.

4.7(19)
30
Leggere i codici di un telecomando IR
AR-16Principiante
Premium

Leggere i codici di un telecomando IR

Ogni tasto del telecomando della TV invia un codice segreto con una luce che non puoi vedere.

4.5(39)
55
Accendere e spegnere LED con ricevitore IR e telecomando
AR-17Intermedio
Premium

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.

4.7(45)
66
Suonare melodie con telecomando IR e cicalino
AR-18Principiante
Premium

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…

4.8(58)
75
Accendere una lampadina 220V con il telecomando
AR-21Avanzato
Premium

Accendere una lampadina 220V con il telecomando

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

4.4(23)
31
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

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

4.8(16)
26
Connessione Wi-Fi STA con ESP32 (con display LCD)
ES-25Avanzato

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.

4.4(21)
38