Ratgeber · 9 Min. Lesezeit

Universalfernbedienung ESP32: IR-Codes lernen, speichern, senden

Universalfernbedienung mit ESP32 bauen: TV- und Klima-Codes mit IRremoteESP8266 lernen, speichern und per Handy senden. Protokolle, IR-LED-Treiber, Reichweite.

Eine Universalfernbedienung mit ESP32 vereint die Fernbedienungen von Fernseher, Klimaanlage, LED-Streifen und Stereoanlage in einem Gerät, das du über eine Webseite auf dem Handy steuerst. Das Prinzip ist einfach: Mit einem IR-Empfänger lernt der ESP32 den Code der Original-Fernbedienung, speichert ihn dauerhaft und sendet denselben Code auf Wunsch über eine IR-LED. Weil die Bibliothek IRremoteESP8266 über hundert Protokolle kennt, entschlüsselt sie sowohl Fernsehertasten als auch die langen Klimaanlagen-Telegramme, die Temperatur und Lüfterstufe enthalten.

In dieser Anleitung siehst du zuerst, wie Infrarot-Fernbedienungen funktionieren und worin sich NEC, Sony, Samsung, RC5 und die Klimaprotokolle unterscheiden. Danach lernst du, die IR-LED über einen Transistor zu treiben, Widerstände und Reichweite zu berechnen, die Codes deiner Fernbedienung auszulesen, sie im ESP32 zu speichern und per Handy zu senden und schließlich eine Klimaanlage direkt über die Temperatur zu steuern, ganz ohne Anlernen. Die Sketche laufen mit den Versionen 2.x und 3.x des ESP32-Cores.

IR-Empfängermodul VS1838B
38-kHz-IR-Empfänger: demoduliert das Signal der Fernbedienung zu digitalen Pulsen, die der ESP32 lesen kann.

Wie funktioniert eine IR-Universalfernbedienung?

Eine Fernbedienung nutzt eine IR-LED, die unsichtbares Licht mit 940 nm abstrahlt. Weil auch Sonne und Lampen Infrarot aussenden, leuchtet die LED nicht dauerhaft: Sie blinkt 38.000-mal pro Sekunde (38-kHz-Träger), und die Information steckt in der Länge dieser Pakete. Empfängermodule wie VS1838B oder TSOP38238 reagieren nur auf diese Frequenz: Sie entfernen den Träger und ziehen ihren Ausgang während jedes Pakets auf LOW. Der ESP32 liest den Code also, indem er die Dauer von Pulsen und Pausen in Mikrosekunden misst. Beim Senden läuft es umgekehrt: Der ESP32 gibt dieselben Zeiten mit 38-kHz-Modulation auf die IR-LED. Die Grundlagen des Empfängers erklären wir in IR-Empfänger und Fernbedienung.

ProtokollTrägerLängeVerwendet inHinweis
NEC38 kHz32 BitViele Fernseher, LED-Streifen-Fernbedienungen, Fernbedienungen aus Arduino-SetsSendet bei gedrückter Taste einen kurzen Wiederholcode
Samsung38 kHz32 BitSamsung-FernseherÄhnlich wie NEC, mit anderem Startpuls
Sony SIRC40 kHz12, 15 oder 20 BitSony-Fernseher und AudiogeräteDer Befehl muss mindestens 3-mal hintereinander gesendet werden
RC5 / RC636 kHz13–20 Bit und mehrPhilips und andere europäische MarkenEin Toggle-Bit wechselt bei jedem neuen Tastendruck
LG38 kHz28 BitLG-Fernseher und -KlimaanlagenDie Bibliothek kennt es als eigenes Protokoll
Klimaanlage (Daikin, Mitsubishi, Gree, Midea, Fujitsu usw.)Meist 38 kHz24–280 BitSplit-KlimageräteJeder Tastendruck sendet den kompletten Zustand inklusive Modus, Temperatur und Lüfter

Der wichtigste Unterschied in der Tabelle liegt zwischen Fernseher und Klimaanlage. Eine TV-Fernbedienung sendet einen Tastencode: „Lauter“ ist immer dieselbe 32-Bit-Zahl, und der Fernseher kennt seine aktuelle Lautstärke selbst. Eine Klima-Fernbedienung sendet dagegen den ganzen Zustand, den du auf ihrem Display siehst: an, Kühlen, 24 °C, Lüfter Auto, Lamelle schwenkend. Ein von der Klimaanlage gelernter Code ist deshalb eine Momentaufnahme der aktuellen Einstellung; sendest du ihn erneut, springt das Gerät genau auf diese Einstellung. Um die Temperatur Grad für Grad zu ändern, brauchst du eine Aufnahme pro Grad, oder du erzeugst das Telegramm im Code, wie du weiter unten siehst.

Material und Schaltung

  • ESP32-Entwicklungsboard (ESP32 DevKit, 30 oder 38 Pins)
  • 38-kHz-IR-Empfängermodul (VS1838B oder TSOP38238)
  • 940-nm-IR-LED, 5 mm (ein Modell mit engem Abstrahlwinkel wie die TSAL6100 erhöht die Reichweite)
  • NPN-Transistor: 2N2222, BC337 oder S8050
  • Widerstände 470 Ω (Basis) und 33 Ω (LED), 1/4 W
  • Elko mit 100 µF
  • Steckbrett, Jumperkabel und ein 5-V-USB-Netzteil
ESP32
ESP32
IR kumanda
IR kumanda
NPN-Transistor
NPN-Transistor
Bauteil und PinAnschluss am ESP32Hinweis
IR-Empfänger OUTGPIO 15Das Modul hat einen eigenen Pull-up
IR-Empfänger VCC / GND3V3 / GNDKeine 5 V: Sonst liegt auch der Ausgang bei 5 V
Transistor-BasisGPIO 4 über 470 ΩBasisstrom etwa 5,5 mA
Transistor-EmitterGND—
Transistor-KollektorKathode der IR-LED (kurzes Bein)—
Anode der IR-LED (langes Bein)5V (VIN) über 33 ΩPulsstrom etwa 100 mA
Kondensator 100 µFZwischen 5V und GND, nahe an der LEDFängt die Stromspitzen ab
Betreibe die IR-LED nie ohne Vorwiderstand oder direkt an einem GPIO-Pin. Die absolute Grenze der ESP32-Pins liegt bei 40 mA, sicher sind etwa 20 mA; damit reicht die LED nur wenige Meter weit, und der Pin wird stark belastet. Die Pinbelegung von Transistoren hängt vom Typ ab: Von vorn gesehen ist sie beim 2N2222 und S8050 meist E-B-C, beim BC337 dagegen C-B-E. Prüfe die Belegung deines Transistors vor dem Einbau; Details in Was ist ein Transistor?.

Treibertransistor für die IR-LED: Widerstände berechnen

Der Transistor arbeitet hier als Schalter: Geht GPIO 4 auf HIGH, fließt Basisstrom, der Transistor schaltet voll durch, und der LED-Strom kommt aus der 5V-Leitung statt aus dem ESP32. Den LED-Vorwiderstand liefert das ohmsche Gesetz: R = (5 − 1,4 − 0,2) / 0,1 ≈ 34 Ω. Dabei sind 1,4 V die Durchlassspannung der IR-LED bei 100 mA und 0,2 V die Spannung am gesättigten Transistor; der nächste Normwert ist 33 Ω. Über den Basiswiderstand fließen (3,3 − 0,7) / 470 ≈ 5,5 mA, genug, um den Transistor bei 100 mA Kollektorstrom sicher in die Sättigung zu bringen. Die Momentanleistung im Widerstand beträgt 0,1² × 33 ≈ 0,33 W, doch die LED ist bei 38 kHz nur die Hälfte der Zeit an und während eines Telegramms auch nicht dauernd; die mittlere Leistung bleibt unter 0,1 W, ein 1/4-W-Widerstand genügt. Andere Werte kannst du mit dem LED-Vorwiderstandsrechner und dem Transistor-Werkzeug durchspielen.

LED-StromEine LED (5 V)Zwei LEDs in Reihe (5 V)Hinweis
50 mA68 Ω39 ΩKurze Reichweite, wenig Verbrauch
100 mA33 Ω22 ΩEmpfohlen; im Dauerbetrieb sicher
200 mA (nur gepulst)15 Ω8,2 ΩGrößte Reichweite; Pulsstromgrenze der LED prüfen

Reichweite berechnen: Wie weit kommt die Fernbedienung?

Licht wird mit dem Quadrat der Entfernung schwächer: Die Bestrahlungsstärke am Empfänger ist E = Ie / d². Ie ist die Strahlstärke der LED pro Steradiant (mW/sr) und steht im Datenblatt. Die Mindestbestrahlungsstärke, die ein Empfänger der TSOP38238-Klasse braucht (Ee min), liegt bei etwa 0,25 mW/m². Nach der Entfernung aufgelöst ergibt sich d = √(Ie / Ee min). Eine LED mit engem Winkel von ±10° wie die TSAL6100 liefert bei 100 mA etwa 130 mW/sr: d = √(130 / 0,25) = √520 ≈ 23 m. Das ist die theoretische Grenze, mit genau auf den Empfänger gerichteter LED in einem dunklen Raum; wegen Sonnenlicht, Leuchtstofflampen und Winkel solltest du in der Praxis mit etwa der Hälfte rechnen. Doppelter Strom bringt nur √2 ≈ 1,4-fache Reichweite, deshalb ist in großen Räumen eine zweite LED in eine andere Richtung oft wirkungsvoller.

LED-Strom und AnsteuerungStrahlstärke (LED mit engem Winkel)Theoretische ReichweitePraktische Reichweite
20 mA, direkt am GPIOEtwa 26 mW/srEtwa 10 m3–5 m
100 mA, Transistor und 33 ΩEtwa 130 mW/srEtwa 23 m8–12 m
200 mA gepulst, Transistor und 15 ΩEtwa 260 mW/srEtwa 32 m12–16 m
2 LEDs × 100 mA, verschiedene RichtungenJe 130 mW/sr23 m pro RichtungBreite Abdeckung im Raum
Ob die IR-LED wirklich leuchtet, siehst du mit der Handykamera: Richte die Kamera auf die LED und drücke auf Senden; auf dem Display sollte ein violettes Leuchten erscheinen. Rückkameras haben manchmal einen Infrarotfilter, probiere dann die Frontkamera.

Die Bibliothek IRremoteESP8266 installieren

  1. Installiere in der Arduino IDE über den Boardverwalter das ESP32-Paket und wähle ESP32 Dev Module als Board; die Einrichtung zeigen wir in Was ist der ESP32?.
  2. Suche im Bibliotheksverwalter nach IRremoteESP8266 und installiere die Bibliothek von David Conran und Team.
  3. Nutzt du Version 3.x des ESP32-Cores, wähle Bibliotheksversion 2.9.0 oder neuer; 2.8.6 und älter lassen sich auf Core 3.x wegen eines Timer-Fehlers nicht kompilieren.
  4. Die ähnlich benannte Bibliothek IRremote ist eine andere Bibliothek; die Sketche in dieser Anleitung sind für IRremoteESP8266.

Schritt 1: Die Tasten der Fernbedienung auslesen

Der erste Sketch dekodiert jedes empfangene Signal und gibt drei Dinge im seriellen Monitor aus: Protokoll und Code, bei Klimaanlagen eine lesbare Zustandszeile und zum Schluss die Rohzeiten. Der Aufnahmepuffer ist auf 1024 Einträge und der Timeout auf 50 ms eingestellt; Klima-Telegramme enthalten Hunderte Pulse und kommen in mehreren Teilen, die Standardwerte würden sie abschneiden. Lade den Code hoch, öffne den seriellen Monitor mit 115200 Baud, richte die Fernbedienung auf den Empfänger und drücke eine Taste.

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}

Bei der Ein-Taste eines LG-Fernsehers siehst du etwa Protocol : NEC, Code : 0x20DF10EF (32 Bits), bei einem Samsung-Fernseher SAMSUNG 0xE0E040BF. Bei einer Klima-Fernbedienung heißt das Protokoll zum Beispiel DAIKIN, GREE oder COOLIX, gefolgt von einer Zeile mit Modus, Temperatur und Lüfter. Hältst du eine Taste gedrückt, senden NEC-Fernbedienungen statt des echten Codes einen kurzen Wiederholcode; der muss beim Anlernen übersprungen werden. Erkennt die Bibliothek ein Protokoll nicht, schreibt sie UNKNOWN; solche Codes lassen sich trotzdem mit ihren Rohzeiten speichern und unverändert zurücksenden.

Schritt 2: Codes speichern und per Handy senden

Die eigentliche Universalfernbedienung ist der folgende Code. Der ESP32 verbindet sich mit dem WLAN und liefert eine Webseite mit sechs Tasten; jede Zeile hat einen Learn- (Anlernen) und einen Send-Knopf (Senden). Nach einem Klick auf Learn hast du 10 Sekunden Zeit, die Taste der Original-Fernbedienung zu drücken; der ESP32 dekodiert den Code und schreibt ihn mit der Bibliothek Preferences in den dauerhaften Speicher (NVS), sodass die Codes auch einen Stromausfall überstehen. TV-Codes werden als Protokoll, Bitanzahl und 64-Bit-Wert gespeichert, Klima-Codes mit allen Zustandsbytes und unbekannte Codes mit ihren Rohzeiten. Die Grundlagen des Webservers findest du unter ESP32-Webserver.

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}
CodeteilAufgabe
Struktur IrCodeHält Protokoll, Bitanzahl, TV-Code oder Klima-Zustandsbytes und Rohlänge einer Taste
storeResult()Kopiert das empfangene Signal in die Struktur; schreibt die Rohzeiten unbekannter Codes unter einen eigenen Schlüssel
sendSlot()Ruft sendRaw() für Rohcodes, send(Typ, Zustand, Bytes) für Klimaanlagen oder send(Typ, Wert, Bits) für Fernseher auf
Preferences (NVS)Speichert die Tasten unter c0–c5 und die Rohzeiten unter r0–r5
disableIRIn() / enableIRIn()Schaltet den Empfänger beim Senden ab, damit der ESP32 nicht sein eigenes Signal lernt
/learn, /send, /statusDie Adressen, die die Knöpfe der Seite aufrufen; die Statuszeile aktualisiert sich jede Sekunde
  1. Trage WLAN-Name und Passwort ein, lade den Code hoch und öffne die im seriellen Monitor angezeigte IP-Adresse auf einem Handy im selben Netz.
  2. Klicke in der Zeile TV Power auf Learn; oben auf der Seite erscheint "Press the key for TV Power".
  3. Richte innerhalb von 10 Sekunden die TV-Fernbedienung auf den Empfänger und drücke einmal auf Ein; die Statuszeile zeigt dann etwa "TV Power: NEC 32 bit".
  4. Stelle für die Klimaanlage zuerst an der Original-Fernbedienung die gewünschte Einstellung ein (z. B. Kühlen, 24 °C), klicke dann in der Zeile AC 24C auf Learn und drücke die Ein-Taste der Fernbedienung.
  5. Lade die Seite neu; in der Tabelle stehen jetzt die Protokollnamen. Teste die Geräte mit den Send-Knöpfen und richte die IR-LED auf sie.

Klima-Fernbedienung: Temperatur einstellen ohne Anlernen

Statt jede Temperatur der Klimaanlage einzeln anzulernen, kannst du das Telegramm im Code erzeugen. Die Klasse IRac von IRremoteESP8266 baut die Telegramme Dutzender Marken, darunter Daikin, Mitsubishi, Fujitsu, Gree, Midea, Samsung, LG, Toshiba und Panasonic, aus einer gemeinsamen Struktur: Du trägst Modus, Temperatur, Lüfter und Lamelle ein, und sendAc() schickt alles in einem Rutsch. Ermittle den Protokollnamen deiner Klimaanlage mit dem Lese-Sketch aus Schritt 1 und trage ihn in den folgenden Code ein. Im seriellen Monitor schaltet o die Klimaanlage ein und aus, + und - ändern die Temperatur zwischen 16 und 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}

Manche Marken haben mehrere Modelle; reagiert die Klimaanlage nicht, probiere model mit 2 oder 3. Der große Vorteil dieser Methode: Du kannst die Temperatur an einen Sensor koppeln. Ein einfacher Thermostat, der die Klimaanlage über 26 °C ein- und unter 22 °C ausschaltet, ist in wenigen Zeilen geschrieben. Die Logik entspricht der Regelung mit Hysterese aus Arduino-Thermostat. Weil die Telegrammstruktur gemeinsam ist, änderst du bei einem anderen Klimagerät nur die Protokollzeile.

Projektideen

  • Klimaanlage nach Zeitplan: Schalte die Klimaanlage mit der NTP-Uhrzeit eine halbe Stunde vor deiner Heimkehr ein.
  • Klimaanlage nach Temperatur: Miss den Raum mit einem DHT11 oder DHT22 und steuere die Klimaanlage automatisch mit IRac.
  • Steuerung per Telegram: Schalte die Klimaanlage unterwegs mit einer Nachricht an einen Telegram-Bot ein.
  • Einbindung in Home Assistant: Füge die Tasten über MQTT in Home Assistant hinzu und nutze sie per Sprachassistent.
  • Fernseher aus im leeren Raum: Erkennt ein PIR-Sensor 30 Minuten lang keine Bewegung, sende dem Fernseher den Aus-Code.
  • Fernbedienung für LED-Streifen: Lerne die NEC-Fernbedienungen mit 24 oder 44 Tasten von RGB-Streifen an und ändere die Farben eines RGB-LED-Streifens per Handy.

Häufige Fehler und Lösungen

SymptomWahrscheinliche UrsacheLösung
Im seriellen Monitor erscheint nichtsFalscher Empfänger-Pin, Empfänger nicht für 38 kHz oder lockeres KabelPrüfen, ob OUT an GPIO 15 hängt; Fernbedienung aus 20–50 cm testen
Der Klima-Code kommt abgeschnitten oder als UNKNOWNPuffer zu klein oder Timeout zu kurzPuffer auf 1024 und Timeout auf 50 ms erhöhen (wie in den Sketchen)
Code ist angelernt, aber das Gerät reagiert nichtLED zu schwach oder falsch ausgerichtet, oder ein Wiederholcode wurde gelerntLED mit der Kamera prüfen und mit einem kurzen, einzelnen Tastendruck neu anlernen
Reichweite nur 1–2 MeterLED direkt am GPIO oder Vorwiderstand zu großMit Transistor und 33 Ω 100 mA liefern, LED mit engem Winkel nehmen
Sony-Fernseher reagiert nicht beim ersten MalDas Sony-Protokoll verlangt Wiederholungensend() hängt selbst mindestens zwei Wiederholungen an; Taste neu anlernen
Timer-Fehler beim KompilierenAlte Bibliothek mit ESP32-Core 3.xIRremoteESP8266 auf Version 2.9.0 oder neuer aktualisieren
Klimaanlage springt bei jedem Senden auf eine andere EinstellungMit verschiedenen Einstellungen gelernte Codes sind vermischtJede Einstellung in einer eigenen Zeile anlernen oder das Telegramm mit IRac erzeugen
Nach dem Senden lernt der Empfänger einen neuen CodeDer ESP32 liest sein eigenes SignalBeim Senden disableIRIn() nutzen und den Empfänger hinter der LED platzieren
Willst du WLAN-Name und Passwort lieber am Handy statt im Code eingeben, nutze die Bibliothek WiFiManager; ziehst du mit der Fernbedienung in eine andere Wohnung um, musst du den Code nicht neu hochladen.

Eine Universalfernbedienung ist der günstigste Weg, alte Geräte im Haus smart zu machen: Das WLAN des ESP32 trifft auf eine einfache IR-Schaltung. Erkenne zuerst deine Fernbedienungen mit dem Lese-Sketch, lerne und speichere dann die Codes und steuere die Temperatur der Klimaanlage direkt mit IRac. In der BlueGrays-App findest du das Auslesen von Fernbedienungscodes mit einem IR-Empfänger, die Steuerung einer LED und einer 220-V-Lampe per Fernbedienung, einen ESP32-IR-Empfänger mit LCD und die ESP32 IR Universal Remote mit OLED-Display, jeweils mit Schritt-für-Schritt-Schaltplan und fertigem Code.

Häufige Fragen

Wie baue ich eine Universalfernbedienung mit dem ESP32?

Du schließt an den ESP32 einen 38-kHz-IR-Empfänger und eine über einen Transistor getriebene IR-LED an. Die Bibliothek IRremoteESP8266 dekodiert die Codes der Fernbedienungen, du speicherst sie mit Preferences dauerhaft und sendest sie über die Knöpfe der Webseite des ESP32 zurück. So steuerst du Fernseher, Klimaanlage und LED-Streifen vom Handy aus.

Welche Klimaanlagen unterstützt IRremoteESP8266?

Die Bibliothek kennt über hundert Protokolle, darunter Daikin, Mitsubishi, Fujitsu, Gree, Midea, Samsung, LG, Toshiba, Panasonic und Haier. Welches Protokoll deine Klimaanlage nutzt, zeigt der Lese-Sketch. Auch wenn das Protokoll unbekannt ist, lässt sich der Code mit seinen Rohzeiten speichern und unverändert senden.

Wie erhöhe ich die Reichweite einer IR-LED?

Treibe die LED mit einem NPN-Transistor mit etwa 100 mA statt direkt am GPIO, wähle eine 940-nm-LED mit engem Abstrahlwinkel und richte sie auf das Gerät. Die Reichweite wächst mit der Wurzel des Stroms, doppelter Strom bringt also nur etwa das 1,4-Fache. In großen Räumen ist eine zweite LED in eine andere Richtung wirkungsvoller.

Warum wird mein Fernbedienungscode als UNKNOWN angezeigt?

Entweder kennt die Bibliothek das Protokoll nicht, oder das Signal wurde nur teilweise aufgenommen. Erhöhe zuerst den Aufnahmepuffer auf 1024 und den Timeout auf 50 ms und versuche es erneut. Bleibt es bei UNKNOWN, funktioniert bei den meisten Geräten das Speichern der Rohzeiten und Senden mit sendRaw() bei 38 kHz.

Darf ich den IR-Empfänger am ESP32 mit 5 V betreiben?

Besser nicht. Mit 5 V versorgt, schwingt auch der Ausgang des Empfängers auf 5 V und kann den 3,3-V-Eingang des ESP32 beschädigen. VS1838B- und TSOP38238-Module laufen problemlos mit 3,3 V, schließe VCC also an den 3V3-Pin an.

Gehen gespeicherte IR-Codes bei einem Stromausfall verloren?

Nein. Der Sketch dieser Anleitung schreibt die gelernten Tasten mit der Bibliothek Preferences in die NVS-Partition des Flash-Speichers und lädt sie beim Start wieder. Zum Löschen lernst du einfach einen neuen Code in derselben Zeile an oder rufst prefs.clear() auf.

Alle Projekte ansehen
ESP32 IR-Universalfernbedienung (IR-Empfänger + Fernbedienung + 3 LEDs + Summer + OLED)
ES-39Fortgeschritten
Premium

ESP32 IR-Universalfernbedienung (IR-Empfänger + Fernbedienung + 3 LEDs + Summer + OLED)

Lies mit dem ESP32 eine fertige IR-Fernbedienung aus und steuere dein eigenes Gerät! Der Infrarotempfänger (NEC-Protokoll, 38kHz) fängt die Signale einer Fernbedienung mit 20 Tasten ab: Die Tasten 1/2/3 schalten drei LEDs ein und aus, PWR schaltet alle ab. Drückst du eine unbekannte Taste, zeigt das OLED ihren HEX-Code, so fügst du die Tasten deiner Fernbedienung leicht in den Code ein.

4.5(9)
16
Fernbedienung mit ESP32-IR-Empfänger (mit LCD-Display)
ES-22Mittel
Premium

Fernbedienung mit ESP32-IR-Empfänger (mit LCD-Display)

Mit dem IR-Empfängermodul TSOP4838 fängt der ESP32 die Signale von Fernseher, Klimaanlage oder jeder anderen Infrarot-Fernbedienung ab. Die mit der Bibliothek IRremote v4 dekodierten Rohcodes ungleich null erscheinen auf dem I2C-LCD. Das Beispiel dient zum Erkennen von Fernbedienungscodes; eine LED schalten oder dimmen gehört nicht dazu. Ein idealer Einstieg, um alte Fernbedienungen für das Smart Home zu nutzen.

4.7(19)
30
IR-Fernbedienungscodes auslesen
AR-16Anfänger
Premium

IR-Fernbedienungscodes auslesen

Jede Taste deiner Fernbedienung schickt mit unsichtbarem Licht einen geheimen Code.

4.5(39)
55
Led ein- und ausschalten mit IR-Empfänger und Fernbedienung
AR-17Mittel
Premium

Led ein- und ausschalten mit IR-Empfänger und Fernbedienung

Wie drei Lampen steuern, ohne aus dem Sessel aufzustehen: Die Tasten 1, 2 und 3 der Fernbedienung schalten die blaue, rote und grüne LED ein, die Tasten 4, 5 und 6 schalten sie in derselben…

4.7(45)
66
Melodien abspielen mit IR-Fernbedienung und Summer
AR-18Anfänger
Premium

Melodien abspielen mit IR-Fernbedienung und Summer

Bau eine Spieluhr, die mit den Tasten einer Fernbedienung Melodien spielt. Ein Infrarotempfänger fängt das Signal der Fernbedienung auf; eine Taste spielt über den Summer eine flotte…

4.8(58)
75
220-V-Glühbirne mit Fernbedienung schalten
AR-21Fortgeschritten
Premium

220-V-Glühbirne mit Fernbedienung schalten

Schalte eine echte Glühbirne in deiner Wohnung mit einer Fernbedienung ein und aus, ohne vom Sofa aufzustehen.

4.4(23)
31
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)

Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

4.8(16)
26
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

ESP32-WLAN-STA-Verbindung (mit LCD-Display)

In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

4.4(21)
38