In diesem Tutorial lernst du, wie du eine IR Fernbedienung und einen Empfänger mit dem Arduino verwendest. Ich habe Schaltpläne und mehrere Beispielcodes beigefügt, um dir den Einstieg zu erleichtern.
Wenn du die Anweisungen in diesem Tutorial befolgst, kannst du praktisch jede IR-Fernbedienung (wie die von deinem Fernseher) verwenden, um Dinge zu steuern, die mit dem Arduino verbunden sind.
In den folgenden Codebeispielen verwenden wir die IRremote Arduino-Bibliothek. Diese Bibliothek ist recht einfach zu benutzen und unterstützt viele verschiedene IR-Kommunikationsprotokolle. Mit den ersten beiden Beispielen kannst du das IR-Protokoll deiner Fernbedienung identifizieren und herausfinden, welchen Code sie sendet, wenn du eine Taste drückst. Danach zeige ich dir, wie du den empfangenen Code den Tastenwerten zuordnest und diese im Serial Monitor oder auf einem LCD anzeigst. Zum Schluss schauen wir uns an, wie man die Ausgänge des Arduino mit einer IR-Fernbedienung und einem Empfänger steuert.
Materialien
Hardware-Komponenten
Software
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.
Wie funktioniert eine Infrarot-(IR)-Fernbedienung und ein Empfänger?
Eine IR-Fernbedienung und ein Empfänger kommunizieren miteinander, indem sie ein Signal in Form von gepulster IR-Strahlung senden und dekodieren.
Infrarotstrahlung (IR) oder Infrarotlicht ist eine Art elektromagnetischer Strahlung mit Wellenlängen von 700 nm bis 1 mm. Da Menschen nur Licht mit Wellenlängen von etwa 400 (Violett) bis 700 (Rot) Nanometern sehen können, ist IR-Strahlung für das menschliche Auge unsichtbar.
Da die IR-Übertragung ein drahtloses Protokoll ist, das auf einer Art Licht basiert, benötigt sie eine freie Sichtlinie zwischen Sender (der Fernbedienung) und Empfänger. Das bedeutet, dass sie nicht durch Wände oder Decken übertragen kann, im Gegensatz zu WiFi oder Bluetooth.
Grundlagen der IR-Kommunikation
Leider ist die IR-LED in deiner Fernbedienung nicht die einzige Quelle von IR-Strahlung. Jedes Objekt mit Temperatur strahlt ebenfalls im Infrarotspektrum. Dieses Phänomen wird auch von Wärmebildkameras genutzt, um Wärme zu erkennen.
All diese Umgebungs-IR-Strahlung kann die Kommunikation zwischen Fernbedienung und Empfänger stören. Wie erkennt der Empfänger also nur das IR-Signal der Fernbedienung? Die Antwort ist Signalmodulation.
Bei der Signalmodulation wird die IR-Lichtquelle am Ende der Fernbedienung mit einer bestimmten Frequenz geblinkt. In der Unterhaltungselektronik liegt diese Trägerfrequenz meist bei etwa 38 kHz.
Diese spezielle Frequenz wird für kommerzielle IR-Übertragungen verwendet, weil sie in der Natur selten vorkommt und sich daher von der Umgebungs-IR unterscheiden lässt.
Der Empfänger ist so gebaut, dass er nur IR-Strahlung bei 38 kHz durchlässt. Dies wird durch einen Bandpassfilter und Verstärker erreicht. Das demodulierte Binärsignal wird dann an den Mikrocontroller (den Arduino) gesendet, wo es dekodiert wird.
IR-Signalprotokoll
Wie sieht ein IR-Signal eigentlich aus?
In dem obigen Bild entspricht die vertikale Achse der Spannung, die zur IR-LED in der Fernbedienung geht, und die horizontale Achse der Zeit. Wenn die IR-LED an ist, wird sie mit 38 kHz geblinkt (moduliert), und wenn sie aus ist, liegt keine Spannung an.
Wichtig ist die Zeitdauer, in der die IR-LED an oder aus ist. Im NEC-Protokoll, einem der beliebtesten IR-Übertragungsprotokolle, werden die Bits („1“ oder „0“) wie folgt dargestellt:
Jedes Bit besteht aus einem 560 µs langen 38 kHz Trägerimpuls (etwa 21 Zyklen), gefolgt von einer Pause. Ein logisches „1“ hat eine Gesamtsendezeit von 2,25 ms, während ein logisches „0“ nur 1,125 ms dauert.
Die Zeitdauer, in der das Signal an oder aus bleibt, und die Anzahl der Bits pro Befehl unterscheiden sich bei allen IR-Protokollen. Im NEC-Protokoll besteht die Gesamtbotschaft meist aus vier 8-Bit-Bytes.
Arten von IR-Empfängern
IR-Empfänger, manchmal auch IR-Sensoren oder IR-Detektionsdioden genannt, gibt es meist in zwei Bauformen. Du kannst die Dioden einzeln kaufen oder auf einer kleinen Breakout-Platine montiert.
Sie funktionieren genau gleich, daher ist es egal, welchen du verwendest. Der einzige Unterschied ist, dass die Breakout-Platine oft eine kleine LED enthält, die bei Signalempfang blinkt – praktisch zum Debuggen.
Anschluss eines IR-Empfängers an den Arduino
Es ist sehr einfach, einen IR-Empfänger an den Arduino anzuschließen, da du nur drei Kabel verbinden musst. Das Ausgangskabel kann an jeden digitalen Pin des Arduino angeschlossen werden. In diesem Fall habe ich es für die ersten Beispiele an Pin 2 angeschlossen.
Der Versorgungsspannungs-Pin wird mit 5 V verbunden und der mittlere Masse-Pin mit GND. Wenn du einen Empfänger auf einer Breakout-Platine verwendest, überprüfe die Beschriftungen auf der Platine, da die Pin-Reihenfolge unterschiedlich sein kann!
Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt
Anschlüsse des IR-Empfängers
| IR-Empfänger | Arduino |
|---|---|
| OUT (links) | Pin 2 |
| GND (mittig) | GND (-) |
| Vcc (rechts) | 5 V (+) |
Installation der IRremote Arduino-Bibliothek
Für dieses Tutorial verwenden wir die beliebte IRremote Bibliothek. Diese Bibliothek ist recht einfach zu benutzen und unterstützt viele verschiedene Arten von IR-Fernbedienungen.
Um die Bibliothek zu installieren, gehe zu Tools > Manage Libraries (Strg + Shift + I unter Windows) in der Arduino IDE. Der Library Manager öffnet sich und aktualisiert die Liste der installierten Bibliotheken.
Du kannst nach ‚IRremote‘ suchen und die Bibliothek von shirriff und z3to auswählen. Wähle die neueste Version und klicke dann auf Installieren.
Bestimme das IR-Protokoll deiner Fernbedienung
NEC ist wahrscheinlich das bekannteste und am weitesten verbreitete IR-Übertragungsprotokoll, da es von der überwiegenden Mehrheit japanischer Unterhaltungselektronik verwendet wird. Es gibt jedoch viele andere Protokolltypen. Es kann nützlich sein zu wissen, welches IR-Protokoll deine Fernbedienung verwendet, wenn du an fortgeschritteneren Projekten arbeiten möchtest.
Stand Sep 2023 unterstützt die IRremote-Bibliothek folgende IR-Protokolle:
- PulseWidth
- PulseDistance
- Apple
- Denon
- JVC
- LG
- LG2
- NEC
- NEC2
- Onkyo
- Panasonic
- Kaseikyo
- Kaseikyo Denon
- Kaseikyo Sharp
- Kaseikyo JVC
- Kaseikyo Mitsubishi
- RC5
- RC6
- Samsung
- Samsung48
- SamsungLG
- Sharp
- Sony
- Bang&Olufsen
- BoseWave
- Lego
- MagiQuest
- Whynter
- FAST
Mit dem kurzen Code unten kannst du herausfinden, welches Protokoll deine Fernbedienung verwendet. Du kannst auch andere Fernbedienungen aus deinem Haushalt ausprobieren und sehen, ob das Protokoll erkannt wird.
IR-Fernbedienungs-Protokollfinder
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
IrReceiver.printIRResultShort(&Serial);
IrReceiver.resume();
}
}
Ich habe mit drei Fernbedienungen in meinem Haus experimentiert, zwei wurden als NEC erkannt, während die dritte (für eine Klimaanlage) als UNKNOWN angezeigt wurde:
Es gibt jedoch eine hervorragende Bibliothek namens IRremoteESP8266, die speziell die Protokolle verschiedener Klimaanlagen unterstützt. Wenn du also deine Klimaanlage per IR steuern möchtest, ist das der richtige Ort, aber diese Bibliothek verwenden wir hier nicht.
Hinweis: Bei Fernbedienungen mit unbekannten Protokollen siehst du neben der Protokollinfo auch den Fehler „Overflow“. Das liegt einfach daran, dass das Ende des IR-Befehls nicht erkannt werden konnte, da das Protokoll unbekannt war.
Ermittlung der Tastencodes deiner Fernbedienung
Da es viele verschiedene Fernbedienungen auf dem Markt gibt (mit unterschiedlicher Anzahl an Tasten und Funktionen), müssen wir herausfinden, welches empfangene Signal zu welcher Taste gehört.
Die IRremote-Bibliothek liest das Signal und gibt alle Informationen über das Signal in der folgenden Datenstruktur zurück:
struct IRData {
decode_type_t protocol; // UNKNOWN, NEC, SONY, RC5, PULSE_DISTANCE, ...
uint16_t address; // Decoded address
uint16_t command; // Decoded command
uint16_t extra;
uint16_t numberOfBits; // Number of bits received for data
uint8_t flags; // IRDATA_FLAGS_IS_REPEAT, IRDATA_FLAGS_WAS_OVERFLOW
IRRawDataType decodedRawData; // Up to 32 bit decoded raw data,
uint32_t decodedRawDataArray[RAW_DATA_ARRAY_SIZE]; // 32 bit decoded raw data for send function.
irparams_struct *rawDataPtr; // Pointer of the raw timing data to be decoded.
};
Wir sind besonders an dem command Teil dieser Struktur interessiert. Dieser enthält den Code, den die Fernbedienung je nach gedrückter Taste sendet. Indem wir den Befehlswert im Serial Monitor ausgeben, können wir eine Umrechnungstabelle erstellen.
Der Code unten macht genau das. Beachte, dass wir eine Verzögerung von 100 ms hinzufügen, damit die Ausgabe verlangsamt wird, falls eine Taste dauerhaft gedrückt wird und somit wiederholt ausgegeben wird.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
Serial.println(command);
delay(100); // wait a bit
IrReceiver.resume();
}
}
Nachdem du den Code hochgeladen hast, öffne den Serial Monitor. Drücke nun jede Taste auf der Fernbedienung und notiere den entsprechenden Wert, den du im Serial Monitor siehst.
Für meine Fernbedienung, die einen Audioplayer steuert, erhielt ich folgende Codes:
| Taste | Code |
|---|---|
| Play | 7 |
| Stop | 3 |
| Mute | 20 |
| Nächster Titel | 8 |
| Vorheriger Titel | 2 |
| Lauter | 31 |
| Leiser | 23 |
Deine Tabelle wird wahrscheinlich anders aussehen! Du musst deine eigene erstellen, um die folgenden Codebeispiele zu verwenden.
Tastennamen im Serial Monitor ausgeben
Jetzt, wo wir wissen, welcher Code welcher Taste entspricht, können wir den Code so anpassen, dass der Name der gedrückten Taste im Serial Monitor ausgegeben wird.
Dafür verwenden wir eine switch case Steuerstruktur. Damit können wir je nach gedrückter Taste einen anderen Code ausführen.
Das folgende Codebeispiel gibt den Tastennamen im Serial Monitor aus, anstatt wie im vorherigen Beispiel den Integer-Wert. Beachte, dass wir die Verzögerung beibehalten, damit der Empfänger nicht mit wiederholten Signalen überlastet wird, wenn eine Taste dauerhaft gedrückt wird.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 2
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY");
break;
case 3:
Serial.println("STOP");
break;
case 20:
Serial.println("MUTE");
break;
case 8:
Serial.println("NEXT");
break;
case 2:
Serial.println("PREV");
break;
case 31:
Serial.println("VOL+");
break;
case 23:
Serial.println("VOL-");
break;
default:
Serial.println("UNDEFINED");
}
delay(100);
IrReceiver.resume();
}
}
So sieht es aus, wenn ich einige Tasten meiner Fernbedienung im Serial Monitor drücke:
Wenn deine Fernbedienung andere Tasten hat und andere Codes sendet als in der obigen Tabelle, ersetze einfach die Werte und Namen in den Zeilen der switch-case-Anweisung, die so aussehen:
case 31:
Serial.println("VOL+");
Diese Zeilen bedeuten: Wenn der Befehlswert 31 ist, drucke „VOL+“ im Serial Monitor. Gibt es keine case-Anweisung für einen Befehlswert, wird die default-Klausel aktiviert und „UNDEFINED“ ausgegeben.
Wie der Code funktioniert
Die erste Zeile des Codes bindet die IRremote.hpp Bibliothek ein. Diese Bibliothek stellt die Funktionen bereit, die für die Arbeit mit IR-Signalen nötig sind.
#include "IRremote.hpp"
Als nächstes definieren wir den Pin, der die IR-Signale empfangen wird. In diesem Fall verwenden wir Pin 2.
#define IR_RECEIVE_PIN 2
In der setup() Funktion starten wir die serielle Kommunikation mit 9600 Baud. Wir initialisieren auch den IR-Empfänger am zuvor definierten Pin mit LED-Feedback. Das bedeutet, dass eine LED am Arduino (und am IR-Empfängermodul) blinkt, wenn ein Code empfangen wird – praktisch zum Debuggen.
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
In der loop() Funktion prüfen wir, ob der IR-Empfänger ein Signal dekodiert hat. Falls ja, holen wir den Befehlswert aus den dekodierten Daten.
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
Dann verwenden wir eine switch-Anweisung, um den Befehl zu interpretieren. Jeder case entspricht einem anderen Befehl der Fernbedienung. Zum Beispiel druckt der Arduino bei Befehl 7 „PLAY“ in den Serial Monitor.
switch (command) {
case 7:
Serial.println("PLAY");
break;
case 3:
Serial.println("STOP");
break;
...
case 23:
Serial.println("VOL-");
break;
default:
Serial.println("UNDEFINED");
}
Nach der Interpretation des Befehls warten wir 100 Millisekunden und setzen den IR-Empfänger zurück, damit er das nächste Signal dekodieren kann.
delay(100);
IrReceiver.resume();
}
}
Dieser Code bietet einen einfachen Rahmen zum Lesen und Interpretieren von Signalen einer IR-Fernbedienung. Du kannst ihn an deine Bedürfnisse anpassen.
IR-Fernbedienung und Empfänger mit Arduino und LCD-Beispiel
Das folgende Beispiel kann verwendet werden, um die gedrückten Tastenwerte auf einem Zeichen-LCD anzuzeigen. Ich habe ein ausführliches Tutorial zur Verwendung von Zeichen-LCDs geschrieben, das du hier findest:
Wenn du lieber ein I2C-LCD verwenden möchtest, das weniger Anschlüsse benötigt, siehe das folgende Tutorial:
Für dieses Beispiel habe ich den Ausgang des IR-Empfängers an digitalen Pin 8 statt 2 angeschlossen. Die Anschlüsse für das Zeichen-LCD sind im Schaltplan unten dargestellt. Beachte, dass du auch ein 10 kΩ Potentiometer zur Kontrasteinstellung und einen 220 Ω Widerstand zur Steuerung der Hintergrundbeleuchtung benötigst.
Die Anschlüsse sind auch in der folgenden Tabelle aufgeführt. Der linke Pin des LCD ist Pin 1 (GND).
LCD- und IR-Empfänger-Anschlüsse
| Pin | Anschluss |
|---|---|
| LCD Pin 1 (GND) | Arduino GND |
| LCD Pin 2 (VCC) | Arduino 5 V |
| LCD Pin 3 (VO) | Mittlerer Pin Potentiometer |
| Linker Pin Potentiometer | Arduino 5 V |
| Rechter Pin Potentiometer | Arduino GND |
| LCD Pin 4 (RS) | Arduino Pin 2 |
| LCD Pin 5 (RW) | Arduino GND |
| LCD Pin 6 (E) | Arduino Pin 3 |
| LCD Pin 11 (DB4) | Arduino Pin 4 |
| LCD Pin 12 (DB5) | Arduino Pin 5 |
| LCD Pin 13 (DB6) | Arduino Pin 6 |
| LCD Pin 14 (DB7) | Arduino Pin 7 |
| LCD Pin 15 (LED-Anode) | Arduino 5 V über 220Ω Widerstand |
| LCD Pin 16 (LED-Kathode) | Arduino GND |
| IR-Empfänger OUT (links) | Arduino Pin 8 |
| IR-Empfänger GND (mittig) | Arduino GND |
| IR-Empfänger Vcc (rechts) | Arduino 5 V |
Wenn du Probleme mit dem LCD-Display hast, siehe das How to use a 16×2 character LCD with Arduino Tutorial für weitere Details.
Mit dem Beispielcode unten kannst du die gedrückte Taste auf dem LCD anzeigen. Wenn deine Fernbedienung andere Codes sendet, ersetze einfach die Befehlswerte und zugehörigen Tastennamen in der switch-case-Anweisung.
Beispielcode für IR-Fernbedienung und Empfänger mit Arduino und LCD-Display
Du kannst den Code kopieren, indem du auf den Button oben rechts im Codefeld klickst.
#include "IRremote.hpp"
#include "LiquidCrystal.h"
// LCD object with pin parameters (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);
#define IR_RECEIVE_PIN 8
void setup() {
lcd.begin(16, 2); // LCD with 16 columns and 2 rows
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
lcd.print("PLAY");
break;
case 3:
lcd.print("STOP");
break;
case 20:
lcd.print("MUTE");
break;
case 8:
lcd.print("NEXT");
break;
case 2:
lcd.print("PREV");
break;
case 31:
lcd.print("VOL+");
break;
case 23:
lcd.print("VOL-");
break;
default:
lcd.print("UNDEFINED");
}
delay(100);
IrReceiver.resume();
}
}
Wenn du die VOL+-Taste drückst, solltest du die folgende Ausgabe auf dem LCD sehen. Möglicherweise musst du den Potentiometer anpassen, um den Kontrast des Displays zu erhöhen.
Steuerung von LEDs (Arduino-Ausgänge) mit IR-Fernbedienung und Empfänger
Obwohl es Spaß macht, die Tastencodes im Serial Monitor oder auf einem LCD anzuzeigen, möchtest du die Fernbedienung wahrscheinlich für etwas Nützlicheres verwenden, also tatsächlich etwas steuern. Im folgenden Beispiel zeige ich dir, wie du LEDs mit der Fernbedienung ein- und ausschaltest. Du kannst diesen Code auch verwenden, um Relais, Lichter oder Motoren zu steuern.
Der Code sieht größtenteils wie die vorherigen Beispiele aus, aber ich habe zusätzliche Funktionen zur Steuerung der LEDs hinzugefügt.
Du musst die folgende Schaltung aufbauen, um die LEDs zu steuern:
Die LEDs sind an die Pins 2 bis 5 des Arduino angeschlossen, der Ausgang des IR-Empfängers an Pin 6. Ich habe 470 Ω Widerstände verwendet, um den Strom durch die LEDs zu begrenzen. Der übliche Betriebsstrom von 3 und 5 mm LEDs liegt bei etwa 20 mA. Du kannst den benötigten Widerstandswert mit einem online Rechner bestimmen.
#include "IRremote.hpp"
#define IR_RECEIVE_PIN 6
#define RED_LED_PIN 2
#define YELLOW_LED_PIN 3
#define GREEN_LED_PIN 4
#define BLUE_LED_PIN 5
void toggleLED(int pin) {
digitalWrite(pin, digitalRead(pin) == HIGH ? LOW : HIGH);
}
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
pinMode(RED_LED_PIN, OUTPUT);
pinMode(YELLOW_LED_PIN, OUTPUT);
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(BLUE_LED_PIN, OUTPUT);
digitalWrite(RED_LED_PIN, LOW);
digitalWrite(YELLOW_LED_PIN, LOW);
digitalWrite(GREEN_LED_PIN, LOW);
digitalWrite(BLUE_LED_PIN, LOW);
}
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY-BLUE");
toggleLED(BLUE_LED_PIN);
break;
case 3:
Serial.println("STOP-YELLOW");
toggleLED(YELLOW_LED_PIN);
break;
case 20:
Serial.println("MUTE-GREEN");
toggleLED(GREEN_LED_PIN);
break;
default:
Serial.println("UNDEFINED-RED");
toggleLED(RED_LED_PIN);
}
delay(100);
IrReceiver.resume();
}
}
Code-Erklärung
Zuerst binden wir wieder die IRremote.hpp Bibliothek ein, die Funktionen für die Arbeit mit IR-Fernbedienungen bereitstellt.
#include "IRremote.hpp"
Dann definieren wir die Pin-Nummern für den IR-Empfänger und die LED-Pins. Beachte, dass wir für den Empfänger einen anderen Pin (PIN 6) als zuvor (PIN 2) verwenden.
#define IR_RECEIVE_PIN 6 #define RED_LED_PIN 2 #define YELLOW_LED_PIN 3 #define GREEN_LED_PIN 4 #define BLUE_LED_PIN 5
Anschließend definieren wir eine Funktion namens toggleLED, die den Zustand eines LED-Pins umschaltet. Sie nimmt einen int Parameter pin, der die Pin-Nummer der LED darstellt. Ist der Pin HIGH, setzen wir ihn auf LOW und umgekehrt.
void toggleLED(int pin) {
digitalWrite(pin, digitalRead(pin) == HIGH ? LOW : HIGH);
}
In der setup Funktion initialisieren wir die serielle Kommunikation mit 9600 Baud. Wir initialisieren auch den IR-Empfänger und setzen die LED-Pins als Ausgänge. Schließlich schalten wir alle LEDs aus.
void setup() {
Serial.begin(9600);
IrReceiver.begin(IR_RECEIVE_PIN, ENABLE_LED_FEEDBACK);
pinMode(RED_LED_PIN, OUTPUT); // set the LED pins as output
pinMode(YELLOW_LED_PIN, OUTPUT);
pinMode(GREEN_LED_PIN, OUTPUT);
pinMode(BLUE_LED_PIN, OUTPUT);
digitalWrite(RED_LED_PIN, LOW); // turn all the LEDs off
digitalWrite(YELLOW_LED_PIN, LOW);
digitalWrite(GREEN_LED_PIN, LOW);
digitalWrite(BLUE_LED_PIN, LOW);
}
In der loop Funktion prüfen wir, ob der IR-Empfänger ein Signal empfangen hat. Wenn ja, extrahieren wir den Befehl aus den dekodierten IR-Daten. Je nach Befehl führen wir unterschiedliche Aktionen aus.
void loop() {
if (IrReceiver.decode()) {
uint16_t command = IrReceiver.decodedIRData.command;
switch (command) {
case 7:
Serial.println("PLAY-BLUE");
toggleLED(BLUE_LED_PIN);
break;
case 3:
Serial.println("STOP-YELLOW");
toggleLED(YELLOW_LED_PIN);
break;
case 20:
Serial.println("MUTE-GREEN");
toggleLED(GREEN_LED_PIN);
break;
default:
Serial.println("UNDEFINED-RED");
toggleLED(RED_LED_PIN);
}
delay(100);
IrReceiver.resume();
}
}
In diesem Codeabschnitt gibt es drei Fälle für verschiedene Befehle der IR-Fernbedienung. Bei Befehl 7 drucken wir „PLAY-BLUE“ im Serial Monitor und schalten die blaue LED um. Bei Befehl 3 drucken wir „STOP-YELLOW“ und schalten die gelbe LED um. Bei Befehl 20 drucken wir „MUTE-GREEN“ und schalten die grüne LED um. Für alle anderen Befehle drucken wir „UNDEFINED-RED“ und schalten die rote LED um.
Nach den Aktionen fügen wir eine Verzögerung von 100 Millisekunden ein und setzen den IR-Empfänger zurück, um das nächste Signal zu empfangen.
Fazit
In diesem Tutorial habe ich dir gezeigt, wie du eine IR-Fernbedienung und einen Empfänger mit Arduino verwendest. Wir haben verschiedene Codebeispiele betrachtet, um das IR-Protokoll zu bestimmen und die IR-Tastencodes deiner Fernbedienung zu identifizieren.
Anschließend haben wir die Tastenwerte im Serial Monitor und auf einem 16×2 Zeichen-LCD angezeigt. Zum Schluss habe ich dir gezeigt, wie du die Ausgänge des Arduino mit der Fernbedienung steuerst, um LEDs ein- und auszuschalten.
Wenn du Fragen, Vorschläge hast oder denkst, dass in diesem Tutorial etwas fehlt, hinterlasse bitte unten einen Kommentar.
Weitere nützliche Links aus dem Web
- Arduino-IRremote
- IRremote – Arduino Reference
- Arduino Infrared Remote Tutorial : 7 Steps
- How to Set Up an IR Remote and Receiver on an Arduino
- Arduino IR Remote Controller Tutorial
- Arduino – Control LED’s with IR Remote Control
- IR Remote Control | Arduino Tutorial
