IRSND
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
Einleitung
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
- ATtiny87, ATtiny167
- ATtiny45, ATtiny85
- ATtiny44, ATtiny84
- ATmega8, ATmega16, ATmega32
- ATmega162
- ATmega164, ATmega324, ATmega644, ATmega644P, ATmega1284
- ATmega88, ATmega88P, ATmega168, ATmega168P, ATmega328P
XMega
- ATXmega128
PIC (C18-Compiler)
- PIC12F1840
- PIC18F4520
STM32
- STM32F4xx
- STM32F10x
- STM32 mit HAL-Library (NEU!)
TEENSY 3.0
- MK20DX256VLH7 (ARM Cortex-M4 72MHz)
Unterstützte Protokolle
IRSND unterstützt die folgenden Protokolle:
- A1TVBOX
- ACP24 (NEU!)
- APPLE
- BANG_OLUFSON
- BOSE (NEU!)
- DENON
- FAN (NEU!)
- FDC (bei mind. ~15kHz)
- GRUNDIG
- IR60 (SDA2008)
- JVC
- KASEIKYO
- LEGO
- LGAIR
- MATSUSHITA
- NEC
- NEC16
- NEC42
- NIKON
- NOKIA
- NUBERT
- PANASONIC (Beamer) (NEU!)
- PENTAX (NEU!)
- RC5
- RC6
- RC6A
- RCCAR (bei mind. ~15kHz)
- RECS80 (bei mind. ~20kHz)
- RECS80EXT (bei mind. ~20kHz)
- ROOMBA
- SAMSUNG
- SAMSUNG32
- SAMSUNG48
- SIEMENS (bei mind. ~15kHz)
- SPEAKER
- TELEFUNKEN
- THOMSON
- SIRCS
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:
- irsnd.c - Der eigentliche IR-Encoder
- irmpprotocols.h - Sämtliche Definitionen zu den IR-Protokollen
- irmpsystem.h - Vom Zielsystem abhängige Definitionen für AVR/PIC/STM32
- irsnd.h - Include-Datei für die Applikation
- irsndconfig.h - Anzupassende Konfigurationsdatei
- irsnd-main-avr.c - Beispiel Anwendung
WICHTIG:
Im Applikations-Source sollte nur irsnd.h per include eingefügt werden, also lediglich:
#include "irsnd.h"
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
/*-----------------------------------------------------------------------------------------------------------------------
* Called (back) from IRSND module
* This example switches a LED (which is connected to Vcc)
*-----------------------------------------------------------------------------------------------------------------------
*/
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:
- Eingabeaufforderung starten
- In das Verzeichnis von irsnd wechseln
- Aufruf von:
irsnd.exe 2 00FF 0001 > nec.txt
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:
- 27.01.2021: Neues IR-Protokoll: MELINERA
- 27.01.2021: Protokoll LEGO: Timing verbessert
- 27.01.2021: Protokoll RUWIDO: Timing verbessert
- 27.01.2021: Protokoll NEC: Senden von Repetition-Frames ermöglicht
Version 3.2.5:
- Anpassungen an Arduino
Version 3.2.4:
- Konstanten in irsnd.c angepasst
Version 3.1.5:
- 28.08.2019: Neues Protokoll: ONKYO
Version 3.1.2:
- 06.09.2018: Support für STM32 mit HAL-Library
Version 3.0.9:
- 19.02.2018: Geringfügige Änderungen
Version 3.0.8:
- 25.08.2017: Neues Protokoll: IRMP16 zwecks transparenter Datenübertragung von 16-Bit-Daten
Version 3.0.2:
- 09.09.2016: Neues Protokoll Mitsubishi Heavy (Klimaanlage)
- 09.09.2016: Einige Anpassungen für Compiler PIC C18
Version 3.0.0:
- Beispiel main-Datei in irsnd-main-avr.c umbenannt
Ältere Versionen =
- 17.11.2015: Neues Protokoll: BOSE
- 17.11.2015: Neues Protokoll: PANASONIC (Beamer)
- 17.11.2015: Portierung auf Teensy (3.x)
- 20.09.2015: Neues Protokoll: TECHNICS
- 15.06.2015: Neues Protokoll: ACP24
- 28.05.2015: Timing-Korrekturen für FAN-Protokoll
- 27.05.2015: Neues Protokoll: MERLIN
- 27.05.2015: Neues Protokoll: FAN
- 18.05.2015: F_CPU Macro für STM32L1XX hinzugefügt
- 07.05.2015: Korrekturen zur XMega-Portierung
- 23.04.2015: Neues Protokoll: PENTAX
- 23.04.2015: Portierung auf AVR XMega
- 10.07.2014: Einige GPIO Änderungen für STM32F10x (in IRSND).
- 10.07.2014: Neues Protokoll: SAMSUNG48
- 23.06.2014: Neues Protokoll: LGAIR
- 03.06.2014: Neues Protokoll: TELEFUNKEN
- 30.05.2014: Neues Protokoll: SPEAKER
- 30.05.2014: Timings für SAMSUNG-Protokolle optimiert
- 20.02.2014: Neues Protokoll: RUWIDO
- 09.04.2013: Neues Protokoll: ROOMBA
- 12.03.2013: 15kHz für RECS80- und RECS80EXT-Protokoll ist nun auch erlaubt
- 17.01.2013: Unterstützung für ATtiny44 hinzugefügt
- 12.12.2012: Neues Protokoll: A1TVBOX
- 07.12.2012: Korrektur Timing beim NIKON-Protokoll
- 26.10.2012: Einige Timer-Korrekturen, Anpassungen an Arduino
- 18.06.2012: Unterstützung für ATtiny87/167 hinzugefügt
- 05.06.2012: Korrekturen Portierung auf ARM STM32 - nun getestet
- 23.05.2012: Portierung auf ARM STM32 (ungetestet!)
- 23.05.2012: Bugfix Timing für 2. Frame beim Denon-Protokoll
- 27.02.2012: Neues Protokoll: IR60 (SDA2008)
- 27.02.2012: Bug beim Senden von Biphase-Frames (Manchester) behoben
- 27.02.2012: Portierung auf C18 Compiler für PIC-Mikroprozessoren
- 15.02.2012: Bugfix: Nur der 1. Frame wurde gesendet
- 13.02.2012: Timing von SAMSUNG- und SAMSUNG32-Protokoll korrigiert
- 13.02.2012: KASEIKYO: Genre2-Bits werden nun im oberen Nibble von flags gespeichert.
- 13.02.2012: Zusätzliche Pause nach dem Senden des letzten Frames
- 20.09.2011: Neues Protokoll: THOMSON
- 20.09.2011: Neues Protokoll: LEGO
- 20.09.2011: Neues Protokoll: NEC16
- 20.09.2011: Neues Protokoll: NEC42
- 20.09.2011: Portierung auf ATtiny84 und ATtiny85
- 20.09.2011: Korrektur von Pausenlängen
- 20.09.2011: Korrekturen von irsnd_stop()
- 20.09.2011: Korrektur des SIEMENS-Timings
- 20.09.2011: Umstellung auf 36kHz Modulationsfrequenz für DENON-Protokoll
- 20.09.2011: Korrektur Behandlung zusätzlicher Bits im SIRCS-Protokoll
- 18.01.2011: Neues Protokoll: RC6A
- 18.01.2011: Neues Protokoll: RC6
- 18.01.2011: Neues Protokoll: NIKON
- 18.01.2011: Beachten der zusätzlichen Bits (>12) im SIRCS-Protokoll
- 18.01.2011: Korrektur der Pausenlängen
- 18.01.2011: Timing-Korrekturen für DENON-Protokoll
- 29.08.2010: Neues Protokoll: KASEIKYO (Panasonic u.a.)
- 25.06.2010: Neues Protokoll: RCCAR
- 02.06.2010: Neues Protokoll: SIEMENS (Gigaset)
- 02.06.2010: Simulation von langen Tastendrücken
- 26.05.2010: Neues Protokoll: NOKIA
- 17.05.2010: Neues Protokoll: GRUNDIG
- 17.05.2010: Behandlung von Frame-Wiederholungen für SIRCS, SAMSUNG32 und NUBERT korrigiert
- 28.04.2010: Unterstützung des APPLE-Protokolls
- 28.04.2010: Konfiguration über irsndconfig.h
- 16.04.2010: Sämtliche Timing-Toleranzen angepasst/optimiert
- 14.04.2010: Neues Protokoll: Bang & Olufsen
- 17.03.2010: Neues Protokoll: NUBERT
- 17.03.2010: Korrektur der Pausen zwischen Frame-Wiederholungen
- 16.03.2010: Korrektur des Timer-Registers TCCR2
- 16.03.2010: Korrektur der RECS80-Startbit-Timings
- 16.03.2010: Neues Protokoll: RECS80 Extended
- 11.03.2010: Anpassungen an verschiedene ATMega-Typen durchgeführt
- 07.03.2010: Alpha-Version