IRSND – Mikrocontroller.net (original) (raw)

Von Frank M. (ukw)

IRSND ist das Gegenstück zu IRMP - nämlich der IR-Encoder, der als IR-Sender arbeitet.

You will find the English documentation here.

IRSND - Infrarot-Multiprotokoll-Encoder

Scan eines NEC-kompatiblen Fernbedienungssignals

Einleitung

Anschluß eines einfachen IR-Senders an µC.

IRSND ist das Gegenstück zu IRMP: es reproduziert aus den Daten, die mit IRMP empfangen wurden, wieder den Original Frame, der dann über eine Infrarot-Diode ausgegeben werden kann.

Unterstützte µCs

IRSND ist auf verschiedenen Mikrocontroller-Familien lauffähig.

AVR

XMega

PIC (C18-Compiler)

STM32

TEENSY 3.0

Unterstützte Protokolle

IRSND unterstützt die folgenden Protokolle:

IRSND unterstützt die folgenden Protokolle derzeit (noch) NICHT:

Download

Version 3.2.6, Stand vom 27.01.2021

Download Release-Version: Irsnd.zip

IRMP & IRSND sind über SVN abrufbar: IRMP im SVN

Achtung:

Die Software-Änderungen kann man sich hier anschauen: Software-Historie

Source-Code

Der Source-Code lässt sich einfach übersetzen, indem man unter Windows die Projekt-Datei irsnd.aps in das AVRStudio 4 lädt.

Auch für andere Entwicklungsumgebungen lässt sich leicht ein Projekt bzw. Makefile zusammenstellen. Zum IRSND-Source gehören folgende Dateien:

WICHTIG:

Im Applikations-Source sollte nur irsnd.h per include eingefügt werden, also lediglich:

Alle anderen Include-Dateien werden automatisch über irsnd.h "eingefügt". Siehe dazu auch die Beispieldatei irsnd-main-avr.c.

IRSND encodiert sämtliche oben aufgelisteten Protokolle in einer ISR, siehe irsnd.c.

Einstellungen in irsndconfig.h

F_INTERRUPTS

Anzahl der Interrupts pro Sekunde. Der Wert kann zwischen 10000 und 20000 eingestellt werden.

Standardwert:

#define F_INTERRUPTS 15000 // interrupts per second

IRSND_SUPPORT_xxx_PROTOCOL

Hier lässt sich einstellen, welche Protokolle von IRSND unterstützt werden sollen. Die Standardprotokolle sind bereits aktiv. Möchte man weitere Protokolle einschalten bzw. einige aus Speicherplatzgründen deaktivieren, sind die entsprechenden Werte in irsndconfig.h anzupassen.

// typical protocols, disable here! Enable Remarks F_INTERRUPTS Program Space #define IRSND_SUPPORT_SIRCS_PROTOCOL 1 // Sony SIRCS >= 10000 ~200 bytes #define IRSND_SUPPORT_NEC_PROTOCOL 1 // NEC + APPLE >= 10000 ~100 bytes #define IRSND_SUPPORT_SAMSUNG_PROTOCOL 1 // Samsung + Samsung32 >= 10000 ~300 bytes #define IRSND_SUPPORT_MATSUSHITA_PROTOCOL 1 // Matsushita >= 10000 ~200 bytes #define IRSND_SUPPORT_KASEIKYO_PROTOCOL 1 // Kaseikyo >= 10000 ~300 bytes

// more protocols, enable here! Enable Remarks F_INTERRUPTS Program Space #define IRSND_SUPPORT_DENON_PROTOCOL 0 // DENON, Sharp >= 10000 ~200 bytes #define IRSND_SUPPORT_RC5_PROTOCOL 0 // RC5 >= 10000 ~150 bytes #define IRSND_SUPPORT_RC6_PROTOCOL 0 // RC6 >= 10000 ~250 bytes #define IRSND_SUPPORT_RC6A_PROTOCOL 0 // RC6A >= 10000 ~250 bytes #define IRSND_SUPPORT_JVC_PROTOCOL 0 // JVC >= 10000 ~150 bytes #define IRSND_SUPPORT_NEC16_PROTOCOL 0 // NEC16 >= 10000 ~150 bytes #define IRSND_SUPPORT_NEC42_PROTOCOL 0 // NEC42 >= 10000 ~150 bytes #define IRSND_SUPPORT_IR60_PROTOCOL 0 // IR60 (SDA2008) >= 10000 ~250 bytes #define IRSND_SUPPORT_GRUNDIG_PROTOCOL 0 // Grundig >= 10000 ~300 bytes #define IRSND_SUPPORT_SIEMENS_PROTOCOL 0 // Siemens, Gigaset >= 15000 ~150 bytes #define IRSND_SUPPORT_NOKIA_PROTOCOL 0 // Nokia >= 10000 ~400 bytes

// exotic protocols, enable here! Enable Remarks F_INTERRUPTS Program Space #define IRSND_SUPPORT_KATHREIN_PROTOCOL 0 // Kathrein >= 10000 DON'T CHANGE, NOT SUPPORTED YET! #define IRSND_SUPPORT_NUBERT_PROTOCOL 0 // NUBERT >= 10000 ~100 bytes #define IRSND_SUPPORT_BANG_OLUFSEN_PROTOCOL 0 // Bang&Olufsen >= 10000 ~250 bytes #define IRSND_SUPPORT_RECS80_PROTOCOL 0 // RECS80 >= 15000 ~100 bytes #define IRSND_SUPPORT_RECS80EXT_PROTOCOL 0 // RECS80EXT >= 15000 ~100 bytes #define IRSND_SUPPORT_THOMSON_PROTOCOL 0 // Thomson >= 10000 ~250 bytes #define IRSND_SUPPORT_NIKON_PROTOCOL 0 // NIKON >= 10000 ~150 bytes #define IRSND_SUPPORT_NETBOX_PROTOCOL 0 // Netbox keyboard >= 10000 DON'T CHANGE, NOT SUPPORTED YET! #define IRSND_SUPPORT_FDC_PROTOCOL 0 // FDC IR keyboard >= 10000 (better 15000) ~150 bytes #define IRSND_SUPPORT_RCCAR_PROTOCOL 0 // RC CAR >= 10000 (better 15000) ~150 bytes #define IRSND_SUPPORT_ROOMBA_PROTOCOL 0 // iRobot Roomba >= 10000 ~150 bytes #define IRSND_SUPPORT_RUWIDO_PROTOCOL 0 // RUWIDO, T-Home >= 15000 ~250 bytes #define IRSND_SUPPORT_A1TVBOX_PROTOCOL 0 // A1 TV BOX >= 15000 (better 20000) ~200 bytes #define IRSND_SUPPORT_LEGO_PROTOCOL 0 // LEGO Power RC >= 20000 ~150 bytes

Mit Setzen auf 0 wird das Protokoll deaktiviert, mit Setzen auf 1 wird es aktiviert. Die deaktivierten Protokolle werden dann nicht mitübersetzt. Das spart Speicherplatz im Flash, siehe Angaben in obigen Kommentaren. Wenn man unbedingt Speicherplatz sparen muss, gelten natürlich hier dieselben Tipps wie für IRMP.

Um das APPLE-Protokoll zu unterstützen, ist IRSND_SUPPORT_NEC_PROTOCOL auf 1 zu setzen, da es sich hier lediglich um einen Spezialfall vom NEC-Protokoll handelt.

IRSND_OCx

Für das Senden der IR-Signale benötigt IRSND einen PWM-fähigen Output-Pin, da das Signal moduliert werden muss. Möglich sind eine der folgenden Einstellungen:

#define IRSND_OCx IRSND_OC2 // OC2 on ATmegas supporting OC2, e.g. ATmega8 #define IRSND_OCx IRSND_OC2A // OC2A on ATmegas supporting OC2A, e.g. ATmega88 #define IRSND_OCx IRSND_OC2B // OC2B on ATmegas supporting OC2B, e.g. ATmega88 #define IRSND_OCx IRSND_OC0 // OC0 on ATmegas supporting OC0, e.g. ATmega162 #define IRSND_OCx IRSND_OC0A // OC0A on ATmegas/ATtinys supporting OC0A, e.g. ATtiny84, ATtiny85 #define IRSND_OCx IRSND_OC0B // OC0B on ATmegas/ATtinys supporting OC0B, e.g. ATtiny84, ATtiny85

Standardwert:

#define IRSND_OCx IRSND_OC2B

Für die PIC- und STM32-µCs sind entsprechende Werte anzupassen, siehe Kommentare in irsndconfig.h.

IRSND_USE_CALLBACK

Standardwert:

#define IRSND_USE_CALLBACK 0 // flag: 0 = don't use callbacks, 1 = use callbacks, default is 0

Wenn man Callbacks einschaltet, wird bei jeder Änderung des Signals (IR-Modulation ein/aus) eine Callback-Funktion aufgerufen. Dies kann zum Beispiel dafür verwendet werden, ein unmoduliertes Signal an einem weiteren Pin auszugeben.

Hier ein Beispiel:

#define LED_PORT PORTD // LED at PD6 #define LED_DDR DDRD #define LED_PIN 6

/*-----------------------------------------------------------------------------------------------------------------------

*/ void led_callback (uint8_t on) { if (on) { LED_PORT &= ~(1 << LED_PIN); } else { LED_PORT |= (1 << LED_PIN); } }

int main () { ... LED_DDR |= (1 << LED_PIN); // LED pin to output LED_PORT |= (1 << LED_PIN); // switch LED off (active low) irsnd_init (); irsnd_set_callback_ptr (led_callback); sei (); ... }

Anwendung von IRSND

IRSND baut den zu sendenden Frame "on-the-fly" aus der IRMP-Datenstruktur wieder zusammen. Dazu zählen:

  1. ID für verwendetes Protokoll
  2. Adresse bzw. Herstellercode
  3. Kommando

Mittels der Funktion

irsnd_send_data (IRMP_DATA * irmp_data_p)

kann man ein zu encodierendes Telegramm versenden. Der Return-Wert ist 1, wenn das Telegramm versendet werden kann, sonst 0. Im ersten Fall werden die Struct-Members

irmp_data_p->protocol
irmp_data_p->address
irmp_data_p->command
irmp_data_p->flags

ausgelesen und dann als Frame im jeweils gewünschten Protokoll gesendet.

irmp_data_p->flags gibt die Anzahl der Wiederholungen an, z.B.

irmp_data_p->flags = 0: keine Wiederholung irmp_data_p->flags = 1: 1 Wiederholung irmp_data_p->flags = 2: 2 Wiederholungen usw.

Es sind maximal 14 Wiederholungen möglich. Der Wert 15 bedeutet etwas besonderes: In diesem Fall gibt es eine Dauerwiederholung. In irsnd.h sind dafür Konstanten definiert:

#define IRSND_NO_REPETITIONS 0 // no repetitions #define IRSND_MAX_REPETITIONS 14 // max # of repetitions #define IRSND_ENDLESS_REPETITION 15 // endless repetions #define IRSND_REPETITION_MASK 0x0F // lower nibble of flags #define IRSND_RAW_REPETITION_FRAME 0x10 // send raw repetition frames, yet only used for NEC

Zu beachten: Es ist unbedingt darauf zu achten, dass irmp_data_p->flags vor dem Aufruf von irsnd_send_data() einen definierten Wert hat!

Hier ein Beispiel:

IRMP_DATA irmp_data;

irmp_data.protocol = IRMP_NEC_PROTOCOL; // sende im NEC-Protokoll irmp_data.address = 0x00FF; // verwende Adresse 0x00FF irmp_data.command = 0x0001; // sende Kommando 0001 irmp_data.flags = 0; // keine Wiederholung!

(void) irsnd_send_data (&irmp_data, FALSE); // versende ohne Prüfung und ohne Warten

Der Frame wird asynchron über die Interrupt-Routine irsnd_ISR() verschickt, so dass die Funktion irsnd_send_data() sofort zurückkommt.

Sind Wiederholungen angegeben, wird entweder der Frame nach einer Pause (protokollabhängig) neu ausgegeben oder automatisch ein protokollspezifischer Wiederholungsframe (z.B. für NEC) gesendet.

Wiederholungsframes für NEC

Normalerweise sendet IRSND die Wiederholungsframes selbst - je nachdem, wieviele Wiederholungen in flags angegeben werden - siehe oben.

Speziell für NEC kann man nun ab Version 3.2.6 Wiederholungsframes gezielt selbst senden. Dies ist speziell für IR-Repeater sinnvoll.

Dabei ist für flags zu setzen:

IRMP_DATA irmp_data;

irmp_data.protocol = IRMP_NEC_PROTOCOL; // sende im NEC-Protokoll irmp_data.address = 0x00FF; // Adresse wird ignoriert irmp_data.command = 0x0001; // Kommando wird ignoriert irmp_data.flags = IRSND_RAW_REPETITION_FRAME; // sende einen NEC-Wiederholungsframe

(void) irsnd_send_data (&irmp_data, TRUE); // versende und warte

Man kann auch Wiederholungsframes wiederholen, nämlich folgendermaßen:

irmp_data.flags = IRSND_RAW_REPETITION_FRAME | 0x02; // sende einen NEC-Wiederholungsframe, wiederhole diesen 2 mal

Auch hier kann man bis zu 14 Wiederholungen senden, also max. 15 Frames.

Warten

Wird irgendwann später erneut die Funktion irsnd_send_data() aufgerufen, wartet diese, bis der vorhergenhende Frame vollständig verschickt wurde. Man kann aber auch selbst prüfen, ob IRSND gerade "busy" ist oder nicht:

while (irsnd_is_busy ()) { ; // selber warten oder was anderes tun... } (void) irsnd_send_data (&irmp_data, FALSE); // versende ohne Prüfung und ohne Warten

Wird irsnd_send_data() mit dem 2. Argument TRUE aufgerufen, kommt diese Funktion erst zurück, wenn der Frame komplett ausgesendet wurde.

Im Beispiel-Source irsnd-main-avr.c findet man neben der Verwendung von irsnd_send_data() auch den Timer-Aufruf:

ISR(TIMER1_COMPA_vect) { irsnd_ISR()) // call irsnd ISR // call other timer interrupt routines... }

Paralleles Betreiben von IRMP und IRSND

Möchte man IRMP und IRSND parallel verwenden (also als Sender und Empfänger) schreibt man die ISR folgendermaßen:

ISR(TIMER1_COMPA_vect) { if (! irsnd_ISR()) // call irsnd ISR { // if not busy... irmp_ISR(); // call irmp ISR } // call other timer interrupt routines... }

Das heisst: Nur wenn irsnd_ISR() nichts zu tun hat, dann rufe die ISR des Empfängers auf. Damit ist der Empfänger solange abgeschaltet, während irsnd_ISR() noch Daten sendet. Die Timer-Initialisierungsroutine ist für IRMP und IRSND dann natürlich dieselbe.

Eine gemeinsame main-Funktion könnte dann zum Beispiel folgendermaßen aussehen:

int main (void) { IRMP_DATA irmp_data;

irmp_init(); // initialize irmp irsnd_init(); // initialize irsnd timer_init(); // initialize timer sei (); // enable interrupts

for (;;) { if (irmp_get_data (&irmp_data)) { irmp_data.flags = 0; // reset flags! irsnd_send_data (&irmp_data); } } }

Die Funktion des obigen Sources ist offensichtlich: Ein empfangenes Telegramm wird nach vollständiger Decodierung wieder encodiert und dann wieder über die IR-Diode ausgesandt. Somit können dann zum Beispiel Signale "um die Ecke" oder streckenweise drahtgebunden übertragen werden.

Desweiteren könnte man auch Protokolle transformieren, zum Beispiel NEC-Telegramme in RC5 umwandeln, wenn man seine Original-RC5-FB zu seinem Philips-Gerät verlegt hat...

Der Rest bleibt der Phantasie des geneigten Lesers überlassen ;-)

Hier noch die möglichen Werte für irmp_data.protocol, siehe auch irmpprotocols.h:

#define IRMP_SIRCS_PROTOCOL 1 // Sony #define IRMP_NEC_PROTOCOL 2 // NEC, Pioneer, JVC, Toshiba, NoName etc. #define IRMP_SAMSUNG_PROTOCOL 3 // Samsung #define IRMP_MATSUSHITA_PROTOCOL 4 // Matsushita #define IRMP_KASEIKYO_PROTOCOL 5 // Kaseikyo (Panasonic etc) #define IRMP_RECS80_PROTOCOL 6 // Philips, Thomson, Nordmende, Telefunken, Saba #define IRMP_RC5_PROTOCOL 7 // Philips etc #define IRMP_DENON_PROTOCOL 8 // Denon, Sharp #define IRMP_RC6_PROTOCOL 9 // Philips etc #define IRMP_SAMSUNG32_PROTOCOL 10 // Samsung32: no sync pulse at bit 16, length 32 instead of 37 #define IRMP_APPLE_PROTOCOL 11 // Apple, very similar to NEC #define IRMP_RECS80EXT_PROTOCOL 12 // Philips, Technisat, Thomson, Nordmende, Telefunken, Saba #define IRMP_NUBERT_PROTOCOL 13 // Nubert #define IRMP_BANG_OLUFSEN_PROTOCOL 14 // Bang & Olufsen #define IRMP_GRUNDIG_PROTOCOL 15 // Grundig #define IRMP_NOKIA_PROTOCOL 16 // Nokia #define IRMP_SIEMENS_PROTOCOL 17 // Siemens, e.g. Gigaset #define IRMP_FDC_PROTOCOL 18 // FDC keyboard #define IRMP_RCCAR_PROTOCOL 19 // RC Car #define IRMP_JVC_PROTOCOL 20 // JVC (NEC with 16 bits) #define IRMP_RC6A_PROTOCOL 21 // RC6A, e.g. Kathrein, XBOX #define IRMP_NIKON_PROTOCOL 22 // Nikon #define IRMP_RUWIDO_PROTOCOL 23 // Ruwido, e.g. T-Home Mediareceiver #define IRMP_IR60_PROTOCOL 24 // IR60 (SDA2008) #define IRMP_KATHREIN_PROTOCOL 25 // Kathrein #define IRMP_NETBOX_PROTOCOL 26 // Netbox keyboard (bitserial) #define IRMP_NEC16_PROTOCOL 27 // NEC with 16 bits (incl. sync) #define IRMP_NEC42_PROTOCOL 28 // NEC with 42 bits #define IRMP_LEGO_PROTOCOL 29 // LEGO Power Functions RC #define IRMP_THOMSON_PROTOCOL 30 // Thomson #define IRMP_BOSE_PROTOCOL 31 // BOSE #define IRMP_A1TVBOX_PROTOCOL 32 // A1 TV Box #define IRMP_ORTEK_PROTOCOL 33 // ORTEK - Hama #define IRMP_TELEFUNKEN_PROTOCOL 34 // Telefunken (1560) #define IRMP_ROOMBA_PROTOCOL 35 // iRobot Roomba vacuum cleaner #define IRMP_RCMM32_PROTOCOL 36 // Fujitsu-Siemens (Activy remote control) #define IRMP_RCMM24_PROTOCOL 37 // Fujitsu-Siemens (Activy keyboard) #define IRMP_RCMM12_PROTOCOL 38 // Fujitsu-Siemens (Activy keyboard) #define IRMP_SPEAKER_PROTOCOL 39 // Another loudspeaker protocol, similar to Nubert #define IRMP_LGAIR_PROTOCOL 40 // LG air conditioner #define IRMP_SAMSUNG48_PROTOCOL 41 // air conditioner with SAMSUNG protocol (48 bits) #define IRMP_MERLIN_PROTOCOL 42 // Merlin (Pollin 620 185) #define IRMP_PENTAX_PROTOCOL 43 // Pentax camera #define IRMP_FAN_PROTOCOL 44 // FAN (ventilator), very similar to NUBERT, but last bit is data bit instead of stop bit #define IRMP_S100_PROTOCOL 45 // very similar to RC5, but 14 instead of 13 data bits #define IRMP_ACP24_PROTOCOL 46 // Stiebel Eltron ACP24 air conditioner #define IRMP_TECHNICS_PROTOCOL 47 // Technics, similar to Matsushita, but 22 instead of 24 bits #define IRMP_PANASONIC_PROTOCOL 48 // Panasonic (Beamer), start bits similar to KASEIKYO #define IRMP_MITSU_HEAVY_PROTOCOL 49 // Mitsubishi-Heavy Aircondition, similar timing as Panasonic beamer #define IRMP_VINCENT_PROTOCOL 50 // Vincent #define IRMP_SAMSUNGAH_PROTOCOL 51 // SAMSUNG AH #define IRMP_IRMP16_PROTOCOL 52 // IRMP specific protocol for data transfer, e.g. between two microcontrollers via IR #define IRMP_GREE_PROTOCOL 53 // Gree climate #define IRMP_RCII_PROTOCOL 54 // RC II Infra Red Remote Control Protocol for FM8 #define IRMP_METZ_PROTOCOL 55 // METZ #define IRMP_ONKYO_PROTOCOL 56 // Onkyo

Die Daten für die Adresse und das Kommando ermittelt man am besten über IRMP, siehe weiter oben ;-)

IRSND unter Linux und Windows

Übersetzen von IRSND

irsnd.c lässt sich auch unter Linux direkt kompilieren, um damit Telegramme in Form von IRMP-Scan-Dateien zu erzeugen. Das geht folgendermaßen:

make -f makefile.unx

Aufruf von IRSND

Der Aufruf geht dann folgendermaßen:

./irsnd protocol-number hex-address hex-command [repeat] > filename.txt

also zum Beispiel für das NEC-Protokoll, Adresse 0x00FF, Kommando 0x0001

./irsnd 2 00FF 0001 > nec.txt # irsnd ausführen

IRSND unter Windows

IRSND kann man auch unter Windows nutzen, nämlich folgendermaßen:

Nun kann man direkt mit IRMP anschließend testen, ob das erzeugte Telegramm auch korrekt ist:

       ./irmp-15kHz < nec.txt

bzw. unter Windows:

       irmp.exe < nec.txt

Das Ganze geht auch ohne Zwischendatei, nämlich:

       ./irsnd-15kHz 2 00FF 0001 | ./irmp-15kHz

bzw. unter Windows:

       irsnd.exe 2 00FF 0001 | irmp.exe

IRMP gibt dann als Ergebnis folgendes aus:

       11111111000000001000000001111111 p =  2, a = 0x00ff, c = 0x0001, f = 0x00

IRMP konnte also aus dem von IRSND generierten Frame wieder das Protokoll 2, Adresse 0x00FF und Kommando 0x0001 decodieren.

Tatsächlich simuliert IRSND unter Linux/Windows immer das zweimalige Drücken einer Taste - mit einer Pause dazwischen. Als Egebnis erscheint daher:

       11111111000000001000000001111111 p =  2, a = 0x00ff, c = 0x0001, f = 0x00
       11111111000000001000000001111111 p =  2, a = 0x00ff, c = 0x0001, f = 0x00

Der Grund ist einfach: Damit kann man wunderbar testen, ob bei Protokollen mit Toggle-Bit dieses von IRSND auch korrekt behandelt wird:

       ./irsnd-15kHz 7 2 3 0 | ./irmp-15kHz
       1100010000011 p= 7 (RC5), a=0x0002, c=0x0003, f=0x00  **Erster Tastendruck**
       1000010000011 p= 7 (RC5), a=0x0002, c=0x0003, f=0x00  **Zweiter Tastendruck**
        ^
        Toggle-Bit

Bitte beachten: Je nach benutztem Protokoll sind die Bit-Breiten der Adressen bzw. Kommandos verschieden, siehe Tabelle Die IR-Protokolle im Detail.

Man kann also nicht mit jedem IR-Protokoll komplett 16-Bit breite Adressen oder Kommandos transparent übertragen.

Anhang

Software-Historie

Änderungen IRSND in 3.0.x

Version 3.2.6:

Version 3.2.5:

Version 3.2.4:

Version 3.1.5:

Version 3.1.2:

Version 3.0.9:

Version 3.0.8:

Version 3.0.2:

Version 3.0.0:

Ältere Versionen =