In diesem Blogbeitrag lernst du, wie du eine universelle, programmierbare IR-Fernbedienung mit Arduino baust. Eine Infrarot-(IR)-Fernbedienung ist ein gängiges Gerät zur Steuerung verschiedener elektronischer Geräte wie Fernseher, Klimaanlagen und DVD-Player. Mit Arduino können wir unsere eigene IR-Fernbedienung erstellen, die programmiert werden kann, um mehrere Geräte zu steuern und mehrere Fernbedienungen in einer zu vereinen.
Am Ende dieses Tutorials weißt du, wie man Infrarot-Empfänger und -Sender verwendet und wie man Daten im nichtflüchtigen EEPROM speichert. Du hast außerdem den Prototyp einer programmierbaren IR-Fernbedienung, die du nach Belieben anpassen oder erweitern kannst. Damit kannst du deine vorhandenen IR-Fernbedienungen für TV, Ventilator usw. nehmen und die Funktionen ihrer Tasten auf die hier gebaute IR-Fernbedienung kopieren.
Benötigte Komponenten
Im Folgenden findest du die Komponenten, die zum Bau der programmierbaren IR-Fernbedienung benötigt werden. Du benötigst außerdem eine IR-Fernbedienung, falls du noch keine hast.
Arduino Uno
Dupont-Kabelset
Breadboard
USB-Kabel für Arduino UNO
Widerstands- & LED-Kit
IR-Empfänger und Sender
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Anschluss der Bauteile
In diesem Abschnitt zeige ich dir, wie du die Komponenten mit dem Arduino verbindest. Das Bild unten zeigt die komplette Verkabelung. Wir beginnen mit dem Anschluss der Stromversorgung an das Breadboard.
Stromversorgung
Führe ein blaues Kabel vom GND-Pin des Arduino zur negativen Stromschiene des Breadboards (mit blauer Linie markiert). Verbinde dann den 5V-Pin des Arduino mit der positiven Stromschiene (mit roter Linie markiert) mit einem roten Kabel.
Verbinde außerdem beide positive Stromschienen des Breadboards mit einem weiteren roten Kabel. So ist auf beiden Schienen positive Spannung vorhanden.
IR-Empfängermodul
Als nächstes zeige ich dir, wie du den IR-Empfänger anschließt. Er empfängt die Infrarotsignale, die von einer IR-Fernbedienung ausgesendet werden, und sendet diese an den Arduino, wo sie decodiert werden.
Führe ein blaues und rotes Kabel vom Empfänger zu den entsprechenden Stromschienen des Breadboards. Die negative Seite ist meist mit (-) am Empfänger markiert, der mittlere Pin ist meist der positive. Danach verbinden wir den Signalpin (S) des Empfängers mit Pin 2 des Arduino; unten mit einem violetten Kabel dargestellt.
Nachdem der Empfänger angeschlossen ist, verbinden wir das Sendermodul.
IR-Sendermodul
Der IR-Sender ist das Modul mit der weißen/transparenten IR-LED. Dieses Modul sendet die Infrarotsignale, mit denen Geräte gesteuert werden.
Auch hier verbinden wir zuerst die Stromversorgung (rotes und blaues Kabel). Danach verbinden wir den Signalpin (S) des Senders mit Pin 3 des Arduino mit einem weißen Kabel.
Da unsere IR-Fernbedienung programmierbar sein soll, benötigen wir eine Status-LED. Sie zeigt an, ob wir im Programmiermodus oder im Sendemodus sind. Unten steht die Beschreibung, wie du die Status-LED anschließt.
Status-LED
Setze eine rote LED auf das Breadboard und verbinde die Kathode (der kürzere Pin) mit einem blauen Kabel zur negativen Stromschiene des Breadboards. Dann verbinde einen 330 Ohm Widerstand mit der Anode der LED (der längere Pin). Schließlich verbindest du den Widerstand mit einem orangefarbenen Kabel mit Pin 11 am Arduino.
Taster
Zuletzt benötigen wir drei Taster. Einen Taster, um zwischen Programmiermodus und Normalmodus der IR-Fernbedienung zu wechseln. Und zwei weitere Taster für zwei verschiedene Funktionen der Fernbedienung, z.B. Lautstärke erhöhen und verringern.
Wie unten zu sehen, sind alle drei Taster gleich angeschlossen. Ein 10K Ohm Widerstand dient als pull-up Wiederstand und ist mit der positiven Stromschiene verbunden. Der Pin auf der anderen Seite des Tasters ist mit einem Eingangs-Pin am Arduino verbunden (dazu später mehr). Der andere Pin ist mit einem blauen Kabel mit der negativen Stromschiene des Breadboards verbunden.
Im normalen, offenen Zustand des Tasters ist der Eingang über den Widerstand mit 5V verbunden und wir lesen ein HIGH-Signal. Wenn du den Taster drückst, verbindet sich die Eingangsleitung mit Masse und wir lesen ein LOW-Signal am Eingang.
Der oberste/erste Taster ist unser Modus-Wechseltaster. Verbinde ihn mit einem gelben Kabel mit Pin 4 am Arduino. Der darunterliegende Taster ist für die erste Funktion. Verbinde ihn mit Pin 5 (türkisfarbenes Kabel). Der letzte Taster ist für die zweite Funktion und wird mit einem grünen Kabel mit Pin 6 verbunden.
Das war’s. Alles ist verbunden – hoffentlich korrekt. Im nächsten Abschnitt schauen wir uns die Software an.
Software schreiben
Zuerst zeige ich dir den gesamten Code, danach gehen wir die einzelnen Teile durch, um zu verstehen, wie er funktioniert. Schau ihn dir einfach kurz an, um einen Überblick zu bekommen.
#include "EEPROM.h"
#include "IRremote.hpp"
#include "TinyIRSender.hpp"
const uint8_t irReceivePin = 2;
const uint8_t irSendPin = 3;
const uint8_t modePin = 4;
const uint8_t func1Pin = 5;
const uint8_t func2Pin = 6;
const uint8_t ledPin = 11;
const uint8_t sRepeats = 2;
uint8_t modeReceive = HIGH;
struct Code {
uint16_t adr;
uint16_t cmd;
} code;
bool isOn(int btn) {
return btn == LOW;
}
bool pressed(int pin) {
return isOn(digitalRead(pin));
}
int memadr(int btnId) {
return (btnId - 1) * sizeof(Code);
}
void store_code(int btnId, IRData &irData) {
digitalWrite(ledPin, LOW);
code = { irData.address, irData.command };
EEPROM.put(memadr(btnId), code);
delay(200);
digitalWrite(ledPin, HIGH);
}
void send_code(int btnId) {
digitalWrite(ledPin, HIGH);
EEPROM.get(memadr(btnId), code);
sendNECMinimal(irSendPin, code.adr, code.cmd, sRepeats);
delay(200);
digitalWrite(ledPin, LOW);
}
void toggle_mode() {
modeReceive = modeReceive == LOW ? HIGH : LOW;
digitalWrite(ledPin, isOn(modeReceive) ? HIGH : LOW);
isOn(modeReceive) ? IrReceiver.start() : IrReceiver.stop();
delay(200);
}
void send() {
if (pressed(func1Pin)) {
send_code(1);
} else if (pressed(func2Pin)) {
send_code(2);
}
}
void receive() {
if (IrReceiver.decode()) {
IRData &irData = IrReceiver.decodedIRData;
IrReceiver.printIRResultShort(&Serial);
if (pressed(func1Pin)) {
store_code(1, irData);
} else if (pressed(func2Pin)) {
store_code(2, irData);
}
IrReceiver.resume();
}
}
void setup() {
Serial.begin(9600);
IrReceiver.begin(irReceivePin, ENABLE_LED_FEEDBACK);
pinMode(ledPin, OUTPUT);
pinMode(modePin, INPUT);
pinMode(func1Pin, INPUT);
pinMode(func2Pin, INPUT);
digitalWrite(ledPin, LOW);
}
void loop() {
if (pressed(modePin)) toggle_mode();
isOn(modeReceive) ? receive() : send();
delay(100);
}
Eingebundene Bibliotheken
Für dieses Projekt benötigst du die folgenden Bibliotheken. EEPROM wird verwendet, um die programmierten IR-Codes zu speichern. Die IRremote Bibliothek wird genutzt, um die IR-Signale zu decodieren, die wir von einer IR-Fernbedienung empfangen. Und TinyIRSender ist Teil der IRremote-Bibliothek und erlaubt uns, IR-Signale zu senden – allerdings beschränkt auf das NEC protocol.
#include "EEPROM.h" #include "IRremote.hpp" #include "TinyIRSender.hpp"
Konstanten
Im folgenden Codeblock definieren wir, welche Pins am Arduino für welche Komponente verwendet werden. irReceivePin und irSendPin sind die Pins, die mit dem IR-Empfänger und -Sender verbunden sind. modePin, func1Pin und func2Pin sind mit den Tastern verbunden. Die Status-LED wird über den ledPingesteuert. Und sRepeats definiert, wie oft ein IR command beim Senden wiederholt wird.
const uint8_t irReceivePin = 2; const uint8_t irSendPin = 3; const uint8_t modePin = 4; const uint8_t func1Pin = 5; const uint8_t func2Pin = 6; const uint8_t ledPin = 11; const uint8_t sRepeats = 2;
Datenstrukturen
Zusätzlich zu den Konstanten brauchen wir eine Variable, um den aktuellen Modus (Programmieren oder Normalbetrieb) unserer IR-Fernbedienung zu speichern. modeReceive ist HIGH, wenn wir im Programmiermodus sind, sonst LOW.
uint8_t modeReceive = HIGH;
struct Code {
uint16_t adr;
uint16_t cmd;
} code;
Die Code Struktur speichert die Adresse (adr) und den Befehl (cmd) der IR-Codes, die wir empfangen, speichern und senden wollen. Zum Beispiel sendet meine IR-Fernbedienung die Adresse 0x20 und den Befehl 0x17, wenn die VOL+-Taste gedrückt wird.
Für mehr Details siehe die Dokumentation der IRremote lib oder schau dir unser Tutorial zu How to use an IR receiver and remote with Arduino an.
Hilfsfunktionen
Um den Code so einfach und lesbar wie möglich zu halten, implementieren wir einige Hilfsfunktionen. Die isOn() Funktion gibt True zurück, wenn ein Taster LOW ist, also gedrückt wird. Mit der pressed() Funktion lesen wir den Zustand eines Eingangs-Pins und nutzen dann isOn(), um zu bestimmen, ob der verbundene Taster gedrückt ist.
bool isOn(int btn) {
return btn == LOW;
}
bool pressed(int pin) {
return isOn(digitalRead(pin));
}
Speicheradressfunktion
Um die empfangenen IR-Codes im Speicher abzulegen, brauchen wir eine Funktion, die uns sagt, an welcher Adresse die Daten gespeichert werden sollen. Die memadr() Funktion berechnet, an welcher Speicheradresse im EEPROM wir IR-Befehle speichern und lesen.
int memadr(int btnId) {
return (btnId - 1) * sizeof(Code);
}
Diese Funktion nimmt eine btnId, die 1 oder 2 ist (für Funktion 1 oder 2), und berechnet die Speicheradresse. Schau dir das folgende Bild an, um die Beziehung zwischen btnId, der Größe einer Code Struktur und der Speicheradresse besser zu verstehen.
IR-Code-Funktionen
Für das eigentliche Speichern und Senden von IR-Codes verwenden wir zwei Funktionen. Die folgende store_code() Funktion nimmt eine Taster-ID (btnId) und einen Datenblock (irData) empfangener IR-Daten entgegen.
Zuerst schalten wir die Status-LED aus, um anzuzeigen, dass wir Daten speichern.
void store_code(int btnId, IRData &irData) {
digitalWrite(ledPin, LOW);
code = { irData.address, irData.command };
EEPROM.put(memadr(btnId), code);
delay(200);
digitalWrite(ledPin, HIGH);
}
Dann extrahieren wir die Code-Adresse und den Befehl aus dem Datenblock und speichern sie in einer Code Struktur. Wir schreiben diese Code-Struktur mit put() in das EEPROM, wobei wir die memadr() Funktion zur Berechnung der Speicheradresse verwenden.
Wir müssen die Daten im EEPROM speichern, da sonst bei Stromausfall alle gespeicherten Daten verloren gehen. Mit den Daten im EEPROM bleiben die programmierten Befehle/Tasten auch bei ausgeschaltetem Arduino erhalten.
Nach dem Speichern warten wir 200 ms, um unnötiges wiederholtes Speichern zu vermeiden, wenn die Programmiertaste gedrückt bleibt. Schließlich schalten wir die Status-LED wieder an, um anzuzeigen, dass die Programmierung abgeschlossen ist.
Das Senden der Codes funktioniert im Wesentlichen umgekehrt. Schau dir die send_code() Funktion unten an. Zuerst setzen wir die Status-LED auf HIGH, um anzuzeigen, dass wir senden. Dann get wir den Code aus dem EEPROM für den gedrückten Taster (btnId). Die sendNECMinimal() Funktion sendet die Code-Adresse und den Befehl mit der angegebenen Wiederholungsanzahl (sRepeats).
void send_code(int btnId) {
digitalWrite(ledPin, HIGH);
EEPROM.get(memadr(btnId), code);
sendNECMinimal(irSendPin, code.adr, code.cmd, sRepeats);
delay(200);
digitalWrite(ledPin, LOW);
}
Danach warten wir wieder 200 ms und schalten die Status-LED aus, um anzuzeigen, dass das Senden abgeschlossen ist.
Hauptfunktionen
Jetzt haben wir alle Grundfunktionen, um die Hauptfunktionen zu bauen. Wir starten mit einer toggle_mode() Funktion, die unsere Fernbedienung vom Programmier-/Empfangsmodus in den Sendemodus und zurück schaltet. Die erste Zeile toggelt den Modus. In der zweiten Zeile schalten wir die Status-LED an, wenn wir im Programmiermodus sind. Im Normalmodus ist die Status-LED aus.
void toggle_mode() {
modeReceive = modeReceive == LOW ? HIGH : LOW;
digitalWrite(ledPin, isOn(modeReceive) ? HIGH : LOW);
isOn(modeReceive) ? IrReceiver.start() : IrReceiver.stop();
delay(200);
}
In der dritten Zeile schalten wir den IrReceiver ein oder aus, je nach Modus. Wenn wir im Empfangsmodus sind, wird der IrReceiver gestartet, sonst gestoppt. Schließlich gibt es eine übliche Verzögerung von 200 ms, um lange Tastendrücke zu handhaben.
Die send() Funktion unten nutzt send_code(), um die im EEPROM gespeicherten IR-Codes für Taster 1 und 2 zu senden. Je nachdem, welcher Taster gedrückt wird, sendet sie den entsprechenden Code.
void send() {
if (pressed(func1Pin)) {
send_code(1);
} else if (pressed(func2Pin)) {
send_code(2);
}
}
Zuletzt ist die letzte Hauptfunktion receive(). Dort empfangen wir die von einer IR-Fernbedienung gesendeten Daten und speichern sie für Taster 1 oder 2, je nachdem, welcher Taster gerade gedrückt ist. Für mehr Details zum Empfang von IR-Daten siehe unser Tutorial: How to use an IR receiver and remote with Arduino.
void receive() {
if (IrReceiver.decode()) {
IRData &irData = IrReceiver.decodedIRData;
IrReceiver.printIRResultShort(&Serial);
if (pressed(func1Pin)) {
store_code(1, irData);
} else if (pressed(func2Pin)) {
store_code(2, irData);
}
IrReceiver.resume();
}
}
Setup-Funktion
Wir sind fast fertig! Nur noch zwei sehr einfache Funktionen sind zu implementieren. In der setup() Funktion stellen wir die serielle Kommunikation her, initialisieren die IrReceiver und setzen die IO-Modi der Pins. Wir sorgen auch dafür, dass die Status-LED ausgeschaltet ist, was anzeigt, dass wir zu Beginn im Sendemodus sind.
void setup() {
Serial.begin(9600);
IrReceiver.begin(irReceivePin, ENABLE_LED_FEEDBACK);
pinMode(ledPin, OUTPUT);
pinMode(modePin, INPUT);
pinMode(func1Pin, INPUT);
pinMode(func2Pin, INPUT);
digitalWrite(ledPin, LOW);
}
Loop-Funktion
Nach der ganzen Arbeit oben ist die Hauptschleife jetzt sehr einfach. Wir überwachen den Modus-Taster, der mit modePin verbunden ist, und wenn er pressed ist, toggeln wir den Modus. Dann prüfen wir, ob wir im Empfangsmodus über isOn(modeReceive) sind. Falls ja, empfangen und speichern wir IR-Daten. Andernfalls senden wir Daten.
void loop() {
if (pressed(modePin)) toggle_mode();
isOn(modeReceive) ? receive() : send();
delay(100);
}
Und das war’s! Im nächsten Abschnitt erkläre ich kurz, wie man die gerade gebaute Fernbedienung tatsächlich benutzt.
Wie man die Fernbedienung benutzt
In diesem Abschnitt erkläre ich, wie man die Fernbedienung tatsächlich verwendet. Wir haben drei Taster. Der Mode-Taster wird verwendet, um vom Programmier- oder Empfangsmodus in den Sendemodus zu wechseln. Zu Beginn ist die Fernbedienung im Sendemodus und die Status-LED ist aus. Wenn du kurz den Mode-Taster drückst, wechselt die Fernbedienung in den Programmiermodus und die Status-LED leuchtet.
Programmieren
Um eine der beiden Funktionstasten zu programmieren, musst du deine andere IR-Fernbedienung auf die Empfängerdiode richten und zwei Tasten gleichzeitig drücken. Die Taste auf der anderen Fernbedienung, die du speichern möchtest, und die Funktionstaste auf unserer Universalfernbedienung. Das folgende Bild zeigt, wie wir die Next Track-Taste als Function 1 speichern würden.
Die Status-LED blinkt kurz auf, um anzuzeigen, dass eine Funktion gespeichert wurde, und du kannst die Tasten loslassen.
Senden
Um IR-Befehle zu senden, drücke einfach den Modus-Taster (die Status-LED sollte ausgeschaltet sein) und drücke eine der programmierten Funktionstasten. Auch hier blinkt die Status-LED, um anzuzeigen, dass der Befehl gesendet wurde.
Fehlersuche
Einige IR-Fernbedienungen werden nicht unterstützt und können nicht programmiert werden. Du kannst das überprüfen, indem du den Seriellen Monitor verbindest, in den Programmiermodus wechselst (Status-LED sollte an sein) und prüfst, ob die IRremote-Bibliothek das Signal decodieren kann. Die Ausgabe sollte etwa so aussehen:
Hier haben wir erfolgreich einen Befehl mit Adresse 0x20 und Befehlscode 0x8 empfangen.
Für die Fehlersuche bei der Sende-Funktion ist einer dieser Komponententester sehr hilfreich. Ansonsten musst du per Trial & Error herausfinden, was falsch ist.
Multi-Funktions-Tester
Der oben gezeigte Komponententester kann IR-Signale decodieren, und ein erfolgreich empfangenes Signal sieht so aus:
Fazit
In diesem Tutorial hast du gelernt, wie man eine universelle, programmierbare IR-Fernbedienung mit Arduino baut. Mit den Schritt-für-Schritt-Anleitungen kannst du ganz einfach deine eigene Fernbedienung erstellen, die eine Vielzahl von Infrarotgeräten steuern kann.
Wir haben mit den benötigten Teilen für dieses Projekt begonnen, darunter ein Arduino-Board, ein IR-Empfängermodul und ein IR-Sendermodul. Wir haben die Verkabelung zwischen diesen Komponenten beschrieben und den Code zur Steuerung bereitgestellt. Außerdem haben wir erklärt, wie man die Fernbedienung programmiert, um IR-Befehle von anderen Fernbedienungen zu übernehmen.
Wenn du weitere Fragen hast oder zusätzliche Unterstützung benötigst, schaue bitte in den Abschnitt Häufig gestellte Fragen oder nutze die bereitgestellten Links für mehr Ressourcen und Inspiration.
Viel Spaß beim Basteln!
Häufig gestellte Fragen
Hier sind einige häufig gestellte Fragen zum Bau einer universellen, programmierbaren IR-Fernbedienung mit Arduino:
Kann ich mehr Funktionstasten haben?
Ja, du kannst die Verkabelung der vorhandenen Tasten für neue Tasten einfach kopieren und den Code erweitern. Insbesondere müssen die Funktionen receive() und send() erweitert werden, um die zusätzlichen Tasten zu unterstützen.
Wie kann ich die Reichweite der IR-Fernbedienung erhöhen?
Du kannst zusätzliche IR-LEDs an andere Ausgangspins anschließen. Oder du betreibst eine IR-LED mit höherer Spannung, was jedoch einen Transistor oder MOSFET erfordert, um das Signal zur LED zu steuern. Hier ist ein Beispielschaltplan, der eine 9V-Batterie verwendet, um eine IR-Sendediode zu betreiben:
Für mehr Details und Beispiele zu MOSFETs siehe unser Tutorial zu Control Air-Conditioner via IR with ESP32 or ESP8266 und How To Control Fan using Arduino UNO.
Es funktioniert nicht mit meiner IR-Fernbedienung?
Die IRremote-Bibliothek ist großartig, unterstützt aber nicht jedes IR-Kommunikationsprotokoll. Für das Senden verwenden wir TinyIRSender, das auf das NEC-Protokoll beschränkt ist, aber die IRremote-Bibliothek unterstützt auch andere Protokolle. Wenn das nicht ausreicht, schau dir als Alternative die IRremoteESP8266 an.
Ich möchte meine Klimaanlage mit der IR-Fernbedienung steuern?
Probiere die IRremoteESP8266 Bibliothek. Sie bietet gute Unterstützung für viele Klimageräte.
Kann ich für dieses Projekt jedes Arduino-Board verwenden?
Ja, du kannst jedes Arduino-Board verwenden, solange du einen IR-Empfänger und -Sender anschließen kannst und die benötigten Bibliotheken unterstützt werden. Ein ESP32 wäre zum Beispiel eine gute Alternative zum Arduino.
Wie finde ich heraus, welche IR-Codes ich für meine Geräte verwenden muss?
Du kannst die IR-Codes für deine Geräte online suchen oder im Benutzerhandbuch des Geräts nachsehen. Viele Hersteller stellen IR-Code-Datenbanken bereit, die mit Arduino-Bibliotheken genutzt werden können. Alternativ kannst du ein IR-Empfängermodul verwenden, um die Codes von einer vorhandenen Fernbedienung zu erfassen. Siehe unser Tutorial zu How to use an IR receiver and remote with Arduino.
Kann ich mit dieser IR-Fernbedienung mehrere Geräte steuern?
Ja, du kannst mit dieser IR-Fernbedienung mehrere Geräte steuern. Indem du verschiedene IR-Codes für jedes Gerät programmierst, kannst du zwischen ihnen über Tasten oder ein Menüsystem im Arduino-Code wechseln. Beachte jedoch, dass der obige Code nur das NEC-Protokoll unterstützt, aber glücklicherweise verwenden die meisten IR-Fernbedienungen dieses.
Kann ich zusätzliche Funktionen zur IR-Fernbedienung hinzufügen?
Absolut! Die Arduino-Plattform erlaubt endlose Anpassungen. Du kannst Funktionen wie ein hintergrundbeleuchtetes LCD-Display, einen Drehencoder für die Menünavigation oder sogar die Integration mit anderen Smart-Home-Geräten über drahtlose Kommunikationsprotokolle wie Wi-Fi oder Bluetooth hinzufügen.
Wenn du weitere Fragen hast oder Unterstützung benötigst, kannst du gerne im Kommentarbereich unten fragen.
Links
Unten findest du einige nützliche Links für zusätzliche Erklärungen und alternative Bauweisen.
- IR Remote and Receiver with Arduino Tutorial (4 Examples)
- ESP32 And IR Remote Interface – A Complete Tutorial
- How to Control a Servo with an IR Remote
- Universal Arduino Remote : 10 Steps (with Pictures)
- Arduino Infrared (IR) Control… The Universal Remote …
- Arduino based universal TV Remote
- Arduino IR Remote Controller Tutorial – Setup and Map …
- Arduino Infrared Remote Tutorial : 7 Steps
