IRSND

Wechseln zu: Navigation, Suche

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

  • 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

TEENSY 3.0 (NEU!)

  • MK20DX256VLH7 (ARM Cortex-M4 72MHz)

Unterstützte Protokolle

IRSND unterstützt die folgenden Protokolle:

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

Download

Version 3.0.8, Stand vom 25.08.2017

Download Release-Version: Irsnd.zip

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

Achtung:

Die Version im SVN kann eine Zwischen- oder Test-Version sein, die nicht den hier dokumentierten Stand widerspiegelt! Im Zweifel verwendet man besser den obigen Download auf Irsnd.zip.

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:

#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.

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 ein protokollspezifischer Wiederholungsframe (z.B. für NEC) gesendet.

Wird erneut 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

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.0.8:

  • 25.08.2017: Neues Protokoll: IRMP16 zwecks transparenter Datenübertragung von 16-Bit-Daten

Version 3.0.2:

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
  • 02.09.2010: Neues Protokoll: JVC
  • 02.09.2010: Anpassung des APPLE-Encoders an IRMP-Version 1.7.3.
  • 29.08.2010: Neues Protokoll: KASEIKYO (Panasonic u.a.)
  • 25.06.2010: Neues Protokoll: RCCAR
  • 09.06.2010: Neues Protokoll: FDC (IR-keyboard)
  • 09.06.2010: Timing für DENON-Protokoll korrigiert
  • 02.06.2010: Neues Protokoll: SIEMENS (Gigaset)
  • 02.06.2010: Simulation von langen Tastendrücken
  • 26.05.2010: Neues Protokoll: NOKIA
  • 28.04.2010: Unterstützung des APPLE-Protokolls
  • 28.04.2010: Konfiguration über irsndconfig.h
  • 16.04.2010: Sämtliche Timing-Toleranzen angepasst/optimiert
  • 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