Guides · 11 min de lecture

Télécommande universelle ESP32 : copier et envoyer les codes IR

Fabrique une télécommande universelle ESP32 : récepteur infrarouge, codes TV et clim appris avec IRremoteESP8266, envoi depuis ton téléphone, LED IR et portée.

Une télécommande universelle ESP32 regroupe les télécommandes de la télé, du climatiseur, du ruban LED et de la chaîne hi-fi dans un seul appareil, que tu pilotes depuis une page web sur ton téléphone. Le principe est simple : grâce à un récepteur infrarouge, l'ESP32 apprend le code envoyé par la télécommande d'origine, l'enregistre dans sa mémoire permanente et le renvoie à la demande par une LED infrarouge. Comme la bibliothèque IRremoteESP8266 reconnaît plus d'une centaine de protocoles, elle décode aussi bien les touches d'un téléviseur que les longues trames de clim qui contiennent la température et la vitesse du ventilateur.

Dans ce guide, tu verras d'abord comment fonctionne une télécommande infrarouge et ce qui distingue les protocoles NEC, Sony, Samsung, RC5 et ceux des climatiseurs. Tu apprendras ensuite à piloter la LED IR avec un transistor, à calculer les résistances et la portée, à lire les codes d'une télécommande, à les enregistrer dans l'ESP32 et à les envoyer depuis ton téléphone, puis à commander un climatiseur directement par sa température, sans rien apprendre. Les programmes fonctionnent avec les versions 2.x et 3.x du core ESP32.

Module récepteur infrarouge VS1838B
Récepteur infrarouge 38 kHz : il démodule le signal de la télécommande et le transforme en impulsions numériques que l'ESP32 peut lire.

Comment fonctionne une télécommande IR universelle ?

Une télécommande utilise une LED infrarouge qui émet une lumière invisible de 940 nm. Comme le soleil et les lampes émettent aussi de l'infrarouge, la télécommande n'allume pas la LED en continu : elle la fait clignoter 38 000 fois par seconde (porteuse de 38 kHz) et code l'information dans la durée de ces salves. Les récepteurs comme le VS1838B ou le TSOP38238 ne réagissent qu'à cette fréquence : ils retirent la porteuse et passent leur sortie à LOW pendant chaque salve. L'ESP32 lit donc le code en mesurant en microsecondes la durée des impulsions et des silences. À l'émission, c'est l'inverse : l'ESP32 applique les mêmes durées à la LED IR avec une modulation à 38 kHz. Nous avons présenté les bases du récepteur dans récepteur IR et télécommande.

ProtocolePorteuseLongueurAppareilsRemarque
NEC38 kHz32 bitsNombreux téléviseurs, télécommandes de rubans LED, kits ArduinoEnvoie un court code de répétition quand on maintient la touche
Samsung38 kHz32 bitsTéléviseurs SamsungProche du NEC, avec une impulsion de départ différente
Sony SIRC40 kHz12, 15 ou 20 bitsTéléviseurs et chaînes SonyLa commande doit être envoyée au moins 3 fois de suite
RC5 / RC636 kHz13 à 20 bits et plusPhilips et certaines marques européennesUn bit (toggle) change à chaque nouvel appui
LG38 kHz28 bitsTéléviseurs et climatiseurs LGLa bibliothèque le reconnaît comme un protocole à part
Climatiseur (Daikin, Mitsubishi, Atlantic/Fujitsu, Gree, Midea, etc.)38 kHz le plus souvent24 à 280 bitsClimatiseurs splitChaque appui envoie l'état complet : mode, température, ventilation

La différence la plus importante du tableau oppose la télé au climatiseur. Une télécommande de téléviseur envoie un code de touche : « volume + » est toujours le même nombre de 32 bits, et c'est le téléviseur qui connaît son volume actuel. Une télécommande de clim, elle, envoie tout l'état affiché sur son écran : marche, froid, 24 °C, ventilation auto, volet oscillant. Un code appris sur un climatiseur est donc une photo du réglage du moment ; quand tu le renvoies, la clim passe exactement à ce réglage. Pour changer la température degré par degré, il faut un enregistrement par degré, ou bien générer la trame dans le code comme on le verra plus bas.

Matériel et montage

  • Carte de développement ESP32 (ESP32 DevKit, 30 ou 38 broches)
  • Module récepteur infrarouge 38 kHz (VS1838B ou TSOP38238)
  • LED infrarouge 940 nm de 5 mm (un modèle à angle étroit comme la TSAL6100 augmente la portée)
  • Transistor NPN : 2N2222, BC337 ou S8050
  • Résistances de 470 Ω (base) et 33 Ω (LED), 1/4 W
  • Condensateur électrolytique de 100 µF
  • Plaque d'essai, fils de connexion et chargeur USB 5 V
ESP32
ESP32
IR kumanda
IR kumanda
Transistor NPN
Transistor NPN
Composant et brocheBranchement sur l'ESP32Remarque
Sortie OUT du récepteurGPIO 15Le module a sa propre résistance de tirage
VCC / GND du récepteur3V3 / GNDPas de 5 V : la sortie monterait aussi à 5 V
Base du transistorGPIO 4, via 470 ΩCourant de base d'environ 5,5 mA
Émetteur du transistorGND—
Collecteur du transistorCathode de la LED IR (patte courte)—
Anode de la LED IR (patte longue)5V (VIN) via 33 ΩCourant d'impulsion d'environ 100 mA
Condensateur de 100 µFEntre 5V et GND, près de la LEDAbsorbe les pics de courant
Ne pilote pas la LED IR sans résistance ni directement par une broche GPIO. La limite absolue des broches de l'ESP32 est de 40 mA et la valeur sûre tourne autour de 20 mA ; ce courant ne porte qu'à quelques mètres et fatigue la broche. L'ordre des pattes d'un transistor dépend du modèle : vu de face, c'est généralement E-B-C pour le 2N2222 et le S8050, mais C-B-E pour le BC337. Vérifie le brochage de ton transistor avant de le monter ; détails dans Qu'est-ce qu'un transistor ?.

Transistor de commande de la LED IR : calcul des résistances

Ici, le transistor sert d'interrupteur : quand GPIO 4 passe à HIGH, un courant de base circule, le transistor se sature et le courant de la LED vient de la ligne 5V et non de l'ESP32. La résistance de la LED se calcule avec la loi d'Ohm : R = (5 − 1,4 − 0,2) / 0,1 ≈ 34 Ω. 1,4 V est la tension directe de la LED IR à 100 mA et 0,2 V la tension aux bornes du transistor saturé ; la valeur normalisée la plus proche est 33 Ω. Dans la résistance de base, il circule (3,3 − 0,7) / 470 ≈ 5,5 mA, de quoi saturer largement le transistor pour 100 mA de collecteur. La puissance instantanée dans la résistance atteint 0,1² × 33 ≈ 0,33 W, mais la LED ne s'allume que la moitié du temps à 38 kHz et pas en continu pendant la trame : la puissance moyenne reste sous 0,1 W, une résistance de 1/4 W suffit. Tu peux essayer d'autres valeurs avec le calculateur de résistance pour LED et l'outil transistors.

Courant de la LEDUne LED (5 V)Deux LED en série (5 V)Remarque
50 mA68 Ω39 ΩCourte portée, faible consommation
100 mA33 Ω22 ΩRecommandé ; sûr en usage continu
200 mA (impulsions uniquement)15 Ω8,2 ΩPortée maximale ; vérifie le courant impulsionnel admis par la LED

Calcul de portée : jusqu'où porte la télécommande ?

La lumière s'affaiblit avec le carré de la distance : l'éclairement reçu vaut E = Ie / d². Ie est l'intensité rayonnante de la LED par stéradian (mW/sr), indiquée dans sa fiche technique. L'éclairement minimal dont un récepteur de la famille TSOP38238 a besoin (Ee min) est d'environ 0,25 mW/m². En résolvant la formule pour la distance, on obtient d = √(Ie / Ee min). Une LED à angle étroit de ±10° comme la TSAL6100 fournit environ 130 mW/sr à 100 mA : d = √(130 / 0,25) = √520 ≈ 23 m. C'est la limite théorique, LED pointée pile sur le récepteur et pièce sombre ; à cause du soleil, des tubes fluorescents et de l'angle, compte plutôt la moitié en pratique. Doubler le courant ne multiplie la portée que par √2 ≈ 1,4 ; pour une grande pièce, ajouter une deuxième LED orientée dans une autre direction est souvent plus efficace.

Courant et commande de la LEDIntensité rayonnante (LED à angle étroit)Portée théoriquePortée pratique
20 mA, directement sur un GPIOEnviron 26 mW/srEnviron 10 m3–5 m
100 mA, transistor et 33 ΩEnviron 130 mW/srEnviron 23 m8–12 m
200 mA impulsionnels, transistor et 15 ΩEnviron 260 mW/srEnviron 32 m12–16 m
2 LED × 100 mA, orientées différemment130 mW/sr chacune23 m par directionLarge couverture de la pièce
Pour vérifier que la LED IR s'allume vraiment, regarde-la avec l'appareil photo de ton téléphone : vise la LED et appuie sur le bouton d'envoi ; une lueur violette doit apparaître à l'écran. Les caméras arrière ont parfois un filtre infrarouge ; si tu ne vois rien, essaie la caméra avant.

Installer la bibliothèque IRremoteESP8266

  1. Dans l'IDE Arduino, installe le paquet ESP32 depuis le gestionnaire de cartes et choisis la carte ESP32 Dev Module ; l'installation est décrite dans Qu'est-ce que l'ESP32 ?.
  2. Dans le gestionnaire de bibliothèques, cherche IRremoteESP8266 et installe la bibliothèque de David Conran et son équipe.
  3. Si tu utilises la version 3.x du core ESP32, choisis la version 2.9.0 ou plus récente de la bibliothèque ; les versions 2.8.6 et antérieures ne compilent pas sur le core 3.x à cause d'une erreur de timer.
  4. La bibliothèque IRremote, au nom proche, est une bibliothèque différente ; les programmes de ce guide sont écrits pour IRremoteESP8266.

Étape 1 : lire les touches de la télécommande

Le premier programme décode chaque signal reçu et affiche trois informations dans le moniteur série : le protocole et le code, un texte lisible de l'état s'il s'agit d'une clim, puis les durées brutes. Le tampon de capture est réglé sur 1024 éléments et le délai d'attente sur 50 ms ; les trames de climatiseur comptent des centaines d'impulsions et arrivent en plusieurs morceaux, les valeurs par défaut les couperaient. Téléverse le code, ouvre le moniteur série à 115200 bauds, vise le récepteur avec la télécommande et appuie sur une touche.

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}

Sur la touche marche d'un téléviseur LG, tu verras une ligne comme Protocol : NEC, Code : 0x20DF10EF (32 Bits), et sur un téléviseur Samsung SAMSUNG 0xE0E040BF. Avec une télécommande de clim, le nom du protocole ressemble à DAIKIN, FUJITSU_AC ou COOLIX, suivi d'une ligne qui donne le mode, la température et la ventilation. Si tu maintiens la touche, les télécommandes NEC envoient un court code de répétition au lieu du vrai code ; il faut l'ignorer pendant l'apprentissage. Quand la bibliothèque ne reconnaît pas le protocole, elle affiche UNKNOWN ; ces codes peuvent quand même être enregistrés avec leurs durées brutes et renvoyés tels quels.

Étape 2 : enregistrer les codes et les envoyer depuis le téléphone

La vraie télécommande universelle, c'est le code ci-dessous. L'ESP32 se connecte au Wi-Fi et sert une page web de six touches ; chaque ligne a un bouton Learn (apprendre) et un bouton Send (envoyer). Après un appui sur Learn, tu as 10 secondes pour presser la touche de la télécommande d'origine ; l'ESP32 décode le code et l'écrit en mémoire permanente (NVS) avec la bibliothèque Preferences, si bien que les codes survivent à une coupure de courant. Les codes TV sont gardés sous forme de protocole, nombre de bits et valeur 64 bits, ceux des climatiseurs avec tous leurs octets d'état, et les codes inconnus avec leurs durées brutes. Pour les bases du serveur web, vois serveur web 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}
Partie du codeRôle
Structure IrCodeGarde le protocole, le nombre de bits, le code TV ou les octets d'état de la clim et la longueur brute d'une touche
storeResult()Copie le signal reçu dans la structure ; écrit les durées brutes des codes inconnus sous une clé séparée
sendSlot()Appelle sendRaw() pour un code brut, send(type, état, octets) pour une clim ou send(type, valeur, bits) pour une télé
Preferences (NVS)Stocke les touches sous les clés c0 à c5 et les durées brutes sous r0 à r5
disableIRIn() / enableIRIn()Coupe le récepteur pendant l'envoi ; l'ESP32 n'apprend pas son propre signal
/learn, /send, /statusAdresses appelées par les boutons de la page ; la ligne d'état se rafraîchit chaque seconde
  1. Saisis le nom et le mot de passe de ton Wi-Fi, téléverse le code et ouvre sur ton téléphone, connecté au même réseau, l'adresse IP affichée dans le moniteur série.
  2. Appuie sur Learn dans la ligne TV Power ; le message "Press the key for TV Power" s'affiche en haut de la page.
  3. Dans les 10 secondes, vise le récepteur avec la télécommande du téléviseur et appuie une fois sur marche ; la ligne d'état affiche par exemple "TV Power: NEC 32 bit".
  4. Pour la clim, règle d'abord la télécommande d'origine comme tu le souhaites (froid, 24 °C, par exemple), appuie sur Learn dans la ligne AC 24C puis sur la touche marche de la télécommande.
  5. Recharge la page ; les noms des protocoles apparaissent dans le tableau. Teste les appareils avec les boutons Send en orientant la LED IR vers eux.

Télécommande de climatiseur : régler la température sans apprentissage

Plutôt que d'apprendre chaque température de la clim, tu peux générer la trame dans le code. La classe IRac d'IRremoteESP8266 construit les trames de dizaines de marques, dont Daikin, Mitsubishi, Atlantic (Fujitsu), Gree, Midea, Samsung, LG, Toshiba et Panasonic, à partir d'une structure commune : tu renseignes le mode, la température, la ventilation et le volet, puis sendAc() envoie le tout en une fois. Repère le protocole de ton climatiseur avec le programme de lecture de l'étape 1 et indique-le dans le code ci-dessous. Dans le moniteur série, o allume ou éteint la clim et + ou - change la température entre 16 et 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}

Certaines marques ont plusieurs modèles ; si la clim ne réagit pas, essaie model à 2 ou 3. Le grand intérêt de cette méthode, c'est de pouvoir relier la température à un capteur : un thermostat simple qui allume la clim au-dessus de 26 °C et l'éteint sous 22 °C s'écrit en quelques lignes. La logique est la même que la régulation avec hystérésis de l'article thermostat Arduino. Comme la structure de trame est commune, il suffit de changer la ligne du protocole quand tu changes de climatiseur.

Idées de projets

  • Clim programmée : avec l'heure NTP, allume la clim une demi-heure avant ton retour.
  • Clim selon la température : mesure la pièce avec un DHT11 ou un DHT22 et pilote la clim automatiquement avec IRac.
  • Commande par Telegram : allume la clim à distance avec un message à un bot Telegram.
  • Intégration à Home Assistant : ajoute les touches à Home Assistant via MQTT et commande-les à la voix.
  • Télé éteinte dans une pièce vide : si un capteur PIR ne détecte aucun mouvement pendant 30 minutes, envoie le code d'arrêt au téléviseur.
  • Télécommande de ruban LED : apprends les télécommandes NEC à 24 ou 44 touches des rubans RGB et change les couleurs du ruban LED RGB depuis ton téléphone.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
Rien ne s'affiche dans le moniteur sérieMauvaise broche, récepteur qui n'est pas en 38 kHz ou fil mal enfoncéVérifie que OUT est sur GPIO 15 ; essaie la télécommande à 20–50 cm
Le code de la clim arrive tronqué ou en UNKNOWNTampon trop petit ou délai d'attente trop courtPasse le tampon à 1024 et le délai à 50 ms (comme dans les programmes)
Le code est appris mais l'appareil ne réagit pasLED trop faible, mal orientée, ou code de répétition apprisContrôle la LED à la caméra et réapprends avec un appui bref et unique
Portée de 1 à 2 mètresLED pilotée directement par le GPIO ou résistance trop forteFournis 100 mA avec le transistor et 33 Ω, utilise une LED à angle étroit
Le téléviseur Sony ne réagit pas du premier coupLe protocole Sony exige des répétitionssend() ajoute lui-même au moins deux répétitions ; réapprends la touche
Erreur de timer à la compilationAncienne bibliothèque avec le core ESP32 3.xMets IRremoteESP8266 à jour en version 2.9.0 ou plus
La clim passe à un autre réglage à chaque envoiDes codes appris avec des réglages différents se mélangentApprends chaque réglage sur une ligne à part ou génère la trame avec IRac
Le récepteur apprend un nouveau code après un envoiL'ESP32 lit son propre signalUtilise disableIRIn() pendant l'envoi, place le récepteur derrière la LED
Pour saisir le nom et le mot de passe du Wi-Fi depuis ton téléphone plutôt que dans le code, utilise la bibliothèque WiFiManager ; si tu installes la télécommande dans un autre logement, tu n'auras pas à téléverser à nouveau le programme.

Une télécommande universelle est le moyen le moins cher de rendre intelligents les vieux appareils de la maison, en associant le Wi-Fi de l'ESP32 à un petit montage infrarouge. Identifie d'abord tes télécommandes avec le programme de lecture, puis apprends et enregistre les codes, et pilote directement la température de la clim avec IRac. Dans l'application BlueGrays, tu trouveras la lecture des codes d'une télécommande avec un récepteur IR, la commande d'une LED et d'une lampe 220 V à la télécommande, un récepteur IR ESP32 avec écran LCD et le projet ESP32 IR Universal Remote avec écran OLED, chacun avec un schéma pas à pas et un code prêt à l'emploi.

Questions fréquentes

Comment faire une télécommande universelle avec un ESP32 ?

Tu branches sur l'ESP32 un récepteur infrarouge 38 kHz et une LED IR commandée par un transistor. La bibliothèque IRremoteESP8266 décode les codes des télécommandes, tu les enregistres en mémoire permanente avec Preferences, puis tu les renvoies avec les boutons de la page web servie par l'ESP32. Tu pilotes ainsi la télé, la clim ou un ruban LED depuis ton téléphone.

Quelles marques de climatiseur IRremoteESP8266 prend-il en charge ?

La bibliothèque reconnaît plus d'une centaine de protocoles, dont Daikin, Mitsubishi, Fujitsu (Atlantic), Gree, Midea, Samsung, LG, Toshiba, Panasonic et Haier. Le programme de lecture t'indique le protocole utilisé par ta clim. Même si le protocole n'est pas reconnu, le code peut être enregistré avec ses durées brutes et renvoyé tel quel.

Comment augmenter la portée d'une LED infrarouge ?

Pilote la LED avec un transistor NPN vers 100 mA au lieu d'un GPIO, choisis une LED 940 nm à angle étroit et oriente-la vers l'appareil. La portée augmente comme la racine carrée du courant : doubler le courant ne la multiplie que par 1,4 environ. Dans une grande pièce, une deuxième LED tournée dans une autre direction est plus efficace.

Pourquoi le code de ma télécommande s'affiche-t-il en UNKNOWN ?

Soit la bibliothèque ne connaît pas ce protocole, soit le signal a été capturé de façon incomplète. Augmente d'abord le tampon de capture à 1024 et le délai d'attente à 50 ms, puis réessaie. S'il reste en UNKNOWN, enregistrer le code avec ses durées brutes et le renvoyer avec sendRaw() à 38 kHz fonctionne sur la plupart des appareils.

Peut-on alimenter le récepteur infrarouge de l'ESP32 en 5 V ?

Mieux vaut éviter. Alimenté en 5 V, le récepteur sort lui aussi un signal de 5 V qui peut endommager l'entrée 3,3 V de l'ESP32. Les modules VS1838B et TSOP38238 fonctionnent parfaitement en 3,3 V, alors branche leur VCC sur la broche 3V3.

Les codes IR enregistrés sont-ils effacés en cas de coupure de courant ?

Non. Le programme de ce guide écrit les touches apprises dans la partition NVS de la mémoire flash de l'ESP32 avec la bibliothèque Preferences et les recharge au démarrage. Pour effacer un code, il suffit d'en apprendre un nouveau sur la même ligne ou d'appeler prefs.clear().

Voir tous les projets
Télécommande universelle ESP32 IR (récepteur IR + télécommande + 3 LED + buzzer + écran OLED)
ES-39Avancé
Premium

Télécommande universelle ESP32 IR (récepteur IR + télécommande + 3 LED + buzzer + écran OLED)

Lis une télécommande IR toute faite avec l'ESP32 et pilote ton propre appareil ! Le récepteur infrarouge (protocole NEC, 38kHz) capte les signaux d'une télécommande à 20 touches : les touches 1/2/3 allument et éteignent trois LED, PWR les éteint toutes. Appuie sur une touche inconnue et l'OLED affiche son code HEX : tu peux ainsi ajouter facilement les boutons de ta télécommande au code.

4.5(9)
16
Télécommande avec récepteur IR ESP32 (avec écran LCD)
ES-22Intermédiaire
Premium

Télécommande avec récepteur IR ESP32 (avec écran LCD)

Avec le module récepteur IR TSOP4838, l'ESP32 capte les signaux d'une télécommande de télé, de climatiseur ou de tout autre appareil infrarouge. Les codes bruts non nuls, décodés avec la bibliothèque IRremote v4, s'affichent sur le LCD I2C. Cet exemple sert à identifier les codes ; il ne commande pas de LED. Un excellent point de départ pour transformer de vieilles télécommandes en commandes domotiques.

4.7(19)
30
Lire les codes d'une télécommande IR
AR-16Débutant
Premium

Lire les codes d'une télécommande IR

Chaque touche de ta télécommande envoie un code secret grâce à une lumière invisible à l'œil.

4.5(39)
55
Allumer et éteindre des LED avec un récepteur IR et une télécommande
AR-17Intermédiaire
Premium

Allumer et éteindre des LED avec un récepteur IR et une télécommande

Comme commander trois lampes sans quitter ton fauteuil : les touches 1, 2 et 3 de la télécommande allument les LED bleue, rouge et verte, et les touches 4, 5 et 6 les éteignent dans le même ordre.

4.7(45)
66
Jouer des mélodies avec une télécommande IR et un buzzer
AR-18Débutant
Premium

Jouer des mélodies avec une télécommande IR et un buzzer

Fabrique une boîte à musique qui joue des airs avec les touches d'une télécommande de télé.

4.8(58)
75
Allumer une ampoule 220 V avec une télécommande
AR-21Avancé
Premium

Allumer une ampoule 220 V avec une télécommande

Allume et éteins une vraie ampoule de la maison avec une télécommande, sans quitter le canapé.

4.4(23)
31
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)

On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

4.8(16)
26
Connexion Wi-Fi STA ESP32 (avec écran LCD)
ES-25Avancé

Connexion Wi-Fi STA ESP32 (avec écran LCD)

Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

4.4(21)
38