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.

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.
| Protokoll | Träger | Länge | Verwendet in | Hinweis |
|---|---|---|---|---|
| NEC | 38 kHz | 32 Bit | Viele Fernseher, LED-Streifen-Fernbedienungen, Fernbedienungen aus Arduino-Sets | Sendet bei gedrückter Taste einen kurzen Wiederholcode |
| Samsung | 38 kHz | 32 Bit | Samsung-Fernseher | Ähnlich wie NEC, mit anderem Startpuls |
| Sony SIRC | 40 kHz | 12, 15 oder 20 Bit | Sony-Fernseher und Audiogeräte | Der Befehl muss mindestens 3-mal hintereinander gesendet werden |
| RC5 / RC6 | 36 kHz | 13–20 Bit und mehr | Philips und andere europäische Marken | Ein Toggle-Bit wechselt bei jedem neuen Tastendruck |
| LG | 38 kHz | 28 Bit | LG-Fernseher und -Klimaanlagen | Die Bibliothek kennt es als eigenes Protokoll |
| Klimaanlage (Daikin, Mitsubishi, Gree, Midea, Fujitsu usw.) | Meist 38 kHz | 24–280 Bit | Split-Klimageräte | Jeder 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



| Bauteil und Pin | Anschluss am ESP32 | Hinweis |
|---|---|---|
| IR-Empfänger OUT | GPIO 15 | Das Modul hat einen eigenen Pull-up |
| IR-Empfänger VCC / GND | 3V3 / GND | Keine 5 V: Sonst liegt auch der Ausgang bei 5 V |
| Transistor-Basis | GPIO 4 über 470 Ω | Basisstrom etwa 5,5 mA |
| Transistor-Emitter | GND | — |
| Transistor-Kollektor | Kathode der IR-LED (kurzes Bein) | — |
| Anode der IR-LED (langes Bein) | 5V (VIN) über 33 Ω | Pulsstrom etwa 100 mA |
| Kondensator 100 µF | Zwischen 5V und GND, nahe an der LED | Fängt die Stromspitzen ab |
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-Strom | Eine LED (5 V) | Zwei LEDs in Reihe (5 V) | Hinweis |
|---|---|---|---|
| 50 mA | 68 Ω | 39 Ω | Kurze Reichweite, wenig Verbrauch |
| 100 mA | 33 Ω | 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 Ansteuerung | Strahlstärke (LED mit engem Winkel) | Theoretische Reichweite | Praktische Reichweite |
|---|---|---|---|
| 20 mA, direkt am GPIO | Etwa 26 mW/sr | Etwa 10 m | 3–5 m |
| 100 mA, Transistor und 33 Ω | Etwa 130 mW/sr | Etwa 23 m | 8–12 m |
| 200 mA gepulst, Transistor und 15 Ω | Etwa 260 mW/sr | Etwa 32 m | 12–16 m |
| 2 LEDs × 100 mA, verschiedene Richtungen | Je 130 mW/sr | 23 m pro Richtung | Breite Abdeckung im Raum |
Die Bibliothek IRremoteESP8266 installieren
- 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?.
- Suche im Bibliotheksverwalter nach IRremoteESP8266 und installiere die Bibliothek von David Conran und Team.
- 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.
- 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.
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.
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}| Codeteil | Aufgabe |
|---|---|
| Struktur IrCode | Hä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, /status | Die Adressen, die die Knöpfe der Seite aufrufen; die Statuszeile aktualisiert sich jede Sekunde |
- 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.
- Klicke in der Zeile TV Power auf Learn; oben auf der Seite erscheint "Press the key for TV Power".
- 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".
- 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.
- 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.
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
| Symptom | Wahrscheinliche Ursache | Lösung |
|---|---|---|
| Im seriellen Monitor erscheint nichts | Falscher Empfänger-Pin, Empfänger nicht für 38 kHz oder lockeres Kabel | Prüfen, ob OUT an GPIO 15 hängt; Fernbedienung aus 20–50 cm testen |
| Der Klima-Code kommt abgeschnitten oder als UNKNOWN | Puffer zu klein oder Timeout zu kurz | Puffer auf 1024 und Timeout auf 50 ms erhöhen (wie in den Sketchen) |
| Code ist angelernt, aber das Gerät reagiert nicht | LED zu schwach oder falsch ausgerichtet, oder ein Wiederholcode wurde gelernt | LED mit der Kamera prüfen und mit einem kurzen, einzelnen Tastendruck neu anlernen |
| Reichweite nur 1–2 Meter | LED 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 Mal | Das Sony-Protokoll verlangt Wiederholungen | send() hängt selbst mindestens zwei Wiederholungen an; Taste neu anlernen |
| Timer-Fehler beim Kompilieren | Alte Bibliothek mit ESP32-Core 3.x | IRremoteESP8266 auf Version 2.9.0 oder neuer aktualisieren |
| Klimaanlage springt bei jedem Senden auf eine andere Einstellung | Mit verschiedenen Einstellungen gelernte Codes sind vermischt | Jede Einstellung in einer eigenen Zeile anlernen oder das Telegramm mit IRac erzeugen |
| Nach dem Senden lernt der Empfänger einen neuen Code | Der ESP32 liest sein eigenes Signal | Beim Senden disableIRIn() nutzen und den Empfänger hinter der LED platzieren |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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.

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.

IR-Fernbedienungscodes auslesen
Jede Taste deiner Fernbedienung schickt mit unsichtbarem Licht einen geheimen Code.

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…

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…

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.

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.

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

