Remote Control

In diesem kurzen Blog-Extra geht es um Fernsteuerung über Infrarot-Fernbedienungen. Als Demonstrationsobjekt dient eine WS2812B-Matrix oder ein WS2812B-LED-Streifen.

15.08.2016, 07:00 Uhr

Lesezeit: 6 Min.

Developer

Von

Dr. Michael Stal

In diesem kurzen Blog-Extra geht es um Fernsteuerung über Infrarot-Fernbedienungen. Als Demonstrationsobjekt dient eine WS2812B-Matrix oder ein WS2812B-LED-Streifen.

In der letzten Ausgabe hatten wir uns intensiv mit der Ansteuerung von WS2812B-Pixeln beschäftigt. Gerade bei Lichteffekten ist der Einsatz einer Fernbedienung sinnvoll. Gängige Kombinationen eines IR-Empfängers und einer Fernbedienung gibt es für einen Apfel und ein Ei bei eBay zu erwerben.

Konkret ist ein entsprechendes Set für teilweise unter 5 Euro erhältlich. Große Erwartungen an die Qualität der Fernbedienung sollte man sich jedoch abschminken. Für den anvisierten Zweck ist das Gebotene aber durchaus ausreichend.

Funktionsweise von IR-Controls

Eine Infrarot-Fernbedienung sendet 940 nm Impulse über relativ geringe Instanzen von maximal 10–20 Metern. Zum Senden dient eine Infrarot-LED. Die dabei eingesetzte Frequenzmodulation arbeitet mit rund 20–70 KHz, etwa 0 = Folge von 38 KHz Bursts, 1 = keine Impulse beziehungsweise Pausen. Die Sendedauer pro Bit beträgt oft 560 Mikrosekunden. Typischerweise sendet die Fernbedienung zunächst einen charakteristischen Header, gefolgt von dem eigentlichen Tastencode. Dadurch kann eine Fernbedienung für den LED-Streifen nicht gleichzeitig den Fernseher steuern. Durch Einsatz eines Bandpassfilters können IR-Empfänger Störfrequenzen ausfiltern. Der Empfang geschieht über entsprechende Photodioden.

Neuere Fernbedienungen arbeiten mit höheren Frequenzen wie z.B. 2.4 GHz oder alternativen Kommunikationsverfahren wie z.B. Bluetooth.

Schaltung

Kommen wir gleich zum eigentlichen Schaltungsaufbau: Im Vergleich zur Schaltung aus der WS2812B-Episode gibt es nur eine Änderung. An Pin 11 erfolgt der Anschluss eines Infrarot-Empfängers, um Codes von der IR-Fernbedienung empfangen zu können. Der nachfolgende Sketch nimmt die gesendeten Codes entgegen und interpretiert sie als Kommandos an den LED-Streifen oder die LED-Matrix. Wir haben es hier also mit Heimautomatisierung in Gestalt von Lichtsteuerung zu tun. Je nach der an der Fernbedienung gedrückten Taste werden alle LEDs auf Rot (Betätigen der '1'-Taste), Grün (Betätigen der '2'-Taste) oder Blau (Betätigen der '3'-Taste) gesetzt. Bei gedrückter '0'-Taste schaltet der Sketch die LEDs hingegen aus.

Bei kleineren Lichtinstallationen mit weniger LEDs können wir auch durchaus das externe Netzteil in der Schaltung einsparen oder zumindest durch ein leistungsschwächeres austauschen.

Ich habe für den obigen Versuchsaufbau zum Beispiel eine 8x8-LED-Matrix verwendet und direkt über einen Uno gespeist – unter Nutzung des Kondensators und des Widerstands versteht sich.

Sketch

Eine geeignete Bibliothek für die Kommunikation mit IR-Fernbedienungen ist IRremote. Navigieren Sie in der Arduino IDE zu Sketch | Include Library | Manager Libraries

In das Suchfeld geben Sie IRremote als Suchbegriff ein. Dann sollte die IDE die entsprechende Bibliothek von shirriff zur Installation anbieten.

Nach der Installation können Sie sofort loslegen. Zu beachten ist dabei, dass die von einer Fernbedienung ausgesandten IR-Codes hardwareabhängig sind. Bei meiner Fernbedienung erzeugt die Taste '1' zum Beispiel den Code 0xFD00FF:

Daher habe ich im unteren Sketch Code hinzugefügt, der die empfangenen Codes am seriellen Monitor ausgibt. Ich hatte die Tasten '1', '2' und '3' gedrückt, worauf der IR-Empfänger folgende Codes erhielt:

Ausgabe empfangener IR-Codes am seriellen Monitor

Wiederholen Sie das entsprechend bei Ihrer eigenen Fernbedienung und merken Sie sich die Zuordnung von Tasten zu Codes für Ihre Version des Sketches. Geben Sie diese Codes dann statt der von mir verwendeten in den Sketch ein: siehe Methode loop().

////////////////////////////////////////////////////////
 //
 // Mini Demo zur Verwendung einer IR-Fernbedienung,
 // um bequem Lichteffekte auszulösen
 //
 ////////////////////////////////////////////////////////


// Importieren der Bibliothek IRremote:
#include <IRremote.h> 

// Importieren der Adafruit Neopixel Library:
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif


// Der IR-Signalempfänger ist an Pin 11 angeschlossen:
const int recvPort  = 11;

// Die WS2812B-LED-Matrix oder den Streifen schließen wir an
 // Pin 6 an:
const int pixelPin  =  6;

// Objekt zur Verbindung mit dem IR-Empfänger:
IRrecv irBeacon(recvPort);

// Initialisieren der Neopixel-Bibliothek. Ich benutze eine LED-Matrix
// mit 64 Pixeln. Geben Sie als erstes Argument die Zahl Ihrer Pixel ein:
Adafruit_NeoPixel strip = Adafruit_NeoPixel(64, 
                                            pixelPin, 
                                            NEO_GRB + NEO_KHZ800);

// Ergebnisvariable für empfangene IR-Codes:
decode_results irReceived;


// Initialisierung:

void setup() {
  Serial.begin(9600); // seriellen Monitor starten
  strip.begin();      // LEDs initialisieren
  strip.show();       // Anfangs sind alle LEDs aus

  Serial.println("Empfang von IR-Codes starten:");
  irBeacon.enableIRIn(); // Start
}

// Die Methode colorWipe aus dem Beispielssketch strandtest 
// der Neopixel-Bibliothek lässt alle LEDs in der gewünschten 
// Farbe <c> leuchten. Die Wartezeit zwischen dem Ansteuern 
// einzelner LEDs beträgt <wait> Millisekunden:
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}


// Die Ereignisschleife:
void loop() {
  if (irBeacon.decode(&irReceived)) // IR-Kommando empfangen
  { 
    Serial.print("Data received ...");
    Serial.println(irReceived.value, HEX); // Ausgabe am seriellen Monitor
    if (irReceived.value == 0xFD00FF) { // Taste 1
       colorWipe(strip.Color(255, 0, 0), 50); // Rot
    }
    if (irReceived.value == 0xFD807F) { // Taste 2
       colorWipe(strip.Color(0, 255, 0), 50); // Grün
    }
    if (irReceived.value == 0xFD40BF) { // Taste 3
       colorWipe(strip.Color(0, 0, 255), 50); // Blau
    }
    if (irReceived.value == 0xFFFFFFFF) { // Taste 0
       colorWipe(strip.Color(0, 0, 0), 50); // LEDs aus
    }
    irBeacon.resume(); // und zum nächsten IR-Empfang weiter
  }
}

Erweiterungen

Natürlich können Sie das Beispiel auch noch erweitern. Sie könnten Kommandos für weitere Lichtanimationen hinzufügen oder die Helligkeit dimmbar gestalten.

Es ist auch möglich, statt eines Arduino Uno eine kleinere Board-Variante zu wählen, etwa für mobile Installationen.

Zusätzlich könnten Sie ein ESP-01 (ESP8266)-Modul für Anschluss der Schaltung ans WLAN nutzen.

Zusammenfassung

In dieser Folge haben wir IR-Kommunikation als weitere Option kennengelernt, um Schaltungen zu steuern. In Kombination mit WS8212B-Pixel verwendeten wir eine Anwendung aus der Heimautomatisierung als Beispielsprojekt. Mittels eines am Arduino angeschlossen Infrarot-Empfängers lassen sich IR-Codes von einer Fernbedienung entgegennehmen und zu Steuerbefehlen umsetzen.

Die verwendete IRremote-Bibliothek ist übrigens auch in der Lage, existierende Fernbedienungen von Unterhaltungselektronik-Herstellern zu interpretieren. In diesem Fall genügt der IR-Empfänger.

Was bisher geschah:

()

nach oben

Alle Angebote

Newsletter heise-Bot Push Push-Nachrichten

${intro} ${title}