Johannes Stratmann
First release of porting 'Infrared Multiprotocol' library from mikrocontroller.net
IRMP - Infrared Multiprotocol Decoder
This library is a mbed version of the famous IRMP code, developed by members of the german forum http://mikrocontroller.net. It can receive and analyze a large number of infrared remote codes. In the original version there is also code for an IR transmitter, this will be added to this lib soon.
Base for this initial release is version 2.9.7 from 2015/11. A detailed description for this lib can be found here : https://www.mikrocontroller.net/articles/IRMP_-_english.
The code was originally written for AVR mikrocontrollers and has been ported to different platforms already. It works also great with the mbed target as it can use the unique I/O and ticker code.
Actually, the code uses the static C functions and is not ported to C++ yet to maintain compatibility to the original library. This requres the DigitalIn Pinname setting in the irmpconfig.h.
The required hardware is e.g. just an TSOP31238 (for 38 kHz modulated IR) or similar.
Information
How to use
- import this library
- edit irmpconfig.h and turn on the desired protocols
- change F_INTERRUPTS if necessary, check the protocol table for the minimum necessary frequency
- search for 'IRMP_PIN' in the irmpconfig and replace with your hardware input
The irmp_ISR() must be called cyclic with a fixed frequency, a simple task for the mbed ticker. In the main program the result is checked by calling irmp_get_data(). This function returns the decoded protocol, address, command and flags like key pressed or released.
Information
Tested platforms
- simple LPC1347 board, works fine
- EA LPC4088 QuickStart Board works fine
- LPCXpresso1549 bad, there is a (known?) issue with slow Ticker ISR processing, ISR consumes >30µs instead of 3 µs
- STM32F103 board: bad, also known problems with Ticker implementation
- Test results with other boards are welcome.
Sample code
prints the information about decoded signals to stdout. The ISR contains additional code for performance mesuring which can be omitted in controlling applications.
Import programIRMP_Receiver
Sample code for IRMP library
Last commit 09 Jan 2016 by 
Johannes Stratmann
Sample for decoding and performance test
#include "mbed.h"
#include "irmp.h"
#define LED_ON 0
#define LED_OFF 1
// LED as test output
DigitalOut led(LED1, LED_OFF);
DigitalOut flash(LED2, LED_OFF);
// cyclic interrupt for IRMP ISR worker
Ticker t;
// only for performance test
Timer timerPerfTest;
int timeISRMax = 0;
float timeISRAvg;
int timeISRAvgSum = 0;
int countISRCalls = 0;
// this ISR must be called cyclic
void irmpISR(void)
{
int t1 = timerPerfTest.read_us(); // read performance timer
irmp_ISR(); // call irmp ISR
int timeISR = timerPerfTest.read_us() - t1; // calc time spent in worker ISR
if (timeISR > timeISRMax) // store maximum
timeISRMax = timeISR;
timeISRAvgSum += timeISR; // sum for avg
countISRCalls++;
}
int main() {
printf("IRMP on mbed\n");
led = LED_OFF;
timerPerfTest.start();
// irmp_data holds result of received IR code
IRMP_DATA irmp_data;
irmp_init(); // initialize irmp
t.attach_us(&irmpISR, 1E6 / F_INTERRUPTS); // call ISR 15.000 / s
// infinite loop, interrupts will blink PORTD pins and handle UART communications.
while (1)
{
flash = !flash; // test output. flashes at 15/2 kHz, you will not see it blinking
// check for received IR commands
if (irmp_get_data (&irmp_data))
{
// ir signal decoded, do something here...
// irmp_data.protocol is the protocol, see irmp.h
// irmp_data.address is the address/manufacturer code of ir sender
// irmp_data.command is the command code
// irm_data.flags is press/release information
// irmp_protocol_names[irmp_data.protocol] is the protocol name (if enabled, see irmpconfig.h)
// printf("proto %d addr %d cmd %d\n", irmp_data.protocol, irmp_data.address, irmp_data.command );
// sample decoding, turn LED on / off
if (irmp_data.protocol == IRMP_RC5_PROTOCOL && irmp_data.address == 5) // old RC5 VCR Remote. TV uses address 0
{
if (irmp_data.flags == 0) // switch only on button press
{
switch (irmp_data.command)
{
case 0: // Key '0'
led = LED_OFF;
break;
case 1: // Key '1'
led = LED_ON;
break;
case 53: // Key 'play'
printf("bring me a beer!\n");
break;
case 54: // Key 'stop'
timeISRAvg = (float)timeISRAvgSum / countISRCalls;
timeISRAvgSum = 0;
countISRCalls = 0;
printf("ISR max / avg runtime [microseconds] : %d / %5.2f\n", timeISRMax, timeISRAvg);
timeISRMax = 0;
break;
}
}
}
// log to stdout
printf("proto %d addr %d cmd %d flags %x name %s\n", irmp_data.protocol, irmp_data.address, irmp_data.command, irmp_data.flags, irmp_protocol_names[irmp_data.protocol] );
}
}
}
irmp.c
- Committer:
- JojoS
- Date:
- 2016-01-09
- Revision:
- 0:a0715ea739cb
File content as of revision 0:a0715ea739cb:
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* irmp.c - infrared multi-protocol decoder, supports several remote control protocols
*
* Copyright (c) 2009-2015 Frank Meyer - frank(at)fli4l.de
*
* $Id: irmp.c,v 1.183 2015/12/03 18:13:45 fm Exp $
*
* Supported AVR mikrocontrollers:
*
* ATtiny87, ATtiny167
* ATtiny45, ATtiny85
* ATtiny44, ATtiny84
* ATmega8, ATmega16, ATmega32
* ATmega162
* ATmega164, ATmega324, ATmega644, ATmega644P, ATmega1284, ATmega1284P
* ATmega88, ATmega88P, ATmega168, ATmega168P, ATmega328P
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
#include "irmp.h"
#if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 || IRMP_SUPPORT_NOKIA_PROTOCOL == 1 || IRMP_SUPPORT_IR60_PROTOCOL == 1
# define IRMP_SUPPORT_GRUNDIG_NOKIA_IR60_PROTOCOL 1
#else
# define IRMP_SUPPORT_GRUNDIG_NOKIA_IR60_PROTOCOL 0
#endif
#if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1 || IRMP_SUPPORT_RUWIDO_PROTOCOL == 1
# define IRMP_SUPPORT_SIEMENS_OR_RUWIDO_PROTOCOL 1
#else
# define IRMP_SUPPORT_SIEMENS_OR_RUWIDO_PROTOCOL 0
#endif
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 || \
IRMP_SUPPORT_S100_PROTOCOL == 1 || \
IRMP_SUPPORT_RC6_PROTOCOL == 1 || \
IRMP_SUPPORT_GRUNDIG_NOKIA_IR60_PROTOCOL == 1 || \
IRMP_SUPPORT_SIEMENS_OR_RUWIDO_PROTOCOL == 1 || \
IRMP_SUPPORT_IR60_PROTOCOL == 1 || \
IRMP_SUPPORT_A1TVBOX_PROTOCOL == 1 || \
IRMP_SUPPORT_MERLIN_PROTOCOL == 1 || \
IRMP_SUPPORT_ORTEK_PROTOCOL == 1
# define IRMP_SUPPORT_MANCHESTER 1
#else
# define IRMP_SUPPORT_MANCHESTER 0
#endif
#if IRMP_SUPPORT_NETBOX_PROTOCOL == 1
# define IRMP_SUPPORT_SERIAL 1
#else
# define IRMP_SUPPORT_SERIAL 0
#endif
#define IRMP_KEY_REPETITION_LEN (uint_fast16_t)(F_INTERRUPTS * 150.0e-3 + 0.5) // autodetect key repetition within 150 msec
#define MIN_TOLERANCE_00 1.0 // -0%
#define MAX_TOLERANCE_00 1.0 // +0%
#define MIN_TOLERANCE_02 0.98 // -2%
#define MAX_TOLERANCE_02 1.02 // +2%
#define MIN_TOLERANCE_03 0.97 // -3%
#define MAX_TOLERANCE_03 1.03 // +3%
#define MIN_TOLERANCE_05 0.95 // -5%
#define MAX_TOLERANCE_05 1.05 // +5%
#define MIN_TOLERANCE_10 0.9 // -10%
#define MAX_TOLERANCE_10 1.1 // +10%
#define MIN_TOLERANCE_15 0.85 // -15%
#define MAX_TOLERANCE_15 1.15 // +15%
#define MIN_TOLERANCE_20 0.8 // -20%
#define MAX_TOLERANCE_20 1.2 // +20%
#define MIN_TOLERANCE_30 0.7 // -30%
#define MAX_TOLERANCE_30 1.3 // +30%
#define MIN_TOLERANCE_40 0.6 // -40%
#define MAX_TOLERANCE_40 1.4 // +40%
#define MIN_TOLERANCE_50 0.5 // -50%
#define MAX_TOLERANCE_50 1.5 // +50%
#define MIN_TOLERANCE_60 0.4 // -60%
#define MAX_TOLERANCE_60 1.6 // +60%
#define MIN_TOLERANCE_70 0.3 // -70%
#define MAX_TOLERANCE_70 1.7 // +70%
#define SIRCS_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SIRCS_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIRCS_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIRCS_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SIRCS_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SIRCS_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#if IRMP_SUPPORT_NETBOX_PROTOCOL // only 5% to avoid conflict with NETBOX:
# define SIRCS_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIRCS_START_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5))
#else // only 5% + 1 to avoid conflict with RC6:
# define SIRCS_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIRCS_START_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#endif
#define SIRCS_1_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SIRCS_1_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIRCS_1_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIRCS_1_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SIRCS_0_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SIRCS_0_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIRCS_0_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIRCS_0_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SIRCS_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SIRCS_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIRCS_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIRCS_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define NEC_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NEC_START_BIT_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define NEC_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NEC_START_BIT_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define NEC_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NEC_START_BIT_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define NEC_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NEC_START_BIT_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define NEC_REPEAT_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NEC_REPEAT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define NEC_REPEAT_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NEC_REPEAT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define NEC_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NEC_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define NEC_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NEC_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define NEC_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NEC_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define NEC_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NEC_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define NEC_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NEC_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define NEC_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NEC_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
// autodetect nec repetition frame within 50 msec:
// NEC seems to send the first repetition frame after 40ms, further repetition frames after 100 ms
#if 0
#define NEC_FRAME_REPEAT_PAUSE_LEN_MAX (uint_fast16_t)(F_INTERRUPTS * NEC_FRAME_REPEAT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5)
#else
#define NEC_FRAME_REPEAT_PAUSE_LEN_MAX (uint_fast16_t)(F_INTERRUPTS * 100.0e-3 * MAX_TOLERANCE_20 + 0.5)
#endif
#define SAMSUNG_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SAMSUNG_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SAMSUNG_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SAMSUNG_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SAMSUNG_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define SAMSUNG_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define SAMSUNG_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define SAMSUNG_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define SAMSUNG_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define SAMSUNG_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SAMSUNG_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define MATSUSHITA_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define MATSUSHITA_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define MATSUSHITA_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define MATSUSHITA_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define MATSUSHITA_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define MATSUSHITA_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define MATSUSHITA_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define MATSUSHITA_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define MATSUSHITA_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define MATSUSHITA_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * MATSUSHITA_0_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define KASEIKYO_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define KASEIKYO_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define KASEIKYO_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define KASEIKYO_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define KASEIKYO_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define KASEIKYO_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define KASEIKYO_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define KASEIKYO_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define KASEIKYO_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define KASEIKYO_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KASEIKYO_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define PANASONIC_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define PANASONIC_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define PANASONIC_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define PANASONIC_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define PANASONIC_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define PANASONIC_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define PANASONIC_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define PANASONIC_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define PANASONIC_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define PANASONIC_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PANASONIC_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RECS80_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RECS80_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RECS80_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RECS80_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RECS80_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#if IRMP_SUPPORT_BOSE_PROTOCOL == 1 // BOSE conflicts with RC5, so keep tolerance for RC5 minimal here:
#define RC5_START_BIT_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define RC5_START_BIT_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#else
#define RC5_START_BIT_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC5_START_BIT_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#endif
#define RC5_BIT_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC5_BIT_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#if IRMP_SUPPORT_BOSE_PROTOCOL == 1 // BOSE conflicts with S100, so keep tolerance for S100 minimal here:
#define S100_START_BIT_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * S100_BIT_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define S100_START_BIT_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * S100_BIT_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#else
#define S100_START_BIT_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * S100_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define S100_START_BIT_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * S100_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#endif
#define S100_BIT_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * S100_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define S100_BIT_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * S100_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define DENON_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define DENON_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define DENON_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define DENON_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
// RUWIDO (see t-home-mediareceiver-15kHz.txt) conflicts here with DENON
#define DENON_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define DENON_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define DENON_AUTO_REPETITION_PAUSE_LEN ((uint_fast16_t)(F_INTERRUPTS * DENON_AUTO_REPETITION_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define THOMSON_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * THOMSON_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define THOMSON_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * THOMSON_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define THOMSON_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * THOMSON_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define THOMSON_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * THOMSON_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define THOMSON_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * THOMSON_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define THOMSON_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * THOMSON_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC6_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC6_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC6_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RC6_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC6_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RC6_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC6_TOGGLE_BIT_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RC6_TOGGLE_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC6_TOGGLE_BIT_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RC6_TOGGLE_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC6_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RC6_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC6_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RC6_BIT_TIME * MAX_TOLERANCE_60 + 0.5) + 1) // pulses: 300 - 800
#define RC6_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RC6_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC6_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RC6_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1) // pauses: 300 - 600
#define RECS80EXT_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RECS80EXT_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RECS80EXT_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80EXT_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80EXT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RECS80EXT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RECS80EXT_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80EXT_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80EXT_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80EXT_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RECS80EXT_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define NUBERT_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NUBERT_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NUBERT_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NUBERT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NUBERT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_1_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NUBERT_1_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_1_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NUBERT_1_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NUBERT_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NUBERT_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_0_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NUBERT_0_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_0_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NUBERT_0_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define FAN_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FAN_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define FAN_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FAN_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define FAN_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FAN_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define FAN_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FAN_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define FAN_1_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FAN_1_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define FAN_1_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FAN_1_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define FAN_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FAN_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define FAN_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FAN_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define FAN_0_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FAN_0_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define FAN_0_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FAN_0_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define FAN_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FAN_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define FAN_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FAN_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define SPEAKER_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define SPEAKER_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define SPEAKER_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define SPEAKER_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define SPEAKER_1_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_1_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define SPEAKER_1_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_1_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define SPEAKER_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define SPEAKER_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define SPEAKER_0_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_0_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define SPEAKER_0_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_0_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define SPEAKER_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define SPEAKER_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SPEAKER_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX ((PAUSE_LEN)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1) // value must be below IRMP_TIMEOUT
#define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_R_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_R_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define IR60_TIMEOUT_LEN ((uint_fast8_t)(F_INTERRUPTS * IR60_TIMEOUT_TIME * 0.5))
#define GRUNDIG_NOKIA_IR60_START_BIT_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * GRUNDIG_NOKIA_IR60_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define GRUNDIG_NOKIA_IR60_START_BIT_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * GRUNDIG_NOKIA_IR60_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define GRUNDIG_NOKIA_IR60_BIT_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * GRUNDIG_NOKIA_IR60_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define GRUNDIG_NOKIA_IR60_BIT_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * GRUNDIG_NOKIA_IR60_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define GRUNDIG_NOKIA_IR60_PRE_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * GRUNDIG_NOKIA_IR60_PRE_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) + 1)
#define GRUNDIG_NOKIA_IR60_PRE_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * GRUNDIG_NOKIA_IR60_PRE_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SIEMENS_OR_RUWIDO_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIEMENS_OR_RUWIDO_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SIEMENS_OR_RUWIDO_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIEMENS_OR_RUWIDO_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SIEMENS_OR_RUWIDO_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SIEMENS_OR_RUWIDO_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIEMENS_OR_RUWIDO_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIEMENS_OR_RUWIDO_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SIEMENS_OR_RUWIDO_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * SIEMENS_OR_RUWIDO_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIEMENS_OR_RUWIDO_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * SIEMENS_OR_RUWIDO_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define FDC_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1) // 5%: avoid conflict with NETBOX
#define FDC_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MAX_TOLERANCE_05 + 0.5))
#define FDC_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define FDC_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5))
#define FDC_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define FDC_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
#define FDC_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define FDC_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#if 0
#define FDC_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * FDC_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1) // could be negative: 255
#else
#define FDC_0_PAUSE_LEN_MIN (1) // simply use 1
#endif
#define FDC_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * FDC_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RCCAR_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RCCAR_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RCCAR_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RCCAR_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RCCAR_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RCCAR_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RCCAR_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define RCCAR_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define RCCAR_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define RCCAR_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define JVC_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * JVC_START_BIT_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define JVC_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * JVC_START_BIT_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define JVC_REPEAT_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * (JVC_FRAME_REPEAT_PAUSE_TIME - IRMP_TIMEOUT_TIME) * MIN_TOLERANCE_40 + 0.5) - 1) // HACK!
#define JVC_REPEAT_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * (JVC_FRAME_REPEAT_PAUSE_TIME - IRMP_TIMEOUT_TIME) * MAX_TOLERANCE_70 + 0.5) - 1) // HACK!
#define JVC_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * JVC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define JVC_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * JVC_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define JVC_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * JVC_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define JVC_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * JVC_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define JVC_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * JVC_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define JVC_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * JVC_0_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
// autodetect JVC repetition frame within 50 msec:
#define JVC_FRAME_REPEAT_PAUSE_LEN_MAX (uint_fast16_t)(F_INTERRUPTS * JVC_FRAME_REPEAT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5)
#define NIKON_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NIKON_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NIKON_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_START_BIT_PAUSE_LEN_MIN ((uint_fast16_t)(F_INTERRUPTS * NIKON_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_START_BIT_PAUSE_LEN_MAX ((uint_fast16_t)(F_INTERRUPTS * NIKON_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_REPEAT_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NIKON_REPEAT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_REPEAT_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NIKON_REPEAT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NIKON_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NIKON_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NIKON_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NIKON_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NIKON_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NIKON_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_FRAME_REPEAT_PAUSE_LEN_MAX (uint_fast16_t)(F_INTERRUPTS * NIKON_FRAME_REPEAT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5)
#define KATHREIN_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define KATHREIN_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define KATHREIN_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define KATHREIN_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define KATHREIN_1_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_1_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define KATHREIN_1_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_1_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define KATHREIN_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define KATHREIN_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define KATHREIN_0_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_0_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define KATHREIN_0_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_0_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define KATHREIN_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define KATHREIN_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define KATHREIN_SYNC_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_SYNC_BIT_PAUSE_LEN_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define KATHREIN_SYNC_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * KATHREIN_SYNC_BIT_PAUSE_LEN_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define NETBOX_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NETBOX_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define NETBOX_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NETBOX_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define NETBOX_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * NETBOX_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define NETBOX_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * NETBOX_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define NETBOX_PULSE_LEN ((uint_fast8_t)(F_INTERRUPTS * NETBOX_PULSE_TIME))
#define NETBOX_PAUSE_LEN ((uint_fast8_t)(F_INTERRUPTS * NETBOX_PAUSE_TIME))
#define NETBOX_PULSE_REST_LEN ((uint_fast8_t)(F_INTERRUPTS * NETBOX_PULSE_TIME / 4))
#define NETBOX_PAUSE_REST_LEN ((uint_fast8_t)(F_INTERRUPTS * NETBOX_PAUSE_TIME / 4))
#define LEGO_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * LEGO_START_BIT_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define LEGO_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * LEGO_START_BIT_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define LEGO_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * LEGO_START_BIT_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define LEGO_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * LEGO_START_BIT_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define LEGO_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * LEGO_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define LEGO_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * LEGO_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define LEGO_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * LEGO_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define LEGO_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * LEGO_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define LEGO_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * LEGO_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define LEGO_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * LEGO_0_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define BOSE_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BOSE_START_BIT_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define BOSE_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BOSE_START_BIT_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define BOSE_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BOSE_START_BIT_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define BOSE_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BOSE_START_BIT_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define BOSE_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BOSE_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define BOSE_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BOSE_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define BOSE_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BOSE_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define BOSE_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BOSE_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define BOSE_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * BOSE_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define BOSE_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * BOSE_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define BOSE_FRAME_REPEAT_PAUSE_LEN_MAX (uint_fast16_t)(F_INTERRUPTS * 100.0e-3 * MAX_TOLERANCE_20 + 0.5)
#define A1TVBOX_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * A1TVBOX_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define A1TVBOX_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * A1TVBOX_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define A1TVBOX_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * A1TVBOX_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define A1TVBOX_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * A1TVBOX_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define A1TVBOX_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * A1TVBOX_BIT_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define A1TVBOX_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * A1TVBOX_BIT_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define A1TVBOX_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * A1TVBOX_BIT_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define A1TVBOX_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * A1TVBOX_BIT_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define MERLIN_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * MERLIN_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define MERLIN_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * MERLIN_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define MERLIN_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * MERLIN_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define MERLIN_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * MERLIN_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define MERLIN_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * MERLIN_BIT_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define MERLIN_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * MERLIN_BIT_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define MERLIN_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * MERLIN_BIT_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define MERLIN_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * MERLIN_BIT_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define ORTEK_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ORTEK_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define ORTEK_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ORTEK_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define ORTEK_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ORTEK_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define ORTEK_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ORTEK_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define ORTEK_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ORTEK_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define ORTEK_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ORTEK_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define ORTEK_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ORTEK_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define ORTEK_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ORTEK_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define TELEFUNKEN_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * TELEFUNKEN_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define TELEFUNKEN_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * TELEFUNKEN_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define TELEFUNKEN_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * (TELEFUNKEN_START_BIT_PAUSE_TIME) * MIN_TOLERANCE_10 + 0.5) - 1)
#define TELEFUNKEN_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * (TELEFUNKEN_START_BIT_PAUSE_TIME) * MAX_TOLERANCE_10 + 0.5) - 1)
#define TELEFUNKEN_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * TELEFUNKEN_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define TELEFUNKEN_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * TELEFUNKEN_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define TELEFUNKEN_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * TELEFUNKEN_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define TELEFUNKEN_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * TELEFUNKEN_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define TELEFUNKEN_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * TELEFUNKEN_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define TELEFUNKEN_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * TELEFUNKEN_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
// autodetect TELEFUNKEN repetition frame within 50 msec:
// #define TELEFUNKEN_FRAME_REPEAT_PAUSE_LEN_MAX (uint_fast16_t)(F_INTERRUPTS * TELEFUNKEN_FRAME_REPEAT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5)
#define ROOMBA_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define ROOMBA_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define ROOMBA_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define ROOMBA_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define ROOMBA_1_PAUSE_LEN_EXACT ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_1_PAUSE_TIME + 0.5))
#define ROOMBA_1_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_1_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define ROOMBA_1_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_1_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define ROOMBA_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define ROOMBA_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define ROOMBA_0_PAUSE_LEN ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_0_PAUSE_TIME))
#define ROOMBA_0_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_0_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define ROOMBA_0_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_0_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define ROOMBA_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define ROOMBA_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ROOMBA_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RCMM32_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCMM32_START_BIT_PULSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define RCMM32_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCMM32_START_BIT_PULSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#define RCMM32_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCMM32_START_BIT_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define RCMM32_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCMM32_START_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#define RCMM32_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCMM32_PULSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define RCMM32_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCMM32_PULSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#define RCMM32_BIT_00_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCMM32_00_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define RCMM32_BIT_00_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCMM32_00_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#define RCMM32_BIT_01_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCMM32_01_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define RCMM32_BIT_01_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCMM32_01_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#define RCMM32_BIT_10_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCMM32_10_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define RCMM32_BIT_10_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCMM32_10_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#define RCMM32_BIT_11_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RCMM32_11_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define RCMM32_BIT_11_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RCMM32_11_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#define PENTAX_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PENTAX_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define PENTAX_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PENTAX_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define PENTAX_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PENTAX_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define PENTAX_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PENTAX_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define PENTAX_1_PAUSE_LEN_EXACT ((uint_fast8_t)(F_INTERRUPTS * PENTAX_1_PAUSE_TIME + 0.5))
#define PENTAX_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PENTAX_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define PENTAX_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PENTAX_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define PENTAX_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PENTAX_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define PENTAX_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PENTAX_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define PENTAX_0_PAUSE_LEN ((uint_fast8_t)(F_INTERRUPTS * PENTAX_0_PAUSE_TIME))
#define PENTAX_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PENTAX_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define PENTAX_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PENTAX_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define PENTAX_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * PENTAX_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define PENTAX_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * PENTAX_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define ACP24_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ACP24_START_BIT_PULSE_TIME * MIN_TOLERANCE_15 + 0.5) - 1)
#define ACP24_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ACP24_START_BIT_PULSE_TIME * MAX_TOLERANCE_15 + 0.5) + 1)
#define ACP24_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ACP24_START_BIT_PAUSE_TIME * MIN_TOLERANCE_15 + 0.5) - 1)
#define ACP24_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ACP24_START_BIT_PAUSE_TIME * MAX_TOLERANCE_15 + 0.5) + 1)
#define ACP24_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ACP24_PULSE_TIME * MIN_TOLERANCE_15 + 0.5) - 1)
#define ACP24_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ACP24_PULSE_TIME * MAX_TOLERANCE_15 + 0.5) + 1)
#define ACP24_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ACP24_1_PAUSE_TIME * MIN_TOLERANCE_15 + 0.5) - 1)
#define ACP24_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ACP24_1_PAUSE_TIME * MAX_TOLERANCE_15 + 0.5) + 1)
#define ACP24_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * ACP24_0_PAUSE_TIME * MIN_TOLERANCE_15 + 0.5) - 1)
#define ACP24_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * ACP24_0_PAUSE_TIME * MAX_TOLERANCE_15 + 0.5) + 1)
#define RADIO1_START_BIT_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RADIO1_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RADIO1_START_BIT_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RADIO1_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RADIO1_START_BIT_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RADIO1_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RADIO1_START_BIT_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RADIO1_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RADIO1_1_PAUSE_LEN_EXACT ((uint_fast8_t)(F_INTERRUPTS * RADIO1_1_PAUSE_TIME + 0.5))
#define RADIO1_1_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RADIO1_1_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RADIO1_1_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RADIO1_1_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RADIO1_1_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RADIO1_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RADIO1_1_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RADIO1_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RADIO1_0_PAUSE_LEN ((uint_fast8_t)(F_INTERRUPTS * RADIO1_0_PAUSE_TIME))
#define RADIO1_0_PULSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RADIO1_0_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RADIO1_0_PULSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RADIO1_0_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RADIO1_0_PAUSE_LEN_MIN ((uint_fast8_t)(F_INTERRUPTS * RADIO1_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RADIO1_0_PAUSE_LEN_MAX ((uint_fast8_t)(F_INTERRUPTS * RADIO1_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define AUTO_FRAME_REPETITION_LEN (uint_fast16_t)(F_INTERRUPTS * AUTO_FRAME_REPETITION_TIME + 0.5) // use uint_fast16_t!
#ifdef ANALYZE
# define ANALYZE_PUTCHAR(a) { if (! silent) { putchar (a); } }
# define ANALYZE_ONLY_NORMAL_PUTCHAR(a) { if (! silent && !verbose) { putchar (a); } }
# define ANALYZE_PRINTF(...) { if (verbose) { printf (__VA_ARGS__); } }
# define ANALYZE_ONLY_NORMAL_PRINTF(...) { if (! silent && !verbose) { printf (__VA_ARGS__); } }
# define ANALYZE_NEWLINE() { if (verbose) { putchar ('\n'); } }
static int silent;
static int time_counter;
static int verbose;
/******************************* not every PIC compiler knows variadic macros :-(
#else
# define ANALYZE_PUTCHAR(a)
# define ANALYZE_ONLY_NORMAL_PUTCHAR(a)
# define ANALYZE_PRINTF(...)
# define ANALYZE_ONLY_NORMAL_PRINTF(...)
# endif
# define ANALYZE_NEWLINE()
*********************************/
#endif
#if IRMP_USE_CALLBACK == 1
static void (*irmp_callback_ptr) (uint_fast8_t);
#endif // IRMP_USE_CALLBACK == 1
#define PARITY_CHECK_OK 1
#define PARITY_CHECK_FAILED 0
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Protocol names
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
#if defined(UNIX_OR_WINDOWS) || IRMP_PROTOCOL_NAMES == 1
static const char proto_unknown[] PROGMEM = "UNKNOWN";
static const char proto_sircs[] PROGMEM = "SIRCS";
static const char proto_nec[] PROGMEM = "NEC";
static const char proto_samsung[] PROGMEM = "SAMSUNG";
static const char proto_matsushita[] PROGMEM = "MATSUSH";
static const char proto_kaseikyo[] PROGMEM = "KASEIKYO";
static const char proto_recs80[] PROGMEM = "RECS80";
static const char proto_rc5[] PROGMEM = "RC5";
static const char proto_denon[] PROGMEM = "DENON";
static const char proto_rc6[] PROGMEM = "RC6";
static const char proto_samsung32[] PROGMEM = "SAMSG32";
static const char proto_apple[] PROGMEM = "APPLE";
static const char proto_recs80ext[] PROGMEM = "RECS80EX";
static const char proto_nubert[] PROGMEM = "NUBERT";
static const char proto_bang_olufsen[] PROGMEM = "BANG OLU";
static const char proto_grundig[] PROGMEM = "GRUNDIG";
static const char proto_nokia[] PROGMEM = "NOKIA";
static const char proto_siemens[] PROGMEM = "SIEMENS";
static const char proto_fdc[] PROGMEM = "FDC";
static const char proto_rccar[] PROGMEM = "RCCAR";
static const char proto_jvc[] PROGMEM = "JVC";
static const char proto_rc6a[] PROGMEM = "RC6A";
static const char proto_nikon[] PROGMEM = "NIKON";
static const char proto_ruwido[] PROGMEM = "RUWIDO";
static const char proto_ir60[] PROGMEM = "IR60";
static const char proto_kathrein[] PROGMEM = "KATHREIN";
static const char proto_netbox[] PROGMEM = "NETBOX";
static const char proto_nec16[] PROGMEM = "NEC16";
static const char proto_nec42[] PROGMEM = "NEC42";
static const char proto_lego[] PROGMEM = "LEGO";
static const char proto_thomson[] PROGMEM = "THOMSON";
static const char proto_bose[] PROGMEM = "BOSE";
static const char proto_a1tvbox[] PROGMEM = "A1TVBOX";
static const char proto_ortek[] PROGMEM = "ORTEK";
static const char proto_telefunken[] PROGMEM = "TELEFUNKEN";
static const char proto_roomba[] PROGMEM = "ROOMBA";
static const char proto_rcmm32[] PROGMEM = "RCMM32";
static const char proto_rcmm24[] PROGMEM = "RCMM24";
static const char proto_rcmm12[] PROGMEM = "RCMM12";
static const char proto_speaker[] PROGMEM = "SPEAKER";
static const char proto_lgair[] PROGMEM = "LGAIR";
static const char proto_samsung48[] PROGMEM = "SAMSG48";
static const char proto_merlin[] PROGMEM = "MERLIN";
static const char proto_pentax[] PROGMEM = "PENTAX";
static const char proto_fan[] PROGMEM = "FAN";
static const char proto_s100[] PROGMEM = "S100";
static const char proto_acp24[] PROGMEM = "ACP24";
static const char proto_technics[] PROGMEM = "TECHNICS";
static const char proto_panasonic[] PROGMEM = "PANASONIC";
static const char proto_radio1[] PROGMEM = "RADIO1";
const char * const
irmp_protocol_names[IRMP_N_PROTOCOLS + 1] PROGMEM =
{
proto_unknown,
proto_sircs,
proto_nec,
proto_samsung,
proto_matsushita,
proto_kaseikyo,
proto_recs80,
proto_rc5,
proto_denon,
proto_rc6,
proto_samsung32,
proto_apple,
proto_recs80ext,
proto_nubert,
proto_bang_olufsen,
proto_grundig,
proto_nokia,
proto_siemens,
proto_fdc,
proto_rccar,
proto_jvc,
proto_rc6a,
proto_nikon,
proto_ruwido,
proto_ir60,
proto_kathrein,
proto_netbox,
proto_nec16,
proto_nec42,
proto_lego,
proto_thomson,
proto_bose,
proto_a1tvbox,
proto_ortek,
proto_telefunken,
proto_roomba,
proto_rcmm32,
proto_rcmm24,
proto_rcmm12,
proto_speaker,
proto_lgair,
proto_samsung48,
proto_merlin,
proto_pentax,
proto_fan,
proto_s100,
proto_acp24,
proto_technics,
proto_panasonic,
proto_radio1
};
#endif
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Logging
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
#if IRMP_LOGGING == 1 // logging via UART
#if defined(ARM_STM32F4XX)
# define STM32_GPIO_CLOCK RCC_AHB1Periph_GPIOA // UART2 on PA2
# define STM32_UART_CLOCK RCC_APB1Periph_USART2
# define STM32_GPIO_PORT GPIOA
# define STM32_GPIO_PIN GPIO_Pin_2
# define STM32_GPIO_SOURCE GPIO_PinSource2
# define STM32_UART_AF GPIO_AF_USART2
# define STM32_UART_COM USART2
# define STM32_UART_BAUD 115200 // 115200 Baud
# include "stm32f4xx_usart.h"
#elif defined(ARM_STM32F10X)
# define STM32_UART_COM USART3 // UART3 on PB10
#elif defined(ARDUINO) // Arduino Serial implementation
# if defined(USB_SERIAL)
# include "usb_serial.h"
# else
# error USB_SERIAL not defined in ARDUINO Environment
# endif
#else
# if IRMP_EXT_LOGGING == 1 // use external logging
# include "../irmp/irmpextlog.h"
# else // normal UART log (IRMP_EXT_LOGGING == 0)
# define BAUD 9600L
# ifndef UNIX_OR_WINDOWS
# include <util/setbaud.h>
# endif
#ifdef UBRR0H
#define UART0_UBRRH UBRR0H
#define UART0_UBRRL UBRR0L
#define UART0_UCSRA UCSR0A
#define UART0_UCSRB UCSR0B
#define UART0_UCSRC UCSR0C
#define UART0_UDRE_BIT_VALUE (1<<UDRE0)
#define UART0_UCSZ1_BIT_VALUE (1<<UCSZ01)
#define UART0_UCSZ0_BIT_VALUE (1<<UCSZ00)
#ifdef URSEL0
#define UART0_URSEL_BIT_VALUE (1<<URSEL0)
#else
#define UART0_URSEL_BIT_VALUE (0)
#endif
#define UART0_TXEN_BIT_VALUE (1<<TXEN0)
#define UART0_UDR UDR0
#define UART0_U2X U2X0
#else
#define UART0_UBRRH UBRRH
#define UART0_UBRRL UBRRL
#define UART0_UCSRA UCSRA
#define UART0_UCSRB UCSRB
#define UART0_UCSRC UCSRC
#define UART0_UDRE_BIT_VALUE (1<<UDRE)
#define UART0_UCSZ1_BIT_VALUE (1<<UCSZ1)
#define UART0_UCSZ0_BIT_VALUE (1<<UCSZ0)
#ifdef URSEL
#define UART0_URSEL_BIT_VALUE (1<<URSEL)
#else
#define UART0_URSEL_BIT_VALUE (0)
#endif
#define UART0_TXEN_BIT_VALUE (1<<TXEN)
#define UART0_UDR UDR
#define UART0_U2X U2X
#endif //UBRR0H
#endif //IRMP_EXT_LOGGING
#endif //ARM_STM32F4XX
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Initialize UART
* @details Initializes UART
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
void
irmp_uart_init (void)
{
#ifndef UNIX_OR_WINDOWS
#if defined(ARM_STM32F4XX)
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
// Clock enable vom TX Pin
RCC_AHB1PeriphClockCmd(STM32_GPIO_CLOCK, ENABLE);
// Clock enable der UART
RCC_APB1PeriphClockCmd(STM32_UART_CLOCK, ENABLE);
// UART Alternative-Funktion mit dem IO-Pin verbinden
GPIO_PinAFConfig(STM32_GPIO_PORT,STM32_GPIO_SOURCE,STM32_UART_AF);
// UART als Alternative-Funktion mit PushPull
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
// TX-Pin
GPIO_InitStructure.GPIO_Pin = STM32_GPIO_PIN;
GPIO_Init(STM32_GPIO_PORT, &GPIO_InitStructure);
// Oversampling
USART_OverSampling8Cmd(STM32_UART_COM, ENABLE);
// init mit Baudrate, 8Databits, 1Stopbit, keine Parit�t, kein RTS+CTS
USART_InitStructure.USART_BaudRate = STM32_UART_BAUD;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Tx;
USART_Init(STM32_UART_COM, &USART_InitStructure);
// UART enable
USART_Cmd(STM32_UART_COM, ENABLE);
#elif defined(ARM_STM32F10X)
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
// Clock enable vom TX Pin
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); // UART3 an PB10
// Clock enable der UART
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
// UART als Alternative-Funktion mit PushPull
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
// TX-Pin
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// Oversampling
USART_OverSampling8Cmd(STM32_UART_COM, ENABLE);
// init mit Baudrate, 8Databits, 1Stopbit, keine Parit�t, kein RTS+CTS
USART_InitStructure.USART_BaudRate = 115200;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Tx;
USART_Init(STM32_UART_COM, &USART_InitStructure);
// UART enable
USART_Cmd(STM32_UART_COM, ENABLE);
#elif defined(ARDUINO)
// we use the Arduino Serial Imlementation
// you have to call Serial.begin(SER_BAUD); in Arduino setup() function
#elif defined (__AVR_XMEGA__)
PMIC.CTRL |= PMIC_HILVLEN_bm;
USARTC1.BAUDCTRLB = 0;
USARTC1.BAUDCTRLA = F_CPU / 153600 - 1;
USARTC1.CTRLA = USART_RXCINTLVL_HI_gc; // High Level (Empfangen)
USARTC1.CTRLB = USART_TXEN_bm | USART_RXEN_bm; //Aktiviert Senden und Empfangen
USARTC1.CTRLC = USART_CHSIZE_8BIT_gc; //Gr��e der Zeichen: 8 Bit
PORTC.DIR |= (1<<7); //TXD als Ausgang setzen
PORTC.DIR &= ~(1<<6);
#else
#if (IRMP_EXT_LOGGING == 0) // use UART
UART0_UBRRH = UBRRH_VALUE; // set baud rate
UART0_UBRRL = UBRRL_VALUE;
#if USE_2X
UART0_UCSRA |= (1<<UART0_U2X);
#else
UART0_UCSRA &= ~(1<<UART0_U2X);
#endif
UART0_UCSRC = UART0_UCSZ1_BIT_VALUE | UART0_UCSZ0_BIT_VALUE | UART0_URSEL_BIT_VALUE;
UART0_UCSRB |= UART0_TXEN_BIT_VALUE; // enable UART TX
#else // other log method
initextlog();
#endif //IRMP_EXT_LOGGING
#endif //ARM_STM32F4XX
#endif // UNIX_OR_WINDOWS
}
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Send character
* @details Sends character
* @param ch character to be transmitted
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
void
irmp_uart_putc (unsigned char ch)
{
#ifndef UNIX_OR_WINDOWS
#if defined(ARM_STM32F4XX) || defined(ARM_STM32F10X)
// warten bis altes Byte gesendet wurde
while (USART_GetFlagStatus(STM32_UART_COM, USART_FLAG_TXE) == RESET)
{
;
}
USART_SendData(STM32_UART_COM, ch);
if (ch == '\n')
{
while (USART_GetFlagStatus(STM32_UART_COM, USART_FLAG_TXE) == RESET);
USART_SendData(STM32_UART_COM, '\r');
}
#elif defined(ARDUINO)
// we use the Arduino Serial Imlementation
usb_serial_putchar(ch);
#else
#if (IRMP_EXT_LOGGING == 0)
# if defined (__AVR_XMEGA__)
while (!(USARTC1.STATUS & USART_DREIF_bm));
USARTC1.DATA = ch;
# else //AVR_MEGA
while (!(UART0_UCSRA & UART0_UDRE_BIT_VALUE))
{
;
}
UART0_UDR = ch;
#endif //__AVR_XMEGA__
#else
sendextlog(ch); // use external log
#endif //IRMP_EXT_LOGGING
#endif //ARM_STM32F4XX
#else
fputc (ch, stderr);
#endif // UNIX_OR_WINDOWS
}
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Log IR signal
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
#define STARTCYCLES 2 // min count of zeros before start of logging
#define ENDBITS 1000 // number of sequenced highbits to detect end
#define DATALEN 700 // log buffer size
static void
irmp_log (uint_fast8_t val)
{
static uint8_t buf[DATALEN]; // logging buffer
static uint_fast16_t buf_idx; // index
static uint_fast8_t startcycles; // current number of start-zeros
static uint_fast16_t cnt; // counts sequenced highbits - to detect end
static uint_fast8_t last_val = 1;
if (! val && (startcycles < STARTCYCLES) && !buf_idx) // prevent that single random zeros init logging
{
startcycles++;
}
else
{
startcycles = 0;
if (! val || buf_idx != 0) // start or continue logging on "0", "1" cannot init logging
{
if (last_val == val)
{
cnt++;
if (val && cnt > ENDBITS) // if high received then look at log-stop condition
{ // if stop condition is true, output on uart
uint_fast8_t i8;
uint_fast16_t i;
uint_fast16_t j;
uint_fast8_t v = '1';
uint_fast16_t d;
for (i8 = 0; i8 < STARTCYCLES; i8++)
{
irmp_uart_putc ('0'); // the ignored starting zeros
}
for (i = 0; i < buf_idx; i++)
{
d = buf[i];
if (d == 0xff)
{
i++;
d = buf[i];
i++;
d |= ((uint_fast16_t) buf[i] << 8);
}
for (j = 0; j < d; j++)
{
irmp_uart_putc (v);
}
v = (v == '1') ? '0' : '1';
}
for (i8 = 0; i8 < 20; i8++)
{
irmp_uart_putc ('1');
}
irmp_uart_putc ('\n');
buf_idx = 0;
last_val = 1;
cnt = 0;
}
}
else if (buf_idx < DATALEN - 3)
{
if (cnt >= 0xff)
{
buf[buf_idx++] = 0xff;
buf[buf_idx++] = (cnt & 0xff);
buf[buf_idx] = (cnt >> 8);
}
else
{
buf[buf_idx] = cnt;
}
buf_idx++;
cnt = 1;
last_val = val;
}
}
}
}
#else
#define irmp_log(val)
#endif //IRMP_LOGGING
typedef struct
{
uint_fast8_t protocol; // ir protocol
uint_fast8_t pulse_1_len_min; // minimum length of pulse with bit value 1
uint_fast8_t pulse_1_len_max; // maximum length of pulse with bit value 1
uint_fast8_t pause_1_len_min; // minimum length of pause with bit value 1
uint_fast8_t pause_1_len_max; // maximum length of pause with bit value 1
uint_fast8_t pulse_0_len_min; // minimum length of pulse with bit value 0
uint_fast8_t pulse_0_len_max; // maximum length of pulse with bit value 0
uint_fast8_t pause_0_len_min; // minimum length of pause with bit value 0
uint_fast8_t pause_0_len_max; // maximum length of pause with bit value 0
uint_fast8_t address_offset; // address offset
uint_fast8_t address_end; // end of address
uint_fast8_t command_offset; // command offset
uint_fast8_t command_end; // end of command
uint_fast8_t complete_len; // complete length of frame
uint_fast8_t stop_bit; // flag: frame has stop bit
uint_fast8_t lsb_first; // flag: LSB first
uint_fast8_t flags; // some flags
} IRMP_PARAMETER;
#if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER sircs_param =
{
IRMP_SIRCS_PROTOCOL, // protocol: ir protocol
SIRCS_1_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
SIRCS_1_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
SIRCS_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
SIRCS_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
SIRCS_0_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
SIRCS_0_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
SIRCS_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
SIRCS_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
SIRCS_ADDRESS_OFFSET, // address_offset: address offset
SIRCS_ADDRESS_OFFSET + SIRCS_ADDRESS_LEN, // address_end: end of address
SIRCS_COMMAND_OFFSET, // command_offset: command offset
SIRCS_COMMAND_OFFSET + SIRCS_COMMAND_LEN, // command_end: end of command
SIRCS_COMPLETE_DATA_LEN, // complete_len: complete length of frame
SIRCS_STOP_BIT, // stop_bit: flag: frame has stop bit
SIRCS_LSB, // lsb_first: flag: LSB first
SIRCS_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_NEC_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER nec_param =
{
IRMP_NEC_PROTOCOL, // protocol: ir protocol
NEC_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
NEC_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
NEC_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
NEC_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
NEC_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
NEC_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
NEC_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
NEC_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
NEC_ADDRESS_OFFSET, // address_offset: address offset
NEC_ADDRESS_OFFSET + NEC_ADDRESS_LEN, // address_end: end of address
NEC_COMMAND_OFFSET, // command_offset: command offset
NEC_COMMAND_OFFSET + NEC_COMMAND_LEN, // command_end: end of command
NEC_COMPLETE_DATA_LEN, // complete_len: complete length of frame
NEC_STOP_BIT, // stop_bit: flag: frame has stop bit
NEC_LSB, // lsb_first: flag: LSB first
NEC_FLAGS // flags: some flags
};
static const PROGMEM IRMP_PARAMETER nec_rep_param =
{
IRMP_NEC_PROTOCOL, // protocol: ir protocol
NEC_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
NEC_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
NEC_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
NEC_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
NEC_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
NEC_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
NEC_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
NEC_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
0, // address_offset: address offset
0, // address_end: end of address
0, // command_offset: command offset
0, // command_end: end of command
0, // complete_len: complete length of frame
NEC_STOP_BIT, // stop_bit: flag: frame has stop bit
NEC_LSB, // lsb_first: flag: LSB first
NEC_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_NEC42_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER nec42_param =
{
IRMP_NEC42_PROTOCOL, // protocol: ir protocol
NEC_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
NEC_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
NEC_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
NEC_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
NEC_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
NEC_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
NEC_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
NEC_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
NEC42_ADDRESS_OFFSET, // address_offset: address offset
NEC42_ADDRESS_OFFSET + NEC42_ADDRESS_LEN, // address_end: end of address
NEC42_COMMAND_OFFSET, // command_offset: command offset
NEC42_COMMAND_OFFSET + NEC42_COMMAND_LEN, // command_end: end of command
NEC42_COMPLETE_DATA_LEN, // complete_len: complete length of frame
NEC_STOP_BIT, // stop_bit: flag: frame has stop bit
NEC_LSB, // lsb_first: flag: LSB first
NEC_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_LGAIR_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER lgair_param =
{
IRMP_LGAIR_PROTOCOL, // protocol: ir protocol
NEC_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
NEC_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
NEC_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
NEC_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
NEC_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
NEC_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
NEC_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
NEC_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
LGAIR_ADDRESS_OFFSET, // address_offset: address offset
LGAIR_ADDRESS_OFFSET + LGAIR_ADDRESS_LEN, // address_end: end of address
LGAIR_COMMAND_OFFSET, // command_offset: command offset
LGAIR_COMMAND_OFFSET + LGAIR_COMMAND_LEN, // command_end: end of command
LGAIR_COMPLETE_DATA_LEN, // complete_len: complete length of frame
NEC_STOP_BIT, // stop_bit: flag: frame has stop bit
NEC_LSB, // lsb_first: flag: LSB first
NEC_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER samsung_param =
{
IRMP_SAMSUNG_PROTOCOL, // protocol: ir protocol
SAMSUNG_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
SAMSUNG_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
SAMSUNG_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
SAMSUNG_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
SAMSUNG_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
SAMSUNG_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
SAMSUNG_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
SAMSUNG_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
SAMSUNG_ADDRESS_OFFSET, // address_offset: address offset
SAMSUNG_ADDRESS_OFFSET + SAMSUNG_ADDRESS_LEN, // address_end: end of address
SAMSUNG_COMMAND_OFFSET, // command_offset: command offset
SAMSUNG_COMMAND_OFFSET + SAMSUNG_COMMAND_LEN, // command_end: end of command
SAMSUNG_COMPLETE_DATA_LEN, // complete_len: complete length of frame
SAMSUNG_STOP_BIT, // stop_bit: flag: frame has stop bit
SAMSUNG_LSB, // lsb_first: flag: LSB first
SAMSUNG_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_TELEFUNKEN_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER telefunken_param =
{
IRMP_TELEFUNKEN_PROTOCOL, // protocol: ir protocol
TELEFUNKEN_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
TELEFUNKEN_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
TELEFUNKEN_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
TELEFUNKEN_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
TELEFUNKEN_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
TELEFUNKEN_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
TELEFUNKEN_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
TELEFUNKEN_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
TELEFUNKEN_ADDRESS_OFFSET, // address_offset: address offset
TELEFUNKEN_ADDRESS_OFFSET + TELEFUNKEN_ADDRESS_LEN, // address_end: end of address
TELEFUNKEN_COMMAND_OFFSET, // command_offset: command offset
TELEFUNKEN_COMMAND_OFFSET + TELEFUNKEN_COMMAND_LEN, // command_end: end of command
TELEFUNKEN_COMPLETE_DATA_LEN, // complete_len: complete length of frame
TELEFUNKEN_STOP_BIT, // stop_bit: flag: frame has stop bit
TELEFUNKEN_LSB, // lsb_first: flag: LSB first
TELEFUNKEN_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER matsushita_param =
{
IRMP_MATSUSHITA_PROTOCOL, // protocol: ir protocol
MATSUSHITA_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
MATSUSHITA_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
MATSUSHITA_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
MATSUSHITA_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
MATSUSHITA_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
MATSUSHITA_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
MATSUSHITA_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
MATSUSHITA_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
MATSUSHITA_ADDRESS_OFFSET, // address_offset: address offset
MATSUSHITA_ADDRESS_OFFSET + MATSUSHITA_ADDRESS_LEN, // address_end: end of address
MATSUSHITA_COMMAND_OFFSET, // command_offset: command offset
MATSUSHITA_COMMAND_OFFSET + MATSUSHITA_COMMAND_LEN, // command_end: end of command
MATSUSHITA_COMPLETE_DATA_LEN, // complete_len: complete length of frame
MATSUSHITA_STOP_BIT, // stop_bit: flag: frame has stop bit
MATSUSHITA_LSB, // lsb_first: flag: LSB first
MATSUSHITA_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER kaseikyo_param =
{
IRMP_KASEIKYO_PROTOCOL, // protocol: ir protocol
KASEIKYO_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
KASEIKYO_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
KASEIKYO_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
KASEIKYO_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
KASEIKYO_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
KASEIKYO_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
KASEIKYO_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
KASEIKYO_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
KASEIKYO_ADDRESS_OFFSET, // address_offset: address offset
KASEIKYO_ADDRESS_OFFSET + KASEIKYO_ADDRESS_LEN, // address_end: end of address
KASEIKYO_COMMAND_OFFSET, // command_offset: command offset
KASEIKYO_COMMAND_OFFSET + KASEIKYO_COMMAND_LEN, // command_end: end of command
KASEIKYO_COMPLETE_DATA_LEN, // complete_len: complete length of frame
KASEIKYO_STOP_BIT, // stop_bit: flag: frame has stop bit
KASEIKYO_LSB, // lsb_first: flag: LSB first
KASEIKYO_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_PANASONIC_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER panasonic_param =
{
IRMP_PANASONIC_PROTOCOL, // protocol: ir protocol
PANASONIC_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
PANASONIC_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
PANASONIC_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
PANASONIC_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
PANASONIC_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
PANASONIC_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
PANASONIC_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
PANASONIC_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
PANASONIC_ADDRESS_OFFSET, // address_offset: address offset
PANASONIC_ADDRESS_OFFSET + PANASONIC_ADDRESS_LEN, // address_end: end of address
PANASONIC_COMMAND_OFFSET, // command_offset: command offset
PANASONIC_COMMAND_OFFSET + PANASONIC_COMMAND_LEN, // command_end: end of command
PANASONIC_COMPLETE_DATA_LEN, // complete_len: complete length of frame
PANASONIC_STOP_BIT, // stop_bit: flag: frame has stop bit
PANASONIC_LSB, // lsb_first: flag: LSB first
PANASONIC_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_RECS80_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER recs80_param =
{
IRMP_RECS80_PROTOCOL, // protocol: ir protocol
RECS80_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
RECS80_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
RECS80_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
RECS80_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
RECS80_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
RECS80_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
RECS80_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
RECS80_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
RECS80_ADDRESS_OFFSET, // address_offset: address offset
RECS80_ADDRESS_OFFSET + RECS80_ADDRESS_LEN, // address_end: end of address
RECS80_COMMAND_OFFSET, // command_offset: command offset
RECS80_COMMAND_OFFSET + RECS80_COMMAND_LEN, // command_end: end of command
RECS80_COMPLETE_DATA_LEN, // complete_len: complete length of frame
RECS80_STOP_BIT, // stop_bit: flag: frame has stop bit
RECS80_LSB, // lsb_first: flag: LSB first
RECS80_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_RC5_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER rc5_param =
{
IRMP_RC5_PROTOCOL, // protocol: ir protocol
RC5_BIT_LEN_MIN, // pulse_1_len_min: here: minimum length of short pulse
RC5_BIT_LEN_MAX, // pulse_1_len_max: here: maximum length of short pulse
RC5_BIT_LEN_MIN, // pause_1_len_min: here: minimum length of short pause
RC5_BIT_LEN_MAX, // pause_1_len_max: here: maximum length of short pause
0, // pulse_0_len_min: here: not used
0, // pulse_0_len_max: here: not used
0, // pause_0_len_min: here: not used
0, // pause_0_len_max: here: not used
RC5_ADDRESS_OFFSET, // address_offset: address offset
RC5_ADDRESS_OFFSET + RC5_ADDRESS_LEN, // address_end: end of address
RC5_COMMAND_OFFSET, // command_offset: command offset
RC5_COMMAND_OFFSET + RC5_COMMAND_LEN, // command_end: end of command
RC5_COMPLETE_DATA_LEN, // complete_len: complete length of frame
RC5_STOP_BIT, // stop_bit: flag: frame has stop bit
RC5_LSB, // lsb_first: flag: LSB first
RC5_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_S100_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER s100_param =
{
IRMP_S100_PROTOCOL, // protocol: ir protocol
S100_BIT_LEN_MIN, // pulse_1_len_min: here: minimum length of short pulse
S100_BIT_LEN_MAX, // pulse_1_len_max: here: maximum length of short pulse
S100_BIT_LEN_MIN, // pause_1_len_min: here: minimum length of short pause
S100_BIT_LEN_MAX, // pause_1_len_max: here: maximum length of short pause
0, // pulse_0_len_min: here: not used
0, // pulse_0_len_max: here: not used
0, // pause_0_len_min: here: not used
0, // pause_0_len_max: here: not used
S100_ADDRESS_OFFSET, // address_offset: address offset
S100_ADDRESS_OFFSET + S100_ADDRESS_LEN, // address_end: end of address
S100_COMMAND_OFFSET, // command_offset: command offset
S100_COMMAND_OFFSET + S100_COMMAND_LEN, // command_end: end of command
S100_COMPLETE_DATA_LEN, // complete_len: complete length of frame
S100_STOP_BIT, // stop_bit: flag: frame has stop bit
S100_LSB, // lsb_first: flag: LSB first
S100_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_DENON_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER denon_param =
{
IRMP_DENON_PROTOCOL, // protocol: ir protocol
DENON_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
DENON_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
DENON_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
DENON_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
DENON_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
DENON_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
DENON_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
DENON_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
DENON_ADDRESS_OFFSET, // address_offset: address offset
DENON_ADDRESS_OFFSET + DENON_ADDRESS_LEN, // address_end: end of address
DENON_COMMAND_OFFSET, // command_offset: command offset
DENON_COMMAND_OFFSET + DENON_COMMAND_LEN, // command_end: end of command
DENON_COMPLETE_DATA_LEN, // complete_len: complete length of frame
DENON_STOP_BIT, // stop_bit: flag: frame has stop bit
DENON_LSB, // lsb_first: flag: LSB first
DENON_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_RC6_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER rc6_param =
{
IRMP_RC6_PROTOCOL, // protocol: ir protocol
RC6_BIT_PULSE_LEN_MIN, // pulse_1_len_min: here: minimum length of short pulse
RC6_BIT_PULSE_LEN_MAX, // pulse_1_len_max: here: maximum length of short pulse
RC6_BIT_PAUSE_LEN_MIN, // pause_1_len_min: here: minimum length of short pause
RC6_BIT_PAUSE_LEN_MAX, // pause_1_len_max: here: maximum length of short pause
0, // pulse_0_len_min: here: not used
0, // pulse_0_len_max: here: not used
0, // pause_0_len_min: here: not used
0, // pause_0_len_max: here: not used
RC6_ADDRESS_OFFSET, // address_offset: address offset
RC6_ADDRESS_OFFSET + RC6_ADDRESS_LEN, // address_end: end of address
RC6_COMMAND_OFFSET, // command_offset: command offset
RC6_COMMAND_OFFSET + RC6_COMMAND_LEN, // command_end: end of command
RC6_COMPLETE_DATA_LEN_SHORT, // complete_len: complete length of frame
RC6_STOP_BIT, // stop_bit: flag: frame has stop bit
RC6_LSB, // lsb_first: flag: LSB first
RC6_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER recs80ext_param =
{
IRMP_RECS80EXT_PROTOCOL, // protocol: ir protocol
RECS80EXT_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
RECS80EXT_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
RECS80EXT_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
RECS80EXT_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
RECS80EXT_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
RECS80EXT_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
RECS80EXT_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
RECS80EXT_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
RECS80EXT_ADDRESS_OFFSET, // address_offset: address offset
RECS80EXT_ADDRESS_OFFSET + RECS80EXT_ADDRESS_LEN, // address_end: end of address
RECS80EXT_COMMAND_OFFSET, // command_offset: command offset
RECS80EXT_COMMAND_OFFSET + RECS80EXT_COMMAND_LEN, // command_end: end of command
RECS80EXT_COMPLETE_DATA_LEN, // complete_len: complete length of frame
RECS80EXT_STOP_BIT, // stop_bit: flag: frame has stop bit
RECS80EXT_LSB, // lsb_first: flag: LSB first
RECS80EXT_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER nubert_param =
{
IRMP_NUBERT_PROTOCOL, // protocol: ir protocol
NUBERT_1_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
NUBERT_1_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
NUBERT_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
NUBERT_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
NUBERT_0_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
NUBERT_0_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
NUBERT_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
NUBERT_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
NUBERT_ADDRESS_OFFSET, // address_offset: address offset
NUBERT_ADDRESS_OFFSET + NUBERT_ADDRESS_LEN, // address_end: end of address
NUBERT_COMMAND_OFFSET, // command_offset: command offset
NUBERT_COMMAND_OFFSET + NUBERT_COMMAND_LEN, // command_end: end of command
NUBERT_COMPLETE_DATA_LEN, // complete_len: complete length of frame
NUBERT_STOP_BIT, // stop_bit: flag: frame has stop bit
NUBERT_LSB, // lsb_first: flag: LSB first
NUBERT_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_FAN_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER fan_param =
{
IRMP_FAN_PROTOCOL, // protocol: ir protocol
FAN_1_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
FAN_1_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
FAN_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
FAN_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
FAN_0_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
FAN_0_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
FAN_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
FAN_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
FAN_ADDRESS_OFFSET, // address_offset: address offset
FAN_ADDRESS_OFFSET + FAN_ADDRESS_LEN, // address_end: end of address
FAN_COMMAND_OFFSET, // command_offset: command offset
FAN_COMMAND_OFFSET + FAN_COMMAND_LEN, // command_end: end of command
FAN_COMPLETE_DATA_LEN, // complete_len: complete length of frame
FAN_STOP_BIT, // stop_bit: flag: frame has NO stop bit
FAN_LSB, // lsb_first: flag: LSB first
FAN_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_SPEAKER_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER speaker_param =
{
IRMP_SPEAKER_PROTOCOL, // protocol: ir protocol
SPEAKER_1_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
SPEAKER_1_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
SPEAKER_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
SPEAKER_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
SPEAKER_0_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
SPEAKER_0_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
SPEAKER_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
SPEAKER_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
SPEAKER_ADDRESS_OFFSET, // address_offset: address offset
SPEAKER_ADDRESS_OFFSET + SPEAKER_ADDRESS_LEN, // address_end: end of address
SPEAKER_COMMAND_OFFSET, // command_offset: command offset
SPEAKER_COMMAND_OFFSET + SPEAKER_COMMAND_LEN, // command_end: end of command
SPEAKER_COMPLETE_DATA_LEN, // complete_len: complete length of frame
SPEAKER_STOP_BIT, // stop_bit: flag: frame has stop bit
SPEAKER_LSB, // lsb_first: flag: LSB first
SPEAKER_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER bang_olufsen_param =
{
IRMP_BANG_OLUFSEN_PROTOCOL, // protocol: ir protocol
BANG_OLUFSEN_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
BANG_OLUFSEN_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
BANG_OLUFSEN_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
BANG_OLUFSEN_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
BANG_OLUFSEN_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
BANG_OLUFSEN_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
BANG_OLUFSEN_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
BANG_OLUFSEN_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
BANG_OLUFSEN_ADDRESS_OFFSET, // address_offset: address offset
BANG_OLUFSEN_ADDRESS_OFFSET + BANG_OLUFSEN_ADDRESS_LEN, // address_end: end of address
BANG_OLUFSEN_COMMAND_OFFSET, // command_offset: command offset
BANG_OLUFSEN_COMMAND_OFFSET + BANG_OLUFSEN_COMMAND_LEN, // command_end: end of command
BANG_OLUFSEN_COMPLETE_DATA_LEN, // complete_len: complete length of frame
BANG_OLUFSEN_STOP_BIT, // stop_bit: flag: frame has stop bit
BANG_OLUFSEN_LSB, // lsb_first: flag: LSB first
BANG_OLUFSEN_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_GRUNDIG_NOKIA_IR60_PROTOCOL == 1
static uint_fast8_t first_bit;
static const PROGMEM IRMP_PARAMETER grundig_param =
{
IRMP_GRUNDIG_PROTOCOL, // protocol: ir protocol
GRUNDIG_NOKIA_IR60_BIT_LEN_MIN, // pulse_1_len_min: here: minimum length of short pulse
GRUNDIG_NOKIA_IR60_BIT_LEN_MAX, // pulse_1_len_max: here: maximum length of short pulse
GRUNDIG_NOKIA_IR60_BIT_LEN_MIN, // pause_1_len_min: here: minimum length of short pause
GRUNDIG_NOKIA_IR60_BIT_LEN_MAX, // pause_1_len_max: here: maximum length of short pause
0, // pulse_0_len_min: here: not used
0, // pulse_0_len_max: here: not used
0, // pause_0_len_min: here: not used
0, // pause_0_len_max: here: not used
GRUNDIG_ADDRESS_OFFSET, // address_offset: address offset
GRUNDIG_ADDRESS_OFFSET + GRUNDIG_ADDRESS_LEN, // address_end: end of address
GRUNDIG_COMMAND_OFFSET, // command_offset: command offset
GRUNDIG_COMMAND_OFFSET + GRUNDIG_COMMAND_LEN + 1, // command_end: end of command (USE 1 bit MORE to STORE NOKIA DATA!)
NOKIA_COMPLETE_DATA_LEN, // complete_len: complete length of frame, here: NOKIA instead of GRUNDIG!
GRUNDIG_NOKIA_IR60_STOP_BIT, // stop_bit: flag: frame has stop bit
GRUNDIG_NOKIA_IR60_LSB, // lsb_first: flag: LSB first
GRUNDIG_NOKIA_IR60_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_SIEMENS_OR_RUWIDO_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER ruwido_param =
{
IRMP_RUWIDO_PROTOCOL, // protocol: ir protocol
SIEMENS_OR_RUWIDO_BIT_PULSE_LEN_MIN, // pulse_1_len_min: here: minimum length of short pulse
SIEMENS_OR_RUWIDO_BIT_PULSE_LEN_MAX, // pulse_1_len_max: here: maximum length of short pulse
SIEMENS_OR_RUWIDO_BIT_PAUSE_LEN_MIN, // pause_1_len_min: here: minimum length of short pause
SIEMENS_OR_RUWIDO_BIT_PAUSE_LEN_MAX, // pause_1_len_max: here: maximum length of short pause
0, // pulse_0_len_min: here: not used
0, // pulse_0_len_max: here: not used
0, // pause_0_len_min: here: not used
0, // pause_0_len_max: here: not used
RUWIDO_ADDRESS_OFFSET, // address_offset: address offset
RUWIDO_ADDRESS_OFFSET + RUWIDO_ADDRESS_LEN, // address_end: end of address
RUWIDO_COMMAND_OFFSET, // command_offset: command offset
RUWIDO_COMMAND_OFFSET + RUWIDO_COMMAND_LEN, // command_end: end of command
SIEMENS_COMPLETE_DATA_LEN, // complete_len: complete length of frame, here: SIEMENS instead of RUWIDO!
SIEMENS_OR_RUWIDO_STOP_BIT, // stop_bit: flag: frame has stop bit
SIEMENS_OR_RUWIDO_LSB, // lsb_first: flag: LSB first
SIEMENS_OR_RUWIDO_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_FDC_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER fdc_param =
{
IRMP_FDC_PROTOCOL, // protocol: ir protocol
FDC_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
FDC_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
FDC_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
FDC_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
FDC_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
FDC_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
FDC_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
FDC_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
FDC_ADDRESS_OFFSET, // address_offset: address offset
FDC_ADDRESS_OFFSET + FDC_ADDRESS_LEN, // address_end: end of address
FDC_COMMAND_OFFSET, // command_offset: command offset
FDC_COMMAND_OFFSET + FDC_COMMAND_LEN, // command_end: end of command
FDC_COMPLETE_DATA_LEN, // complete_len: complete length of frame
FDC_STOP_BIT, // stop_bit: flag: frame has stop bit
FDC_LSB, // lsb_first: flag: LSB first
FDC_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER rccar_param =
{
IRMP_RCCAR_PROTOCOL, // protocol: ir protocol
RCCAR_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
RCCAR_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
RCCAR_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
RCCAR_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
RCCAR_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
RCCAR_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
RCCAR_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
RCCAR_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
RCCAR_ADDRESS_OFFSET, // address_offset: address offset
RCCAR_ADDRESS_OFFSET + RCCAR_ADDRESS_LEN, // address_end: end of address
RCCAR_COMMAND_OFFSET, // command_offset: command offset
RCCAR_COMMAND_OFFSET + RCCAR_COMMAND_LEN, // command_end: end of command
RCCAR_COMPLETE_DATA_LEN, // complete_len: complete length of frame
RCCAR_STOP_BIT, // stop_bit: flag: frame has stop bit
RCCAR_LSB, // lsb_first: flag: LSB first
RCCAR_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_NIKON_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER nikon_param =
{
IRMP_NIKON_PROTOCOL, // protocol: ir protocol
NIKON_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
NIKON_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
NIKON_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
NIKON_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
NIKON_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
NIKON_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
NIKON_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
NIKON_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
NIKON_ADDRESS_OFFSET, // address_offset: address offset
NIKON_ADDRESS_OFFSET + NIKON_ADDRESS_LEN, // address_end: end of address
NIKON_COMMAND_OFFSET, // command_offset: command offset
NIKON_COMMAND_OFFSET + NIKON_COMMAND_LEN, // command_end: end of command
NIKON_COMPLETE_DATA_LEN, // complete_len: complete length of frame
NIKON_STOP_BIT, // stop_bit: flag: frame has stop bit
NIKON_LSB, // lsb_first: flag: LSB first
NIKON_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_KATHREIN_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER kathrein_param =
{
IRMP_KATHREIN_PROTOCOL, // protocol: ir protocol
KATHREIN_1_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
KATHREIN_1_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
KATHREIN_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
KATHREIN_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
KATHREIN_0_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
KATHREIN_0_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
KATHREIN_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
KATHREIN_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
KATHREIN_ADDRESS_OFFSET, // address_offset: address offset
KATHREIN_ADDRESS_OFFSET + KATHREIN_ADDRESS_LEN, // address_end: end of address
KATHREIN_COMMAND_OFFSET, // command_offset: command offset
KATHREIN_COMMAND_OFFSET + KATHREIN_COMMAND_LEN, // command_end: end of command
KATHREIN_COMPLETE_DATA_LEN, // complete_len: complete length of frame
KATHREIN_STOP_BIT, // stop_bit: flag: frame has stop bit
KATHREIN_LSB, // lsb_first: flag: LSB first
KATHREIN_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_NETBOX_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER netbox_param =
{
IRMP_NETBOX_PROTOCOL, // protocol: ir protocol
NETBOX_PULSE_LEN, // pulse_1_len_min: minimum length of pulse with bit value 1, here: exact value
NETBOX_PULSE_REST_LEN, // pulse_1_len_max: maximum length of pulse with bit value 1, here: rest value
NETBOX_PAUSE_LEN, // pause_1_len_min: minimum length of pause with bit value 1, here: exact value
NETBOX_PAUSE_REST_LEN, // pause_1_len_max: maximum length of pause with bit value 1, here: rest value
NETBOX_PULSE_LEN, // pulse_0_len_min: minimum length of pulse with bit value 0, here: exact value
NETBOX_PULSE_REST_LEN, // pulse_0_len_max: maximum length of pulse with bit value 0, here: rest value
NETBOX_PAUSE_LEN, // pause_0_len_min: minimum length of pause with bit value 0, here: exact value
NETBOX_PAUSE_REST_LEN, // pause_0_len_max: maximum length of pause with bit value 0, here: rest value
NETBOX_ADDRESS_OFFSET, // address_offset: address offset
NETBOX_ADDRESS_OFFSET + NETBOX_ADDRESS_LEN, // address_end: end of address
NETBOX_COMMAND_OFFSET, // command_offset: command offset
NETBOX_COMMAND_OFFSET + NETBOX_COMMAND_LEN, // command_end: end of command
NETBOX_COMPLETE_DATA_LEN, // complete_len: complete length of frame
NETBOX_STOP_BIT, // stop_bit: flag: frame has stop bit
NETBOX_LSB, // lsb_first: flag: LSB first
NETBOX_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_LEGO_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER lego_param =
{
IRMP_LEGO_PROTOCOL, // protocol: ir protocol
LEGO_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
LEGO_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
LEGO_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
LEGO_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
LEGO_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
LEGO_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
LEGO_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
LEGO_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
LEGO_ADDRESS_OFFSET, // address_offset: address offset
LEGO_ADDRESS_OFFSET + LEGO_ADDRESS_LEN, // address_end: end of address
LEGO_COMMAND_OFFSET, // command_offset: command offset
LEGO_COMMAND_OFFSET + LEGO_COMMAND_LEN, // command_end: end of command
LEGO_COMPLETE_DATA_LEN, // complete_len: complete length of frame
LEGO_STOP_BIT, // stop_bit: flag: frame has stop bit
LEGO_LSB, // lsb_first: flag: LSB first
LEGO_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_THOMSON_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER thomson_param =
{
IRMP_THOMSON_PROTOCOL, // protocol: ir protocol
THOMSON_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
THOMSON_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
THOMSON_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
THOMSON_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
THOMSON_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
THOMSON_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
THOMSON_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
THOMSON_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
THOMSON_ADDRESS_OFFSET, // address_offset: address offset
THOMSON_ADDRESS_OFFSET + THOMSON_ADDRESS_LEN, // address_end: end of address
THOMSON_COMMAND_OFFSET, // command_offset: command offset
THOMSON_COMMAND_OFFSET + THOMSON_COMMAND_LEN, // command_end: end of command
THOMSON_COMPLETE_DATA_LEN, // complete_len: complete length of frame
THOMSON_STOP_BIT, // stop_bit: flag: frame has stop bit
THOMSON_LSB, // lsb_first: flag: LSB first
THOMSON_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_BOSE_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER bose_param =
{
IRMP_BOSE_PROTOCOL, // protocol: ir protocol
BOSE_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
BOSE_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
BOSE_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
BOSE_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
BOSE_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
BOSE_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
BOSE_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
BOSE_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
BOSE_ADDRESS_OFFSET, // address_offset: address offset
BOSE_ADDRESS_OFFSET + BOSE_ADDRESS_LEN, // address_end: end of address
BOSE_COMMAND_OFFSET, // command_offset: command offset
BOSE_COMMAND_OFFSET + BOSE_COMMAND_LEN, // command_end: end of command
BOSE_COMPLETE_DATA_LEN, // complete_len: complete length of frame
BOSE_STOP_BIT, // stop_bit: flag: frame has stop bit
BOSE_LSB, // lsb_first: flag: LSB first
BOSE_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_A1TVBOX_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER a1tvbox_param =
{
IRMP_A1TVBOX_PROTOCOL, // protocol: ir protocol
A1TVBOX_BIT_PULSE_LEN_MIN, // pulse_1_len_min: here: minimum length of short pulse
A1TVBOX_BIT_PULSE_LEN_MAX, // pulse_1_len_max: here: maximum length of short pulse
A1TVBOX_BIT_PAUSE_LEN_MIN, // pause_1_len_min: here: minimum length of short pause
A1TVBOX_BIT_PAUSE_LEN_MAX, // pause_1_len_max: here: maximum length of short pause
0, // pulse_0_len_min: here: not used
0, // pulse_0_len_max: here: not used
0, // pause_0_len_min: here: not used
0, // pause_0_len_max: here: not used
A1TVBOX_ADDRESS_OFFSET, // address_offset: address offset
A1TVBOX_ADDRESS_OFFSET + A1TVBOX_ADDRESS_LEN, // address_end: end of address
A1TVBOX_COMMAND_OFFSET, // command_offset: command offset
A1TVBOX_COMMAND_OFFSET + A1TVBOX_COMMAND_LEN, // command_end: end of command
A1TVBOX_COMPLETE_DATA_LEN, // complete_len: complete length of frame
A1TVBOX_STOP_BIT, // stop_bit: flag: frame has stop bit
A1TVBOX_LSB, // lsb_first: flag: LSB first
A1TVBOX_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_MERLIN_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER merlin_param =
{
IRMP_MERLIN_PROTOCOL, // protocol: ir protocol
MERLIN_BIT_PULSE_LEN_MIN, // pulse_1_len_min: here: minimum length of short pulse
MERLIN_BIT_PULSE_LEN_MAX, // pulse_1_len_max: here: maximum length of short pulse
MERLIN_BIT_PAUSE_LEN_MIN, // pause_1_len_min: here: minimum length of short pause
MERLIN_BIT_PAUSE_LEN_MAX, // pause_1_len_max: here: maximum length of short pause
0, // pulse_0_len_min: here: not used
0, // pulse_0_len_max: here: not used
0, // pause_0_len_min: here: not used
0, // pause_0_len_max: here: not used
MERLIN_ADDRESS_OFFSET, // address_offset: address offset
MERLIN_ADDRESS_OFFSET + MERLIN_ADDRESS_LEN, // address_end: end of address
MERLIN_COMMAND_OFFSET, // command_offset: command offset
MERLIN_COMMAND_OFFSET + MERLIN_COMMAND_LEN, // command_end: end of command
MERLIN_COMPLETE_DATA_LEN, // complete_len: complete length of frame
MERLIN_STOP_BIT, // stop_bit: flag: frame has stop bit
MERLIN_LSB, // lsb_first: flag: LSB first
MERLIN_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_ORTEK_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER ortek_param =
{
IRMP_ORTEK_PROTOCOL, // protocol: ir protocol
ORTEK_BIT_PULSE_LEN_MIN, // pulse_1_len_min: here: minimum length of short pulse
ORTEK_BIT_PULSE_LEN_MAX, // pulse_1_len_max: here: maximum length of short pulse
ORTEK_BIT_PAUSE_LEN_MIN, // pause_1_len_min: here: minimum length of short pause
ORTEK_BIT_PAUSE_LEN_MAX, // pause_1_len_max: here: maximum length of short pause
0, // pulse_0_len_min: here: not used
0, // pulse_0_len_max: here: not used
0, // pause_0_len_min: here: not used
0, // pause_0_len_max: here: not used
ORTEK_ADDRESS_OFFSET, // address_offset: address offset
ORTEK_ADDRESS_OFFSET + ORTEK_ADDRESS_LEN, // address_end: end of address
ORTEK_COMMAND_OFFSET, // command_offset: command offset
ORTEK_COMMAND_OFFSET + ORTEK_COMMAND_LEN, // command_end: end of command
ORTEK_COMPLETE_DATA_LEN, // complete_len: complete length of frame
ORTEK_STOP_BIT, // stop_bit: flag: frame has stop bit
ORTEK_LSB, // lsb_first: flag: LSB first
ORTEK_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_ROOMBA_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER roomba_param =
{
IRMP_ROOMBA_PROTOCOL, // protocol: ir protocol
ROOMBA_1_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
ROOMBA_1_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
ROOMBA_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
ROOMBA_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
ROOMBA_0_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
ROOMBA_0_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
ROOMBA_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
ROOMBA_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
ROOMBA_ADDRESS_OFFSET, // address_offset: address offset
ROOMBA_ADDRESS_OFFSET + ROOMBA_ADDRESS_LEN, // address_end: end of address
ROOMBA_COMMAND_OFFSET, // command_offset: command offset
ROOMBA_COMMAND_OFFSET + ROOMBA_COMMAND_LEN, // command_end: end of command
ROOMBA_COMPLETE_DATA_LEN, // complete_len: complete length of frame
ROOMBA_STOP_BIT, // stop_bit: flag: frame has stop bit
ROOMBA_LSB, // lsb_first: flag: LSB first
ROOMBA_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_RCMM_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER rcmm_param =
{
IRMP_RCMM32_PROTOCOL, // protocol: ir protocol
RCMM32_BIT_PULSE_LEN_MIN, // pulse_1_len_min: here: minimum length of short pulse
RCMM32_BIT_PULSE_LEN_MAX, // pulse_1_len_max: here: maximum length of short pulse
0, // pause_1_len_min: here: minimum length of short pause
0, // pause_1_len_max: here: maximum length of short pause
RCMM32_BIT_PULSE_LEN_MIN, // pulse_0_len_min: here: not used
RCMM32_BIT_PULSE_LEN_MAX, // pulse_0_len_max: here: not used
0, // pause_0_len_min: here: not used
0, // pause_0_len_max: here: not used
RCMM32_ADDRESS_OFFSET, // address_offset: address offset
RCMM32_ADDRESS_OFFSET + RCMM32_ADDRESS_LEN, // address_end: end of address
RCMM32_COMMAND_OFFSET, // command_offset: command offset
RCMM32_COMMAND_OFFSET + RCMM32_COMMAND_LEN, // command_end: end of command
RCMM32_COMPLETE_DATA_LEN, // complete_len: complete length of frame
RCMM32_STOP_BIT, // stop_bit: flag: frame has stop bit
RCMM32_LSB, // lsb_first: flag: LSB first
RCMM32_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_PENTAX_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER pentax_param =
{
IRMP_PENTAX_PROTOCOL, // protocol: ir protocol
PENTAX_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
PENTAX_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
PENTAX_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
PENTAX_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
PENTAX_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
PENTAX_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
PENTAX_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
PENTAX_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
PENTAX_ADDRESS_OFFSET, // address_offset: address offset
PENTAX_ADDRESS_OFFSET + PENTAX_ADDRESS_LEN, // address_end: end of address
PENTAX_COMMAND_OFFSET, // command_offset: command offset
PENTAX_COMMAND_OFFSET + PENTAX_COMMAND_LEN, // command_end: end of command
PENTAX_COMPLETE_DATA_LEN, // complete_len: complete length of frame
PENTAX_STOP_BIT, // stop_bit: flag: frame has stop bit
PENTAX_LSB, // lsb_first: flag: LSB first
PENTAX_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_ACP24_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER acp24_param =
{
IRMP_ACP24_PROTOCOL, // protocol: ir protocol
ACP24_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
ACP24_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
ACP24_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
ACP24_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
ACP24_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
ACP24_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
ACP24_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
ACP24_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
ACP24_ADDRESS_OFFSET, // address_offset: address offset
ACP24_ADDRESS_OFFSET + ACP24_ADDRESS_LEN, // address_end: end of address
ACP24_COMMAND_OFFSET, // command_offset: command offset
ACP24_COMMAND_OFFSET + ACP24_COMMAND_LEN, // command_end: end of command
ACP24_COMPLETE_DATA_LEN, // complete_len: complete length of frame
ACP24_STOP_BIT, // stop_bit: flag: frame has stop bit
ACP24_LSB, // lsb_first: flag: LSB first
ACP24_FLAGS // flags: some flags
};
#endif
#if IRMP_SUPPORT_RADIO1_PROTOCOL == 1
static const PROGMEM IRMP_PARAMETER radio1_param =
{
IRMP_RADIO1_PROTOCOL, // protocol: ir protocol
RADIO1_1_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1
RADIO1_1_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1
RADIO1_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1
RADIO1_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1
RADIO1_0_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0
RADIO1_0_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0
RADIO1_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0
RADIO1_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0
RADIO1_ADDRESS_OFFSET, // address_offset: address offset
RADIO1_ADDRESS_OFFSET + RADIO1_ADDRESS_LEN, // address_end: end of address
RADIO1_COMMAND_OFFSET, // command_offset: command offset
RADIO1_COMMAND_OFFSET + RADIO1_COMMAND_LEN, // command_end: end of command
RADIO1_COMPLETE_DATA_LEN, // complete_len: complete length of frame
RADIO1_STOP_BIT, // stop_bit: flag: frame has stop bit
RADIO1_LSB, // lsb_first: flag: LSB first
RADIO1_FLAGS // flags: some flags
};
#endif
static uint_fast8_t irmp_bit; // current bit position
static IRMP_PARAMETER irmp_param;
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
static IRMP_PARAMETER irmp_param2;
#endif
static volatile uint_fast8_t irmp_ir_detected = FALSE;
static volatile uint_fast8_t irmp_protocol;
static volatile uint_fast16_t irmp_address;
static volatile uint_fast16_t irmp_command;
static volatile uint_fast16_t irmp_id; // only used for SAMSUNG protocol
static volatile uint_fast8_t irmp_flags;
// static volatile uint_fast8_t irmp_busy_flag;
#if defined(__MBED__)
// DigitalIn inputPin(IRMP_PIN, PullUp); // this requires mbed.h and source to be compiled as cpp
gpio_t gpioIRin; // use low level c function instead
#endif
#ifdef ANALYZE
#define input(x) (x)
static uint_fast8_t IRMP_PIN;
static uint_fast8_t radio;
#endif
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Initialize IRMP decoder
* @details Configures IRMP input pin
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
#ifndef ANALYZE
void
irmp_init (void)
{
#if defined(PIC_CCS) || defined(PIC_C18) // PIC: do nothing
#elif defined (ARM_STM32) // STM32
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIOx clock enable */
# if defined (ARM_STM32L1XX)
RCC_AHBPeriphClockCmd(IRMP_PORT_RCC, ENABLE);
# elif defined (ARM_STM32F10X)
RCC_APB2PeriphClockCmd(IRMP_PORT_RCC, ENABLE);
# elif defined (ARM_STM32F4XX)
RCC_AHB1PeriphClockCmd(IRMP_PORT_RCC, ENABLE);
# endif
/* GPIO Configuration */
GPIO_InitStructure.GPIO_Pin = IRMP_BIT;
# if defined (ARM_STM32L1XX) || defined (ARM_STM32F4XX)
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
# elif defined (ARM_STM32F10X)
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
# endif
GPIO_Init(IRMP_PORT, &GPIO_InitStructure);
#elif defined(STELLARIS_ARM_CORTEX_M4)
// Enable the GPIO port
ROM_SysCtlPeripheralEnable(IRMP_PORT_PERIPH);
// Set as an input
ROM_GPIODirModeSet(IRMP_PORT_BASE, IRMP_PORT_PIN, GPIO_DIR_MODE_IN);
ROM_GPIOPadConfigSet(IRMP_PORT_BASE, IRMP_PORT_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
#elif defined(__SDCC_stm8) // STM8
IRMP_GPIO_STRUCT->DDR &= ~(1<<IRMP_BIT); // pin is input
IRMP_GPIO_STRUCT->CR1 |= (1<<IRMP_BIT); // activate pullup
#elif defined (TEENSY_ARM_CORTEX_M4) // TEENSY
pinMode(IRMP_PIN, INPUT);
#elif defined(__MBED__)
gpio_init_in_ex(&gpioIRin, IRMP_PIN, IRMP_PINMODE); // initialize input for IR diode
#else // AVR
IRMP_PORT &= ~(1<<IRMP_BIT); // deactivate pullup
IRMP_DDR &= ~(1<<IRMP_BIT); // set pin to input
#endif
#if IRMP_LOGGING == 1
irmp_uart_init ();
#endif
}
#endif
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Get IRMP data
* @details gets decoded IRMP data
* @param pointer in order to store IRMP data
* @return TRUE: successful, FALSE: failed
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
uint_fast8_t
irmp_get_data (IRMP_DATA * irmp_data_p)
{
uint_fast8_t rtc = FALSE;
if (irmp_ir_detected)
{
switch (irmp_protocol)
{
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
case IRMP_SAMSUNG_PROTOCOL:
if ((irmp_command >> 8) == (~irmp_command & 0x00FF))
{
irmp_command &= 0xff;
irmp_command |= irmp_id << 8;
rtc = TRUE;
}
break;
#if IRMP_SUPPORT_SAMSUNG48_PROTOCOL == 1
case IRMP_SAMSUNG48_PROTOCOL:
irmp_command = (irmp_command & 0x00FF) | ((irmp_id & 0x00FF) << 8);
rtc = TRUE;
break;
#endif
#endif
#if IRMP_SUPPORT_NEC_PROTOCOL == 1
case IRMP_NEC_PROTOCOL:
if ((irmp_command >> 8) == (~irmp_command & 0x00FF))
{
irmp_command &= 0xff;
rtc = TRUE;
}
else if (irmp_address == 0x87EE)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to APPLE protocol\n");
#endif // ANALYZE
irmp_protocol = IRMP_APPLE_PROTOCOL;
irmp_address = (irmp_command & 0xFF00) >> 8;
irmp_command &= 0x00FF;
rtc = TRUE;
}
break;
#endif
#if IRMP_SUPPORT_BOSE_PROTOCOL == 1
case IRMP_BOSE_PROTOCOL:
if ((irmp_command >> 8) == (~irmp_command & 0x00FF))
{
irmp_command &= 0xff;
rtc = TRUE;
}
break;
#endif
#if IRMP_SUPPORT_SIEMENS_OR_RUWIDO_PROTOCOL == 1
case IRMP_SIEMENS_PROTOCOL:
case IRMP_RUWIDO_PROTOCOL:
if (((irmp_command >> 1) & 0x0001) == (~irmp_command & 0x0001))
{
irmp_command >>= 1;
rtc = TRUE;
}
break;
#endif
#if IRMP_SUPPORT_KATHREIN_PROTOCOL == 1
case IRMP_KATHREIN_PROTOCOL:
if (irmp_command != 0x0000)
{
rtc = TRUE;
}
break;
#endif
#if IRMP_SUPPORT_RC5_PROTOCOL == 1
case IRMP_RC5_PROTOCOL:
irmp_address &= ~0x20; // clear toggle bit
rtc = TRUE;
break;
#endif
#if IRMP_SUPPORT_S100_PROTOCOL == 1
case IRMP_S100_PROTOCOL:
irmp_address &= ~0x20; // clear toggle bit
rtc = TRUE;
break;
#endif
#if IRMP_SUPPORT_IR60_PROTOCOL == 1
case IRMP_IR60_PROTOCOL:
if (irmp_command != 0x007d) // 0x007d (== 62<<1 + 1) is start instruction frame
{
rtc = TRUE;
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF("Info IR60: got start instruction frame\n");
#endif // ANALYZE
}
break;
#endif
#if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
case IRMP_RCCAR_PROTOCOL:
// frame in irmp_data:
// Bit 12 11 10 9 8 7 6 5 4 3 2 1 0
// V D7 D6 D5 D4 D3 D2 D1 D0 A1 A0 C1 C0 // 10 9 8 7 6 5 4 3 2 1 0
irmp_address = (irmp_command & 0x000C) >> 2; // addr: 0 0 0 0 0 0 0 0 0 A1 A0
irmp_command = ((irmp_command & 0x1000) >> 2) | // V-Bit: V 0 0 0 0 0 0 0 0 0 0
((irmp_command & 0x0003) << 8) | // C-Bits: 0 C1 C0 0 0 0 0 0 0 0 0
((irmp_command & 0x0FF0) >> 4); // D-Bits: D7 D6 D5 D4 D3 D2 D1 D0
rtc = TRUE; // Summe: V C1 C0 D7 D6 D5 D4 D3 D2 D1 D0
break;
#endif
#if IRMP_SUPPORT_NETBOX_PROTOCOL == 1 // squeeze code to 8 bit, upper bit indicates release-key
case IRMP_NETBOX_PROTOCOL:
if (irmp_command & 0x1000) // last bit set?
{
if ((irmp_command & 0x1f) == 0x15) // key pressed: 101 01 (LSB)
{
irmp_command >>= 5;
irmp_command &= 0x7F;
rtc = TRUE;
}
else if ((irmp_command & 0x1f) == 0x10) // key released: 000 01 (LSB)
{
irmp_command >>= 5;
irmp_command |= 0x80;
rtc = TRUE;
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF("error NETBOX: bit6/7 must be 0/1\n");
#endif // ANALYZE
}
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF("error NETBOX: last bit not set\n");
#endif // ANALYZE
}
break;
#endif
#if IRMP_SUPPORT_LEGO_PROTOCOL == 1
case IRMP_LEGO_PROTOCOL:
{
uint_fast8_t crc = 0x0F ^ ((irmp_command & 0xF000) >> 12) ^ ((irmp_command & 0x0F00) >> 8) ^ ((irmp_command & 0x00F0) >> 4);
if ((irmp_command & 0x000F) == crc)
{
irmp_command >>= 4;
rtc = TRUE;
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF ("CRC error in LEGO protocol\n");
#endif // ANALYZE
// rtc = TRUE; // don't accept codes with CRC errors
}
break;
}
#endif
default:
{
rtc = TRUE;
break;
}
}
if (rtc)
{
irmp_data_p->protocol = irmp_protocol;
irmp_data_p->address = irmp_address;
irmp_data_p->command = irmp_command;
irmp_data_p->flags = irmp_flags;
irmp_command = 0;
irmp_address = 0;
irmp_flags = 0;
}
irmp_ir_detected = FALSE;
}
return rtc;
}
#if IRMP_USE_CALLBACK == 1
void
irmp_set_callback_ptr (void (*cb)(uint_fast8_t))
{
irmp_callback_ptr = cb;
}
#endif // IRMP_USE_CALLBACK == 1
// these statics must not be volatile, because they are only used by irmp_store_bit(), which is called by irmp_ISR()
static uint_fast16_t irmp_tmp_address; // ir address
static uint_fast16_t irmp_tmp_command; // ir command
#if (IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)) || IRMP_SUPPORT_NEC42_PROTOCOL == 1
static uint_fast16_t irmp_tmp_address2; // ir address
static uint_fast16_t irmp_tmp_command2; // ir command
#endif
#if IRMP_SUPPORT_LGAIR_PROTOCOL == 1
static uint_fast16_t irmp_lgair_address; // ir address
static uint_fast16_t irmp_lgair_command; // ir command
#endif
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
static uint_fast16_t irmp_tmp_id; // ir id (only SAMSUNG)
#endif
#if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
static uint8_t xor_check[6]; // check kaseikyo "parity" bits
static uint_fast8_t genre2; // save genre2 bits here, later copied to MSB in flags
#endif
#if IRMP_SUPPORT_ORTEK_PROTOCOL == 1
static uint_fast8_t parity; // number of '1' of the first 14 bits, check if even.
#endif
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* store bit
* @details store bit in temp address or temp command
* @param value to store: 0 or 1
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
// verhindert, dass irmp_store_bit() inline compiliert wird:
// static void irmp_store_bit (uint_fast8_t) __attribute__ ((noinline));
static void
irmp_store_bit (uint_fast8_t value)
{
#if IRMP_SUPPORT_ACP24_PROTOCOL == 1
if (irmp_param.protocol == IRMP_ACP24_PROTOCOL) // squeeze 64 bits into 16 bits:
{
if (value)
{
// ACP24-Frame:
// 1 2 3 4 5 6
// 0123456789012345678901234567890123456789012345678901234567890123456789
// N VVMMM ? ??? t vmA x y TTTT
//
// irmp_data_p->command:
//
// 5432109876543210
// NAVVvMMMmtxyTTTT
switch (irmp_bit)
{
case 0: irmp_tmp_command |= (1<<15); break; // N
case 2: irmp_tmp_command |= (1<<13); break; // V
case 3: irmp_tmp_command |= (1<<12); break; // V
case 4: irmp_tmp_command |= (1<<10); break; // M
case 5: irmp_tmp_command |= (1<< 9); break; // M
case 6: irmp_tmp_command |= (1<< 8); break; // M
case 20: irmp_tmp_command |= (1<< 6); break; // t
case 22: irmp_tmp_command |= (1<<11); break; // v
case 23: irmp_tmp_command |= (1<< 7); break; // m
case 24: irmp_tmp_command |= (1<<14); break; // A
case 26: irmp_tmp_command |= (1<< 5); break; // x
case 44: irmp_tmp_command |= (1<< 4); break; // y
case 66: irmp_tmp_command |= (1<< 3); break; // T
case 67: irmp_tmp_command |= (1<< 2); break; // T
case 68: irmp_tmp_command |= (1<< 1); break; // T
case 69: irmp_tmp_command |= (1<< 0); break; // T
}
}
}
else
#endif // IRMP_SUPPORT_ACP24_PROTOCOL
#if IRMP_SUPPORT_ORTEK_PROTOCOL == 1
if (irmp_param.protocol == IRMP_ORTEK_PROTOCOL)
{
if (irmp_bit < 14)
{
if (value)
{
parity++;
}
}
else if (irmp_bit == 14)
{
if (value) // value == 1: even parity
{
if (parity & 0x01)
{
parity = PARITY_CHECK_FAILED;
}
else
{
parity = PARITY_CHECK_OK;
}
}
else
{
if (parity & 0x01) // value == 0: odd parity
{
parity = PARITY_CHECK_OK;
}
else
{
parity = PARITY_CHECK_FAILED;
}
}
}
}
else
#endif
{
;
}
#if IRMP_SUPPORT_GRUNDIG_NOKIA_IR60_PROTOCOL == 1
if (irmp_bit == 0 && irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL)
{
first_bit = value;
}
else
#endif
if (irmp_bit >= irmp_param.address_offset && irmp_bit < irmp_param.address_end)
{
if (irmp_param.lsb_first)
{
irmp_tmp_address |= (((uint_fast16_t) (value)) << (irmp_bit - irmp_param.address_offset)); // CV wants cast
}
else
{
irmp_tmp_address <<= 1;
irmp_tmp_address |= value;
}
}
else if (irmp_bit >= irmp_param.command_offset && irmp_bit < irmp_param.command_end)
{
if (irmp_param.lsb_first)
{
#if IRMP_SUPPORT_SAMSUNG48_PROTOCOL == 1
if (irmp_param.protocol == IRMP_SAMSUNG48_PROTOCOL && irmp_bit >= 32)
{
irmp_tmp_id |= (((uint_fast16_t) (value)) << (irmp_bit - 32)); // CV wants cast
}
else
#endif
{
irmp_tmp_command |= (((uint_fast16_t) (value)) << (irmp_bit - irmp_param.command_offset)); // CV wants cast
}
}
else
{
irmp_tmp_command <<= 1;
irmp_tmp_command |= value;
}
}
#if IRMP_SUPPORT_LGAIR_PROTOCOL == 1
if (irmp_param.protocol == IRMP_NEC_PROTOCOL || irmp_param.protocol == IRMP_NEC42_PROTOCOL)
{
if (irmp_bit < 8)
{
irmp_lgair_address <<= 1; // LGAIR uses MSB
irmp_lgair_address |= value;
}
else if (irmp_bit < 24)
{
irmp_lgair_command <<= 1; // LGAIR uses MSB
irmp_lgair_command |= value;
}
}
// NO else!
#endif
#if IRMP_SUPPORT_NEC42_PROTOCOL == 1
if (irmp_param.protocol == IRMP_NEC42_PROTOCOL && irmp_bit >= 13 && irmp_bit < 26)
{
irmp_tmp_address2 |= (((uint_fast16_t) (value)) << (irmp_bit - 13)); // CV wants cast
}
else
#endif
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
if (irmp_param.protocol == IRMP_SAMSUNG_PROTOCOL && irmp_bit >= SAMSUNG_ID_OFFSET && irmp_bit < SAMSUNG_ID_OFFSET + SAMSUNG_ID_LEN)
{
irmp_tmp_id |= (((uint_fast16_t) (value)) << (irmp_bit - SAMSUNG_ID_OFFSET)); // store with LSB first
}
else
#endif
#if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
if (irmp_param.protocol == IRMP_KASEIKYO_PROTOCOL)
{
if (irmp_bit >= 20 && irmp_bit < 24)
{
irmp_tmp_command |= (((uint_fast16_t) (value)) << (irmp_bit - 8)); // store 4 system bits (genre 1) in upper nibble with LSB first
}
else if (irmp_bit >= 24 && irmp_bit < 28)
{
genre2 |= (((uint_fast8_t) (value)) << (irmp_bit - 20)); // store 4 system bits (genre 2) in upper nibble with LSB first
}
if (irmp_bit < KASEIKYO_COMPLETE_DATA_LEN)
{
if (value)
{
xor_check[irmp_bit / 8] |= 1 << (irmp_bit % 8);
}
else
{
xor_check[irmp_bit / 8] &= ~(1 << (irmp_bit % 8));
}
}
}
else
#endif
{
;
}
irmp_bit++;
}
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* store bit
* @details store bit in temp address or temp command
* @param value to store: 0 or 1
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
static void
irmp_store_bit2 (uint_fast8_t value)
{
uint_fast8_t irmp_bit2;
if (irmp_param.protocol)
{
irmp_bit2 = irmp_bit - 2;
}
else
{
irmp_bit2 = irmp_bit - 1;
}
if (irmp_bit2 >= irmp_param2.address_offset && irmp_bit2 < irmp_param2.address_end)
{
irmp_tmp_address2 |= (((uint_fast16_t) (value)) << (irmp_bit2 - irmp_param2.address_offset)); // CV wants cast
}
else if (irmp_bit2 >= irmp_param2.command_offset && irmp_bit2 < irmp_param2.command_end)
{
irmp_tmp_command2 |= (((uint_fast16_t) (value)) << (irmp_bit2 - irmp_param2.command_offset)); // CV wants cast
}
}
#endif // IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* ISR routine
* @details ISR routine, called 10000 times per second
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
uint_fast8_t
irmp_ISR (void)
{
static uint_fast8_t irmp_start_bit_detected; // flag: start bit detected
static uint_fast8_t wait_for_space; // flag: wait for data bit space
static uint_fast8_t wait_for_start_space; // flag: wait for start bit space
static uint_fast8_t irmp_pulse_time; // count bit time for pulse
static PAUSE_LEN irmp_pause_time; // count bit time for pause
static uint_fast16_t last_irmp_address = 0xFFFF; // save last irmp address to recognize key repetition
static uint_fast16_t last_irmp_command = 0xFFFF; // save last irmp command to recognize key repetition
static uint_fast16_t key_repetition_len; // SIRCS repeats frame 2-5 times with 45 ms pause
static uint_fast8_t repetition_frame_number;
#if IRMP_SUPPORT_DENON_PROTOCOL == 1
static uint_fast16_t last_irmp_denon_command; // save last irmp command to recognize DENON frame repetition
static uint_fast16_t denon_repetition_len = 0xFFFF; // denon repetition len of 2nd auto generated frame
#endif
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 || IRMP_SUPPORT_S100_PROTOCOL == 1
static uint_fast8_t rc5_cmd_bit6; // bit 6 of RC5 command is the inverted 2nd start bit
#endif
#if IRMP_SUPPORT_MANCHESTER == 1
static PAUSE_LEN last_pause; // last pause value
#endif
#if IRMP_SUPPORT_MANCHESTER == 1 || IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
static uint_fast8_t last_value; // last bit value
#endif
uint_fast8_t irmp_input; // input value
#ifdef ANALYZE
time_counter++;
#endif // ANALYZE
#if defined(__SDCC_stm8)
irmp_input = input(IRMP_GPIO_STRUCT->IDR)
#elif defined(__MBED__)
//irmp_input = inputPin;
irmp_input = gpio_read (&gpioIRin);
#else
irmp_input = input(IRMP_PIN);
#endif
#if IRMP_USE_CALLBACK == 1
if (irmp_callback_ptr)
{
static uint_fast8_t last_inverted_input;
if (last_inverted_input != !irmp_input)
{
(*irmp_callback_ptr) (! irmp_input);
last_inverted_input = !irmp_input;
}
}
#endif // IRMP_USE_CALLBACK == 1
irmp_log(irmp_input); // log ir signal, if IRMP_LOGGING defined
if (! irmp_ir_detected) // ir code already detected?
{ // no...
if (! irmp_start_bit_detected) // start bit detected?
{ // no...
if (! irmp_input) // receiving burst?
{ // yes...
// irmp_busy_flag = TRUE;
#ifdef ANALYZE
if (! irmp_pulse_time)
{
ANALYZE_PRINTF("%8.3fms [starting pulse]\n", (double) (time_counter * 1000) / F_INTERRUPTS);
}
#endif // ANALYZE
irmp_pulse_time++; // increment counter
}
else
{ // no...
if (irmp_pulse_time) // it's dark....
{ // set flags for counting the time of darkness...
irmp_start_bit_detected = 1;
wait_for_start_space = 1;
wait_for_space = 0;
irmp_tmp_command = 0;
irmp_tmp_address = 0;
#if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
genre2 = 0;
#endif
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
irmp_tmp_id = 0;
#endif
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1) || IRMP_SUPPORT_NEC42_PROTOCOL == 1
irmp_tmp_command2 = 0;
irmp_tmp_address2 = 0;
#endif
#if IRMP_SUPPORT_LGAIR_PROTOCOL == 1
irmp_lgair_command = 0;
irmp_lgair_address = 0;
#endif
irmp_bit = 0xff;
irmp_pause_time = 1; // 1st pause: set to 1, not to 0!
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 || IRMP_SUPPORT_S100_PROTOCOL == 1
rc5_cmd_bit6 = 0; // fm 2010-03-07: bugfix: reset it after incomplete RC5 frame!
#endif
}
else
{
if (key_repetition_len < 0xFFFF) // avoid overflow of counter
{
key_repetition_len++;
#if IRMP_SUPPORT_DENON_PROTOCOL == 1
if (denon_repetition_len < 0xFFFF) // avoid overflow of counter
{
denon_repetition_len++;
if (denon_repetition_len >= DENON_AUTO_REPETITION_PAUSE_LEN && last_irmp_denon_command != 0)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms warning: did not receive inverted command repetition\n",
(double) (time_counter * 1000) / F_INTERRUPTS);
#endif // ANALYZE
last_irmp_denon_command = 0;
denon_repetition_len = 0xFFFF;
}
}
#endif // IRMP_SUPPORT_DENON_PROTOCOL == 1
}
}
}
}
else
{
if (wait_for_start_space) // we have received start bit...
{ // ...and are counting the time of darkness
if (irmp_input) // still dark?
{ // yes
irmp_pause_time++; // increment counter
#if IRMP_SUPPORT_NIKON_PROTOCOL == 1
if (((irmp_pulse_time < NIKON_START_BIT_PULSE_LEN_MIN || irmp_pulse_time > NIKON_START_BIT_PULSE_LEN_MAX) && irmp_pause_time > IRMP_TIMEOUT_LEN) ||
irmp_pause_time > IRMP_TIMEOUT_NIKON_LEN)
#else
if (irmp_pause_time > IRMP_TIMEOUT_LEN) // timeout?
#endif
{ // yes...
#if IRMP_SUPPORT_JVC_PROTOCOL == 1
if (irmp_protocol == IRMP_JVC_PROTOCOL) // don't show eror if JVC protocol, irmp_pulse_time has been set below!
{
;
}
else
#endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms error 1: pause after start bit pulse %d too long: %d\n", (double) (time_counter * 1000) / F_INTERRUPTS, irmp_pulse_time, irmp_pause_time);
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
}
irmp_start_bit_detected = 0; // reset flags, let's wait for another start bit
irmp_pulse_time = 0;
irmp_pause_time = 0;
}
}
else
{ // receiving first data pulse!
IRMP_PARAMETER * irmp_param_p;
irmp_param_p = (IRMP_PARAMETER *) 0;
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
irmp_param2.protocol = 0;
#endif
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms [start-bit: pulse = %2d, pause = %2d]\n", (double) (time_counter * 1000) / F_INTERRUPTS, irmp_pulse_time, irmp_pause_time);
#endif // ANALYZE
#if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
if (irmp_pulse_time >= SIRCS_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= SIRCS_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= SIRCS_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= SIRCS_START_BIT_PAUSE_LEN_MAX)
{ // it's SIRCS
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = SIRCS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
SIRCS_START_BIT_PULSE_LEN_MIN, SIRCS_START_BIT_PULSE_LEN_MAX,
SIRCS_START_BIT_PAUSE_LEN_MIN, SIRCS_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &sircs_param;
}
else
#endif // IRMP_SUPPORT_SIRCS_PROTOCOL == 1
#if IRMP_SUPPORT_JVC_PROTOCOL == 1
if (irmp_protocol == IRMP_JVC_PROTOCOL && // last protocol was JVC, awaiting repeat frame
irmp_pulse_time >= JVC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= JVC_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= JVC_REPEAT_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= JVC_REPEAT_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = NEC or JVC (type 1) repeat frame, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
JVC_START_BIT_PULSE_LEN_MIN, JVC_START_BIT_PULSE_LEN_MAX,
JVC_REPEAT_START_BIT_PAUSE_LEN_MIN, JVC_REPEAT_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &nec_param;
}
else
#endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
#if IRMP_SUPPORT_NEC_PROTOCOL == 1
if (irmp_pulse_time >= NEC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= NEC_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= NEC_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= NEC_START_BIT_PAUSE_LEN_MAX)
{
#if IRMP_SUPPORT_NEC42_PROTOCOL == 1
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = NEC42, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
NEC_START_BIT_PULSE_LEN_MIN, NEC_START_BIT_PULSE_LEN_MAX,
NEC_START_BIT_PAUSE_LEN_MIN, NEC_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &nec42_param;
#else
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = NEC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
NEC_START_BIT_PULSE_LEN_MIN, NEC_START_BIT_PULSE_LEN_MAX,
NEC_START_BIT_PAUSE_LEN_MIN, NEC_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &nec_param;
#endif
}
else if (irmp_pulse_time >= NEC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= NEC_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= NEC_REPEAT_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= NEC_REPEAT_START_BIT_PAUSE_LEN_MAX)
{ // it's NEC
#if IRMP_SUPPORT_JVC_PROTOCOL == 1
if (irmp_protocol == IRMP_JVC_PROTOCOL) // last protocol was JVC, awaiting repeat frame
{ // some jvc remote controls use nec repetition frame for jvc repetition frame
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = JVC repeat frame type 2, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
NEC_START_BIT_PULSE_LEN_MIN, NEC_START_BIT_PULSE_LEN_MAX,
NEC_REPEAT_START_BIT_PAUSE_LEN_MIN, NEC_REPEAT_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &nec_param;
}
else
#endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = NEC (repetition frame), start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
NEC_START_BIT_PULSE_LEN_MIN, NEC_START_BIT_PULSE_LEN_MAX,
NEC_REPEAT_START_BIT_PAUSE_LEN_MIN, NEC_REPEAT_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &nec_rep_param;
}
}
else
#if IRMP_SUPPORT_JVC_PROTOCOL == 1
if (irmp_protocol == IRMP_JVC_PROTOCOL && // last protocol was JVC, awaiting repeat frame
irmp_pulse_time >= NEC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= NEC_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= NEC_0_PAUSE_LEN_MIN && irmp_pause_time <= NEC_0_PAUSE_LEN_MAX)
{ // it's JVC repetition type 3
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = JVC repeat frame type 3, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
NEC_START_BIT_PULSE_LEN_MIN, NEC_START_BIT_PULSE_LEN_MAX,
NEC_0_PAUSE_LEN_MIN, NEC_0_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &nec_param;
}
else
#endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
#endif // IRMP_SUPPORT_NEC_PROTOCOL == 1
#if IRMP_SUPPORT_TELEFUNKEN_PROTOCOL == 1
if (irmp_pulse_time >= TELEFUNKEN_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= TELEFUNKEN_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= TELEFUNKEN_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= TELEFUNKEN_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = TELEFUNKEN, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
TELEFUNKEN_START_BIT_PULSE_LEN_MIN, TELEFUNKEN_START_BIT_PULSE_LEN_MAX,
TELEFUNKEN_START_BIT_PAUSE_LEN_MIN, TELEFUNKEN_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &telefunken_param;
}
else
#endif // IRMP_SUPPORT_TELEFUNKEN_PROTOCOL == 1
#if IRMP_SUPPORT_ROOMBA_PROTOCOL == 1
if (irmp_pulse_time >= ROOMBA_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= ROOMBA_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= ROOMBA_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= ROOMBA_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = ROOMBA, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
ROOMBA_START_BIT_PULSE_LEN_MIN, ROOMBA_START_BIT_PULSE_LEN_MAX,
ROOMBA_START_BIT_PAUSE_LEN_MIN, ROOMBA_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &roomba_param;
}
else
#endif // IRMP_SUPPORT_ROOMBA_PROTOCOL == 1
#if IRMP_SUPPORT_ACP24_PROTOCOL == 1
if (irmp_pulse_time >= ACP24_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= ACP24_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= ACP24_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= ACP24_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = ACP24, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
ACP24_START_BIT_PULSE_LEN_MIN, ACP24_START_BIT_PULSE_LEN_MAX,
ACP24_START_BIT_PAUSE_LEN_MIN, ACP24_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &acp24_param;
}
else
#endif // IRMP_SUPPORT_ROOMBA_PROTOCOL == 1
#if IRMP_SUPPORT_PENTAX_PROTOCOL == 1
if (irmp_pulse_time >= PENTAX_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= PENTAX_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= PENTAX_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= PENTAX_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = PENTAX, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
PENTAX_START_BIT_PULSE_LEN_MIN, PENTAX_START_BIT_PULSE_LEN_MAX,
PENTAX_START_BIT_PAUSE_LEN_MIN, PENTAX_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &pentax_param;
}
else
#endif // IRMP_SUPPORT_PENTAX_PROTOCOL == 1
#if IRMP_SUPPORT_NIKON_PROTOCOL == 1
if (irmp_pulse_time >= NIKON_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= NIKON_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= NIKON_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= NIKON_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = NIKON, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
NIKON_START_BIT_PULSE_LEN_MIN, NIKON_START_BIT_PULSE_LEN_MAX,
NIKON_START_BIT_PAUSE_LEN_MIN, NIKON_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &nikon_param;
}
else
#endif // IRMP_SUPPORT_NIKON_PROTOCOL == 1
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
if (irmp_pulse_time >= SAMSUNG_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= SAMSUNG_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= SAMSUNG_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= SAMSUNG_START_BIT_PAUSE_LEN_MAX)
{ // it's SAMSUNG
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = SAMSUNG, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
SAMSUNG_START_BIT_PULSE_LEN_MIN, SAMSUNG_START_BIT_PULSE_LEN_MAX,
SAMSUNG_START_BIT_PAUSE_LEN_MIN, SAMSUNG_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &samsung_param;
}
else
#endif // IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
#if IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
if (irmp_pulse_time >= MATSUSHITA_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= MATSUSHITA_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= MATSUSHITA_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= MATSUSHITA_START_BIT_PAUSE_LEN_MAX)
{ // it's MATSUSHITA
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = MATSUSHITA, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
MATSUSHITA_START_BIT_PULSE_LEN_MIN, MATSUSHITA_START_BIT_PULSE_LEN_MAX,
MATSUSHITA_START_BIT_PAUSE_LEN_MIN, MATSUSHITA_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &matsushita_param;
}
else
#endif // IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
#if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
if (irmp_pulse_time >= KASEIKYO_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= KASEIKYO_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= KASEIKYO_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= KASEIKYO_START_BIT_PAUSE_LEN_MAX)
{ // it's KASEIKYO
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = KASEIKYO, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
KASEIKYO_START_BIT_PULSE_LEN_MIN, KASEIKYO_START_BIT_PULSE_LEN_MAX,
KASEIKYO_START_BIT_PAUSE_LEN_MIN, KASEIKYO_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &kaseikyo_param;
}
else
#endif // IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
#if IRMP_SUPPORT_PANASONIC_PROTOCOL == 1
if (irmp_pulse_time >= PANASONIC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= PANASONIC_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= PANASONIC_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= PANASONIC_START_BIT_PAUSE_LEN_MAX)
{ // it's PANASONIC
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = PANASONIC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
PANASONIC_START_BIT_PULSE_LEN_MIN, PANASONIC_START_BIT_PULSE_LEN_MAX,
PANASONIC_START_BIT_PAUSE_LEN_MIN, PANASONIC_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &panasonic_param;
}
else
#endif // IRMP_SUPPORT_PANASONIC_PROTOCOL == 1
#if IRMP_SUPPORT_RADIO1_PROTOCOL == 1
if (irmp_pulse_time >= RADIO1_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RADIO1_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= RADIO1_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RADIO1_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RADIO1, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
RADIO1_START_BIT_PULSE_LEN_MIN, RADIO1_START_BIT_PULSE_LEN_MAX,
RADIO1_START_BIT_PAUSE_LEN_MIN, RADIO1_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &radio1_param;
}
else
#endif // IRMP_SUPPORT_RRADIO1_PROTOCOL == 1
#if IRMP_SUPPORT_RECS80_PROTOCOL == 1
if (irmp_pulse_time >= RECS80_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RECS80_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= RECS80_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RECS80_START_BIT_PAUSE_LEN_MAX)
{ // it's RECS80
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RECS80, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
RECS80_START_BIT_PULSE_LEN_MIN, RECS80_START_BIT_PULSE_LEN_MAX,
RECS80_START_BIT_PAUSE_LEN_MIN, RECS80_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &recs80_param;
}
else
#endif // IRMP_SUPPORT_RECS80_PROTOCOL == 1
#if IRMP_SUPPORT_S100_PROTOCOL == 1
if (((irmp_pulse_time >= S100_START_BIT_LEN_MIN && irmp_pulse_time <= S100_START_BIT_LEN_MAX) ||
(irmp_pulse_time >= 2 * S100_START_BIT_LEN_MIN && irmp_pulse_time <= 2 * S100_START_BIT_LEN_MAX)) &&
((irmp_pause_time >= S100_START_BIT_LEN_MIN && irmp_pause_time <= S100_START_BIT_LEN_MAX) ||
(irmp_pause_time >= 2 * S100_START_BIT_LEN_MIN && irmp_pause_time <= 2 * S100_START_BIT_LEN_MAX)))
{ // it's S100
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = S100, start bit timings: pulse: %3d - %3d, pause: %3d - %3d or pulse: %3d - %3d, pause: %3d - %3d\n",
S100_START_BIT_LEN_MIN, S100_START_BIT_LEN_MAX,
2 * S100_START_BIT_LEN_MIN, 2 * S100_START_BIT_LEN_MAX,
S100_START_BIT_LEN_MIN, S100_START_BIT_LEN_MAX,
2 * S100_START_BIT_LEN_MIN, 2 * S100_START_BIT_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &s100_param;
last_pause = irmp_pause_time;
if ((irmp_pulse_time > S100_START_BIT_LEN_MAX && irmp_pulse_time <= 2 * S100_START_BIT_LEN_MAX) ||
(irmp_pause_time > S100_START_BIT_LEN_MAX && irmp_pause_time <= 2 * S100_START_BIT_LEN_MAX))
{
last_value = 0;
rc5_cmd_bit6 = 1<<6;
}
else
{
last_value = 1;
}
}
else
#endif // IRMP_SUPPORT_S100_PROTOCOL == 1
#if IRMP_SUPPORT_RC5_PROTOCOL == 1
if (((irmp_pulse_time >= RC5_START_BIT_LEN_MIN && irmp_pulse_time <= RC5_START_BIT_LEN_MAX) ||
(irmp_pulse_time >= 2 * RC5_START_BIT_LEN_MIN && irmp_pulse_time <= 2 * RC5_START_BIT_LEN_MAX)) &&
((irmp_pause_time >= RC5_START_BIT_LEN_MIN && irmp_pause_time <= RC5_START_BIT_LEN_MAX) ||
(irmp_pause_time >= 2 * RC5_START_BIT_LEN_MIN && irmp_pause_time <= 2 * RC5_START_BIT_LEN_MAX)))
{ // it's RC5
#if IRMP_SUPPORT_FDC_PROTOCOL == 1
if (irmp_pulse_time >= FDC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= FDC_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= FDC_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= FDC_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RC5 or FDC\n");
ANALYZE_PRINTF ("FDC start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
FDC_START_BIT_PULSE_LEN_MIN, FDC_START_BIT_PULSE_LEN_MAX,
FDC_START_BIT_PAUSE_LEN_MIN, FDC_START_BIT_PAUSE_LEN_MAX);
ANALYZE_PRINTF ("RC5 start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
RC5_START_BIT_LEN_MIN, RC5_START_BIT_LEN_MAX,
RC5_START_BIT_LEN_MIN, RC5_START_BIT_LEN_MAX);
#endif // ANALYZE
memcpy_P (&irmp_param2, &fdc_param, sizeof (IRMP_PARAMETER));
}
else
#endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
#if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
if (irmp_pulse_time >= RCCAR_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RCCAR_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= RCCAR_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RCCAR_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RC5 or RCCAR\n");
ANALYZE_PRINTF ("RCCAR start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
RCCAR_START_BIT_PULSE_LEN_MIN, RCCAR_START_BIT_PULSE_LEN_MAX,
RCCAR_START_BIT_PAUSE_LEN_MIN, RCCAR_START_BIT_PAUSE_LEN_MAX);
ANALYZE_PRINTF ("RC5 start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
RC5_START_BIT_LEN_MIN, RC5_START_BIT_LEN_MAX,
RC5_START_BIT_LEN_MIN, RC5_START_BIT_LEN_MAX);
#endif // ANALYZE
memcpy_P (&irmp_param2, &rccar_param, sizeof (IRMP_PARAMETER));
}
else
#endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RC5, start bit timings: pulse: %3d - %3d, pause: %3d - %3d or pulse: %3d - %3d, pause: %3d - %3d\n",
RC5_START_BIT_LEN_MIN, RC5_START_BIT_LEN_MAX,
2 * RC5_START_BIT_LEN_MIN, 2 * RC5_START_BIT_LEN_MAX,
RC5_START_BIT_LEN_MIN, RC5_START_BIT_LEN_MAX,
2 * RC5_START_BIT_LEN_MIN, 2 * RC5_START_BIT_LEN_MAX);
#endif // ANALYZE
}
irmp_param_p = (IRMP_PARAMETER *) &rc5_param;
last_pause = irmp_pause_time;
if ((irmp_pulse_time > RC5_START_BIT_LEN_MAX && irmp_pulse_time <= 2 * RC5_START_BIT_LEN_MAX) ||
(irmp_pause_time > RC5_START_BIT_LEN_MAX && irmp_pause_time <= 2 * RC5_START_BIT_LEN_MAX))
{
last_value = 0;
rc5_cmd_bit6 = 1<<6;
}
else
{
last_value = 1;
}
}
else
#endif // IRMP_SUPPORT_RC5_PROTOCOL == 1
#if IRMP_SUPPORT_DENON_PROTOCOL == 1
if ( (irmp_pulse_time >= DENON_PULSE_LEN_MIN && irmp_pulse_time <= DENON_PULSE_LEN_MAX) &&
((irmp_pause_time >= DENON_1_PAUSE_LEN_MIN && irmp_pause_time <= DENON_1_PAUSE_LEN_MAX) ||
(irmp_pause_time >= DENON_0_PAUSE_LEN_MIN && irmp_pause_time <= DENON_0_PAUSE_LEN_MAX)))
{ // it's DENON
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = DENON, start bit timings: pulse: %3d - %3d, pause: %3d - %3d or %3d - %3d\n",
DENON_PULSE_LEN_MIN, DENON_PULSE_LEN_MAX,
DENON_1_PAUSE_LEN_MIN, DENON_1_PAUSE_LEN_MAX,
DENON_0_PAUSE_LEN_MIN, DENON_0_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &denon_param;
}
else
#endif // IRMP_SUPPORT_DENON_PROTOCOL == 1
#if IRMP_SUPPORT_THOMSON_PROTOCOL == 1
if ( (irmp_pulse_time >= THOMSON_PULSE_LEN_MIN && irmp_pulse_time <= THOMSON_PULSE_LEN_MAX) &&
((irmp_pause_time >= THOMSON_1_PAUSE_LEN_MIN && irmp_pause_time <= THOMSON_1_PAUSE_LEN_MAX) ||
(irmp_pause_time >= THOMSON_0_PAUSE_LEN_MIN && irmp_pause_time <= THOMSON_0_PAUSE_LEN_MAX)))
{ // it's THOMSON
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = THOMSON, start bit timings: pulse: %3d - %3d, pause: %3d - %3d or %3d - %3d\n",
THOMSON_PULSE_LEN_MIN, THOMSON_PULSE_LEN_MAX,
THOMSON_1_PAUSE_LEN_MIN, THOMSON_1_PAUSE_LEN_MAX,
THOMSON_0_PAUSE_LEN_MIN, THOMSON_0_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &thomson_param;
}
else
#endif // IRMP_SUPPORT_THOMSON_PROTOCOL == 1
#if IRMP_SUPPORT_BOSE_PROTOCOL == 1
if (irmp_pulse_time >= BOSE_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= BOSE_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= BOSE_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= BOSE_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = BOSE, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
BOSE_START_BIT_PULSE_LEN_MIN, BOSE_START_BIT_PULSE_LEN_MAX,
BOSE_START_BIT_PAUSE_LEN_MIN, BOSE_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &bose_param;
}
else
#endif // IRMP_SUPPORT_BOSE_PROTOCOL == 1
#if IRMP_SUPPORT_RC6_PROTOCOL == 1
if (irmp_pulse_time >= RC6_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RC6_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= RC6_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RC6_START_BIT_PAUSE_LEN_MAX)
{ // it's RC6
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RC6, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
RC6_START_BIT_PULSE_LEN_MIN, RC6_START_BIT_PULSE_LEN_MAX,
RC6_START_BIT_PAUSE_LEN_MIN, RC6_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &rc6_param;
last_pause = 0;
last_value = 1;
}
else
#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
#if IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
if (irmp_pulse_time >= RECS80EXT_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RECS80EXT_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= RECS80EXT_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RECS80EXT_START_BIT_PAUSE_LEN_MAX)
{ // it's RECS80EXT
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RECS80EXT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
RECS80EXT_START_BIT_PULSE_LEN_MIN, RECS80EXT_START_BIT_PULSE_LEN_MAX,
RECS80EXT_START_BIT_PAUSE_LEN_MIN, RECS80EXT_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &recs80ext_param;
}
else
#endif // IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
#if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
if (irmp_pulse_time >= NUBERT_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= NUBERT_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= NUBERT_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= NUBERT_START_BIT_PAUSE_LEN_MAX)
{ // it's NUBERT
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = NUBERT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
NUBERT_START_BIT_PULSE_LEN_MIN, NUBERT_START_BIT_PULSE_LEN_MAX,
NUBERT_START_BIT_PAUSE_LEN_MIN, NUBERT_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &nubert_param;
}
else
#endif // IRMP_SUPPORT_NUBERT_PROTOCOL == 1
#if IRMP_SUPPORT_FAN_PROTOCOL == 1
if (irmp_pulse_time >= FAN_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= FAN_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= FAN_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= FAN_START_BIT_PAUSE_LEN_MAX)
{ // it's FAN
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = FAN, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
FAN_START_BIT_PULSE_LEN_MIN, FAN_START_BIT_PULSE_LEN_MAX,
FAN_START_BIT_PAUSE_LEN_MIN, FAN_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &fan_param;
}
else
#endif // IRMP_SUPPORT_FAN_PROTOCOL == 1
#if IRMP_SUPPORT_SPEAKER_PROTOCOL == 1
if (irmp_pulse_time >= SPEAKER_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= SPEAKER_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= SPEAKER_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= SPEAKER_START_BIT_PAUSE_LEN_MAX)
{ // it's SPEAKER
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = SPEAKER, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
SPEAKER_START_BIT_PULSE_LEN_MIN, SPEAKER_START_BIT_PULSE_LEN_MAX,
SPEAKER_START_BIT_PAUSE_LEN_MIN, SPEAKER_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &speaker_param;
}
else
#endif // IRMP_SUPPORT_SPEAKER_PROTOCOL == 1
#if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
if (irmp_pulse_time >= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN && irmp_pulse_time <= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX &&
irmp_pause_time >= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX)
{ // it's BANG_OLUFSEN
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = BANG_OLUFSEN\n");
ANALYZE_PRINTF ("start bit 1 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX,
BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX);
ANALYZE_PRINTF ("start bit 2 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX,
BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX);
ANALYZE_PRINTF ("start bit 3 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX,
BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX);
ANALYZE_PRINTF ("start bit 4 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX,
BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &bang_olufsen_param;
last_value = 0;
}
else
#endif // IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
#if IRMP_SUPPORT_GRUNDIG_NOKIA_IR60_PROTOCOL == 1
if (irmp_pulse_time >= GRUNDIG_NOKIA_IR60_START_BIT_LEN_MIN && irmp_pulse_time <= GRUNDIG_NOKIA_IR60_START_BIT_LEN_MAX &&
irmp_pause_time >= GRUNDIG_NOKIA_IR60_PRE_PAUSE_LEN_MIN && irmp_pause_time <= GRUNDIG_NOKIA_IR60_PRE_PAUSE_LEN_MAX)
{ // it's GRUNDIG
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = GRUNDIG, pre bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
GRUNDIG_NOKIA_IR60_START_BIT_LEN_MIN, GRUNDIG_NOKIA_IR60_START_BIT_LEN_MAX,
GRUNDIG_NOKIA_IR60_PRE_PAUSE_LEN_MIN, GRUNDIG_NOKIA_IR60_PRE_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &grundig_param;
last_pause = irmp_pause_time;
last_value = 1;
}
else
#endif // IRMP_SUPPORT_GRUNDIG_NOKIA_IR60_PROTOCOL == 1
#if IRMP_SUPPORT_MERLIN_PROTOCOL == 1 // check MERLIN before RUWIDO!
if (irmp_pulse_time >= MERLIN_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= MERLIN_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= MERLIN_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= MERLIN_START_BIT_PAUSE_LEN_MAX)
{ // it's MERLIN
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = MERLIN, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
MERLIN_START_BIT_PULSE_LEN_MIN, MERLIN_START_BIT_PULSE_LEN_MAX,
MERLIN_START_BIT_PAUSE_LEN_MIN, MERLIN_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &merlin_param;
last_pause = 0;
last_value = 1;
}
else
#endif // IRMP_SUPPORT_MERLIN_PROTOCOL == 1
#if IRMP_SUPPORT_SIEMENS_OR_RUWIDO_PROTOCOL == 1
if (((irmp_pulse_time >= SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MAX) ||
(irmp_pulse_time >= 2 * SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= 2 * SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MAX)) &&
((irmp_pause_time >= SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MAX) ||
(irmp_pause_time >= 2 * SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= 2 * SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MAX)))
{ // it's RUWIDO or SIEMENS
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RUWIDO, start bit timings: pulse: %3d - %3d or %3d - %3d, pause: %3d - %3d or %3d - %3d\n",
SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MIN, SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MAX,
2 * SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MIN, 2 * SIEMENS_OR_RUWIDO_START_BIT_PULSE_LEN_MAX,
SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MIN, SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MAX,
2 * SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MIN, 2 * SIEMENS_OR_RUWIDO_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &ruwido_param;
last_pause = irmp_pause_time;
last_value = 1;
}
else
#endif // IRMP_SUPPORT_SIEMENS_OR_RUWIDO_PROTOCOL == 1
#if IRMP_SUPPORT_FDC_PROTOCOL == 1
if (irmp_pulse_time >= FDC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= FDC_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= FDC_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= FDC_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = FDC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
FDC_START_BIT_PULSE_LEN_MIN, FDC_START_BIT_PULSE_LEN_MAX,
FDC_START_BIT_PAUSE_LEN_MIN, FDC_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &fdc_param;
}
else
#endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
#if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
if (irmp_pulse_time >= RCCAR_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RCCAR_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= RCCAR_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RCCAR_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RCCAR, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
RCCAR_START_BIT_PULSE_LEN_MIN, RCCAR_START_BIT_PULSE_LEN_MAX,
RCCAR_START_BIT_PAUSE_LEN_MIN, RCCAR_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &rccar_param;
}
else
#endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
#if IRMP_SUPPORT_KATHREIN_PROTOCOL == 1
if (irmp_pulse_time >= KATHREIN_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= KATHREIN_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= KATHREIN_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= KATHREIN_START_BIT_PAUSE_LEN_MAX)
{ // it's KATHREIN
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = KATHREIN, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
KATHREIN_START_BIT_PULSE_LEN_MIN, KATHREIN_START_BIT_PULSE_LEN_MAX,
KATHREIN_START_BIT_PAUSE_LEN_MIN, KATHREIN_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &kathrein_param;
}
else
#endif // IRMP_SUPPORT_KATHREIN_PROTOCOL == 1
#if IRMP_SUPPORT_NETBOX_PROTOCOL == 1
if (irmp_pulse_time >= NETBOX_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= NETBOX_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= NETBOX_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= NETBOX_START_BIT_PAUSE_LEN_MAX)
{ // it's NETBOX
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = NETBOX, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
NETBOX_START_BIT_PULSE_LEN_MIN, NETBOX_START_BIT_PULSE_LEN_MAX,
NETBOX_START_BIT_PAUSE_LEN_MIN, NETBOX_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &netbox_param;
}
else
#endif // IRMP_SUPPORT_NETBOX_PROTOCOL == 1
#if IRMP_SUPPORT_LEGO_PROTOCOL == 1
if (irmp_pulse_time >= LEGO_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= LEGO_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= LEGO_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= LEGO_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = LEGO, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
LEGO_START_BIT_PULSE_LEN_MIN, LEGO_START_BIT_PULSE_LEN_MAX,
LEGO_START_BIT_PAUSE_LEN_MIN, LEGO_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &lego_param;
}
else
#endif // IRMP_SUPPORT_LEGO_PROTOCOL == 1
#if IRMP_SUPPORT_A1TVBOX_PROTOCOL == 1
if (irmp_pulse_time >= A1TVBOX_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= A1TVBOX_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= A1TVBOX_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= A1TVBOX_START_BIT_PAUSE_LEN_MAX)
{ // it's A1TVBOX
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = A1TVBOX, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
A1TVBOX_START_BIT_PULSE_LEN_MIN, A1TVBOX_START_BIT_PULSE_LEN_MAX,
A1TVBOX_START_BIT_PAUSE_LEN_MIN, A1TVBOX_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &a1tvbox_param;
last_pause = 0;
last_value = 1;
}
else
#endif // IRMP_SUPPORT_A1TVBOX_PROTOCOL == 1
#if IRMP_SUPPORT_ORTEK_PROTOCOL == 1
if (irmp_pulse_time >= ORTEK_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= ORTEK_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= ORTEK_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= ORTEK_START_BIT_PAUSE_LEN_MAX)
{ // it's ORTEK (Hama)
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = ORTEK, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
ORTEK_START_BIT_PULSE_LEN_MIN, ORTEK_START_BIT_PULSE_LEN_MAX,
ORTEK_START_BIT_PAUSE_LEN_MIN, ORTEK_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &ortek_param;
last_pause = 0;
last_value = 1;
parity = 0;
}
else
#endif // IRMP_SUPPORT_ORTEK_PROTOCOL == 1
#if IRMP_SUPPORT_RCMM_PROTOCOL == 1
if (irmp_pulse_time >= RCMM32_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RCMM32_START_BIT_PULSE_LEN_MAX &&
irmp_pause_time >= RCMM32_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RCMM32_START_BIT_PAUSE_LEN_MAX)
{ // it's RCMM
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = RCMM, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
RCMM32_START_BIT_PULSE_LEN_MIN, RCMM32_START_BIT_PULSE_LEN_MAX,
RCMM32_START_BIT_PAUSE_LEN_MIN, RCMM32_START_BIT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_param_p = (IRMP_PARAMETER *) &rcmm_param;
}
else
#endif // IRMP_SUPPORT_RCMM_PROTOCOL == 1
{
#ifdef ANALYZE
ANALYZE_PRINTF ("protocol = UNKNOWN\n");
#endif // ANALYZE
irmp_start_bit_detected = 0; // wait for another start bit...
}
if (irmp_start_bit_detected)
{
memcpy_P (&irmp_param, irmp_param_p, sizeof (IRMP_PARAMETER));
if (! (irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER))
{
#ifdef ANALYZE
ANALYZE_PRINTF ("pulse_1: %3d - %3d\n", irmp_param.pulse_1_len_min, irmp_param.pulse_1_len_max);
ANALYZE_PRINTF ("pause_1: %3d - %3d\n", irmp_param.pause_1_len_min, irmp_param.pause_1_len_max);
#endif // ANALYZE
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF ("pulse: %3d - %3d or %3d - %3d\n", irmp_param.pulse_1_len_min, irmp_param.pulse_1_len_max,
2 * irmp_param.pulse_1_len_min, 2 * irmp_param.pulse_1_len_max);
ANALYZE_PRINTF ("pause: %3d - %3d or %3d - %3d\n", irmp_param.pause_1_len_min, irmp_param.pause_1_len_max,
2 * irmp_param.pause_1_len_min, 2 * irmp_param.pause_1_len_max);
#endif // ANALYZE
}
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
if (irmp_param2.protocol)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("pulse_0: %3d - %3d\n", irmp_param2.pulse_0_len_min, irmp_param2.pulse_0_len_max);
ANALYZE_PRINTF ("pause_0: %3d - %3d\n", irmp_param2.pause_0_len_min, irmp_param2.pause_0_len_max);
ANALYZE_PRINTF ("pulse_1: %3d - %3d\n", irmp_param2.pulse_1_len_min, irmp_param2.pulse_1_len_max);
ANALYZE_PRINTF ("pause_1: %3d - %3d\n", irmp_param2.pause_1_len_min, irmp_param2.pause_1_len_max);
#endif // ANALYZE
}
#endif
#if IRMP_SUPPORT_RC6_PROTOCOL == 1
if (irmp_param.protocol == IRMP_RC6_PROTOCOL)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("pulse_toggle: %3d - %3d\n", RC6_TOGGLE_BIT_LEN_MIN, RC6_TOGGLE_BIT_LEN_MAX);
#endif // ANALYZE
}
#endif
if (! (irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER))
{
#ifdef ANALYZE
ANALYZE_PRINTF ("pulse_0: %3d - %3d\n", irmp_param.pulse_0_len_min, irmp_param.pulse_0_len_max);
ANALYZE_PRINTF ("pause_0: %3d - %3d\n", irmp_param.pause_0_len_min, irmp_param.pause_0_len_max);
#endif // ANALYZE
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF ("pulse: %3d - %3d or %3d - %3d\n", irmp_param.pulse_0_len_min, irmp_param.pulse_0_len_max,
2 * irmp_param.pulse_0_len_min, 2 * irmp_param.pulse_0_len_max);
ANALYZE_PRINTF ("pause: %3d - %3d or %3d - %3d\n", irmp_param.pause_0_len_min, irmp_param.pause_0_len_max,
2 * irmp_param.pause_0_len_min, 2 * irmp_param.pause_0_len_max);
#endif // ANALYZE
}
#ifdef ANALYZE
#if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
if (irmp_param.protocol == IRMP_BANG_OLUFSEN_PROTOCOL)
{
ANALYZE_PRINTF ("pulse_r: %3d - %3d\n", irmp_param.pulse_0_len_min, irmp_param.pulse_0_len_max);
ANALYZE_PRINTF ("pause_r: %3d - %3d\n", BANG_OLUFSEN_R_PAUSE_LEN_MIN, BANG_OLUFSEN_R_PAUSE_LEN_MAX);
}
#endif
ANALYZE_PRINTF ("command_offset: %2d\n", irmp_param.command_offset);
ANALYZE_PRINTF ("command_len: %3d\n", irmp_param.command_end - irmp_param.command_offset);
ANALYZE_PRINTF ("complete_len: %3d\n", irmp_param.complete_len);
ANALYZE_PRINTF ("stop_bit: %3d\n", irmp_param.stop_bit);
#endif // ANALYZE
}
irmp_bit = 0;
#if IRMP_SUPPORT_MANCHESTER == 1
if ((irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER) &&
irmp_param.protocol != IRMP_RUWIDO_PROTOCOL && // Manchester, but not RUWIDO
irmp_param.protocol != IRMP_RC6_PROTOCOL) // Manchester, but not RC6
{
if (irmp_pause_time > irmp_param.pulse_1_len_max && irmp_pause_time <= 2 * irmp_param.pulse_1_len_max)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms [bit %2d: pulse = %3d, pause = %3d] ", (double) (time_counter * 1000) / F_INTERRUPTS, irmp_bit, irmp_pulse_time, irmp_pause_time);
ANALYZE_PUTCHAR ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? '0' : '1');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 0 : 1);
}
else if (! last_value) // && irmp_pause_time >= irmp_param.pause_1_len_min && irmp_pause_time <= irmp_param.pause_1_len_max)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms [bit %2d: pulse = %3d, pause = %3d] ", (double) (time_counter * 1000) / F_INTERRUPTS, irmp_bit, irmp_pulse_time, irmp_pause_time);
ANALYZE_PUTCHAR ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? '1' : '0');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 1 : 0);
}
}
else
#endif // IRMP_SUPPORT_MANCHESTER == 1
#if IRMP_SUPPORT_SERIAL == 1
if (irmp_param.flags & IRMP_PARAM_FLAG_IS_SERIAL)
{
; // do nothing
}
else
#endif // IRMP_SUPPORT_SERIAL == 1
#if IRMP_SUPPORT_DENON_PROTOCOL == 1
if (irmp_param.protocol == IRMP_DENON_PROTOCOL)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms [bit %2d: pulse = %3d, pause = %3d] ", (double) (time_counter * 1000) / F_INTERRUPTS, irmp_bit, irmp_pulse_time, irmp_pause_time);
#endif // ANALYZE
if (irmp_pause_time >= DENON_1_PAUSE_LEN_MIN && irmp_pause_time <= DENON_1_PAUSE_LEN_MAX)
{ // pause timings correct for "1"?
#ifdef ANALYZE
ANALYZE_PUTCHAR ('1'); // yes, store 1
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (1);
}
else // if (irmp_pause_time >= DENON_0_PAUSE_LEN_MIN && irmp_pause_time <= DENON_0_PAUSE_LEN_MAX)
{ // pause timings correct for "0"?
#ifdef ANALYZE
ANALYZE_PUTCHAR ('0'); // yes, store 0
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (0);
}
}
else
#endif // IRMP_SUPPORT_DENON_PROTOCOL == 1
#if IRMP_SUPPORT_THOMSON_PROTOCOL == 1
if (irmp_param.protocol == IRMP_THOMSON_PROTOCOL)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms [bit %2d: pulse = %3d, pause = %3d] ", (double) (time_counter * 1000) / F_INTERRUPTS, irmp_bit, irmp_pulse_time, irmp_pause_time);
#endif // ANALYZE
if (irmp_pause_time >= THOMSON_1_PAUSE_LEN_MIN && irmp_pause_time <= THOMSON_1_PAUSE_LEN_MAX)
{ // pause timings correct for "1"?
#ifdef ANALYZE
ANALYZE_PUTCHAR ('1'); // yes, store 1
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (1);
}
else // if (irmp_pause_time >= THOMSON_0_PAUSE_LEN_MIN && irmp_pause_time <= THOMSON_0_PAUSE_LEN_MAX)
{ // pause timings correct for "0"?
#ifdef ANALYZE
ANALYZE_PUTCHAR ('0'); // yes, store 0
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (0);
}
}
else
#endif // IRMP_SUPPORT_THOMSON_PROTOCOL == 1
{
; // else do nothing
}
irmp_pulse_time = 1; // set counter to 1, not 0
irmp_pause_time = 0;
wait_for_start_space = 0;
}
}
else if (wait_for_space) // the data section....
{ // counting the time of darkness....
uint_fast8_t got_light = FALSE;
if (irmp_input) // still dark?
{ // yes...
if (irmp_bit == irmp_param.complete_len && irmp_param.stop_bit == 1)
{
if (
#if IRMP_SUPPORT_MANCHESTER == 1
(irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER) ||
#endif
#if IRMP_SUPPORT_SERIAL == 1
(irmp_param.flags & IRMP_PARAM_FLAG_IS_SERIAL) ||
#endif
(irmp_pulse_time >= irmp_param.pulse_0_len_min && irmp_pulse_time <= irmp_param.pulse_0_len_max))
{
#ifdef ANALYZE
if (! (irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER))
{
ANALYZE_PRINTF ("stop bit detected\n");
}
#endif // ANALYZE
irmp_param.stop_bit = 0;
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF ("error: stop bit timing wrong, irmp_bit = %d, irmp_pulse_time = %d, pulse_0_len_min = %d, pulse_0_len_max = %d\n",
irmp_bit, irmp_pulse_time, irmp_param.pulse_0_len_min, irmp_param.pulse_0_len_max);
#endif // ANALYZE
irmp_start_bit_detected = 0; // wait for another start bit...
irmp_pulse_time = 0;
irmp_pause_time = 0;
}
}
else
{
irmp_pause_time++; // increment counter
#if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
if (irmp_param.protocol == IRMP_SIRCS_PROTOCOL && // Sony has a variable number of bits:
irmp_pause_time > SIRCS_PAUSE_LEN_MAX && // minimum is 12
irmp_bit >= 12 - 1) // pause too long?
{ // yes, break and close this frame
irmp_param.complete_len = irmp_bit + 1; // set new complete length
got_light = TRUE; // this is a lie, but helps (generates stop bit)
irmp_tmp_address |= (irmp_bit - SIRCS_MINIMUM_DATA_LEN + 1) << 8; // new: store number of additional bits in upper byte of address!
irmp_param.command_end = irmp_param.command_offset + irmp_bit + 1; // correct command length
irmp_pause_time = SIRCS_PAUSE_LEN_MAX - 1; // correct pause length
}
else
#endif
#if IRMP_SUPPORT_FAN_PROTOCOL == 1
if (irmp_param.protocol == IRMP_FAN_PROTOCOL && // FAN has no stop bit.
irmp_bit >= FAN_COMPLETE_DATA_LEN - 1) // last bit in frame
{ // yes, break and close this frame
if (irmp_pulse_time <= FAN_0_PULSE_LEN_MAX && irmp_pause_time >= FAN_0_PAUSE_LEN_MIN)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Generating virtual stop bit\n");
#endif // ANALYZE
got_light = TRUE; // this is a lie, but helps (generates stop bit)
}
else if (irmp_pulse_time >= FAN_1_PULSE_LEN_MIN && irmp_pause_time >= FAN_1_PAUSE_LEN_MIN)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Generating virtual stop bit\n");
#endif // ANALYZE
got_light = TRUE; // this is a lie, but helps (generates stop bit)
}
}
else
#endif
#if IRMP_SUPPORT_SERIAL == 1
// NETBOX generates no stop bit, here is the timeout condition:
if ((irmp_param.flags & IRMP_PARAM_FLAG_IS_SERIAL) && irmp_param.protocol == IRMP_NETBOX_PROTOCOL &&
irmp_pause_time >= NETBOX_PULSE_LEN * (NETBOX_COMPLETE_DATA_LEN - irmp_bit))
{
got_light = TRUE; // this is a lie, but helps (generates stop bit)
}
else
#endif
#if IRMP_SUPPORT_GRUNDIG_NOKIA_IR60_PROTOCOL == 1
if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL && !irmp_param.stop_bit)
{
if (irmp_pause_time > IR60_TIMEOUT_LEN && (irmp_bit == 5 || irmp_bit == 6))
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to IR60 protocol\n");
#endif // ANALYZE
got_light = TRUE; // this is a lie, but generates a stop bit ;-)
irmp_param.stop_bit = TRUE; // set flag
irmp_param.protocol = IRMP_IR60_PROTOCOL; // change protocol
irmp_param.complete_len = IR60_COMPLETE_DATA_LEN; // correct complete len
irmp_param.address_offset = IR60_ADDRESS_OFFSET;
irmp_param.address_end = IR60_ADDRESS_OFFSET + IR60_ADDRESS_LEN;
irmp_param.command_offset = IR60_COMMAND_OFFSET;
irmp_param.command_end = IR60_COMMAND_OFFSET + IR60_COMMAND_LEN;
irmp_tmp_command <<= 1;
irmp_tmp_command |= first_bit;
}
else if (irmp_pause_time >= 2 * irmp_param.pause_1_len_max && irmp_bit >= GRUNDIG_COMPLETE_DATA_LEN - 2)
{ // special manchester decoder
irmp_param.complete_len = GRUNDIG_COMPLETE_DATA_LEN; // correct complete len
got_light = TRUE; // this is a lie, but generates a stop bit ;-)
irmp_param.stop_bit = TRUE; // set flag
}
else if (irmp_bit >= GRUNDIG_COMPLETE_DATA_LEN)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to NOKIA protocol, irmp_bit = %d\n", irmp_bit);
#endif // ANALYZE
irmp_param.protocol = IRMP_NOKIA_PROTOCOL; // change protocol
irmp_param.address_offset = NOKIA_ADDRESS_OFFSET;
irmp_param.address_end = NOKIA_ADDRESS_OFFSET + NOKIA_ADDRESS_LEN;
irmp_param.command_offset = NOKIA_COMMAND_OFFSET;
irmp_param.command_end = NOKIA_COMMAND_OFFSET + NOKIA_COMMAND_LEN;
if (irmp_tmp_command & 0x300)
{
irmp_tmp_address = (irmp_tmp_command >> 8);
irmp_tmp_command &= 0xFF;
}
}
}
else
#endif
#if IRMP_SUPPORT_SIEMENS_OR_RUWIDO_PROTOCOL == 1
if (irmp_param.protocol == IRMP_RUWIDO_PROTOCOL && !irmp_param.stop_bit)
{
if (irmp_pause_time >= 2 * irmp_param.pause_1_len_max && irmp_bit >= RUWIDO_COMPLETE_DATA_LEN - 2)
{ // special manchester decoder
irmp_param.complete_len = RUWIDO_COMPLETE_DATA_LEN; // correct complete len
got_light = TRUE; // this is a lie, but generates a stop bit ;-)
irmp_param.stop_bit = TRUE; // set flag
}
else if (irmp_bit >= RUWIDO_COMPLETE_DATA_LEN)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to SIEMENS protocol\n");
#endif // ANALYZE
irmp_param.protocol = IRMP_SIEMENS_PROTOCOL; // change protocol
irmp_param.address_offset = SIEMENS_ADDRESS_OFFSET;
irmp_param.address_end = SIEMENS_ADDRESS_OFFSET + SIEMENS_ADDRESS_LEN;
irmp_param.command_offset = SIEMENS_COMMAND_OFFSET;
irmp_param.command_end = SIEMENS_COMMAND_OFFSET + SIEMENS_COMMAND_LEN;
// 76543210
// RUWIDO: AAAAAAAAACCCCCCCp
// SIEMENS: AAAAAAAAAAACCCCCCCCCCp
irmp_tmp_address <<= 2;
irmp_tmp_address |= (irmp_tmp_command >> 6);
irmp_tmp_command &= 0x003F;
// irmp_tmp_command <<= 4;
irmp_tmp_command |= last_value;
}
}
else
#endif
#if IRMP_SUPPORT_ROOMBA_PROTOCOL == 1
if (irmp_param.protocol == IRMP_ROOMBA_PROTOCOL && // Roomba has no stop bit
irmp_bit >= ROOMBA_COMPLETE_DATA_LEN - 1) // it's the last data bit...
{ // break and close this frame
if (irmp_pulse_time >= ROOMBA_1_PULSE_LEN_MIN && irmp_pulse_time <= ROOMBA_1_PULSE_LEN_MAX)
{
irmp_pause_time = ROOMBA_1_PAUSE_LEN_EXACT;
}
else if (irmp_pulse_time >= ROOMBA_0_PULSE_LEN_MIN && irmp_pulse_time <= ROOMBA_0_PULSE_LEN_MAX)
{
irmp_pause_time = ROOMBA_0_PAUSE_LEN;
}
got_light = TRUE; // this is a lie, but helps (generates stop bit)
}
else
#endif
#if IRMP_SUPPORT_MANCHESTER == 1
if ((irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER) &&
irmp_pause_time >= 2 * irmp_param.pause_1_len_max && irmp_bit >= irmp_param.complete_len - 2 && !irmp_param.stop_bit)
{ // special manchester decoder
got_light = TRUE; // this is a lie, but generates a stop bit ;-)
irmp_param.stop_bit = TRUE; // set flag
}
else
#endif // IRMP_SUPPORT_MANCHESTER == 1
if (irmp_pause_time > IRMP_TIMEOUT_LEN) // timeout?
{ // yes...
if (irmp_bit == irmp_param.complete_len - 1 && irmp_param.stop_bit == 0)
{
irmp_bit++;
}
#if IRMP_SUPPORT_JVC_PROTOCOL == 1
else if (irmp_param.protocol == IRMP_NEC_PROTOCOL && (irmp_bit == 16 || irmp_bit == 17)) // it was a JVC stop bit
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to JVC protocol, irmp_bit = %d\n", irmp_bit);
#endif // ANALYZE
irmp_param.stop_bit = TRUE; // set flag
irmp_param.protocol = IRMP_JVC_PROTOCOL; // switch protocol
irmp_param.complete_len = irmp_bit; // patch length: 16 or 17
irmp_tmp_command = (irmp_tmp_address >> 4); // set command: upper 12 bits are command bits
irmp_tmp_address = irmp_tmp_address & 0x000F; // lower 4 bits are address bits
irmp_start_bit_detected = 1; // tricky: don't wait for another start bit...
}
#endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
#if IRMP_SUPPORT_LGAIR_PROTOCOL == 1
else if (irmp_param.protocol == IRMP_NEC_PROTOCOL && (irmp_bit == 28 || irmp_bit == 29)) // it was a LGAIR stop bit
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to LGAIR protocol, irmp_bit = %d\n", irmp_bit);
#endif // ANALYZE
irmp_param.stop_bit = TRUE; // set flag
irmp_param.protocol = IRMP_LGAIR_PROTOCOL; // switch protocol
irmp_param.complete_len = irmp_bit; // patch length: 16 or 17
irmp_tmp_command = irmp_lgair_command; // set command: upper 8 bits are command bits
irmp_tmp_address = irmp_lgair_address; // lower 4 bits are address bits
irmp_start_bit_detected = 1; // tricky: don't wait for another start bit...
}
#endif // IRMP_SUPPORT_LGAIR_PROTOCOL == 1
#if IRMP_SUPPORT_NEC42_PROTOCOL == 1
#if IRMP_SUPPORT_NEC_PROTOCOL == 1
else if (irmp_param.protocol == IRMP_NEC42_PROTOCOL && irmp_bit == 32) // it was a NEC stop bit
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to NEC protocol\n");
#endif // ANALYZE
irmp_param.stop_bit = TRUE; // set flag
irmp_param.protocol = IRMP_NEC_PROTOCOL; // switch protocol
irmp_param.complete_len = irmp_bit; // patch length: 16 or 17
// 0123456789ABC0123456789ABC0123456701234567
// NEC42: AAAAAAAAAAAAAaaaaaaaaaaaaaCCCCCCCCcccccccc
// NEC: AAAAAAAAaaaaaaaaCCCCCCCCcccccccc
irmp_tmp_address |= (irmp_tmp_address2 & 0x0007) << 13; // fm 2012-02-13: 12 -> 13
irmp_tmp_command = (irmp_tmp_address2 >> 3) | (irmp_tmp_command << 10);
}
#endif // IRMP_SUPPORT_NEC_PROTOCOL == 1
#if IRMP_SUPPORT_LGAIR_PROTOCOL == 1
else if (irmp_param.protocol == IRMP_NEC42_PROTOCOL && irmp_bit == 28) // it was a NEC stop bit
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to LGAIR protocol\n");
#endif // ANALYZE
irmp_param.stop_bit = TRUE; // set flag
irmp_param.protocol = IRMP_LGAIR_PROTOCOL; // switch protocol
irmp_param.complete_len = irmp_bit; // patch length: 16 or 17
irmp_tmp_address = irmp_lgair_address;
irmp_tmp_command = irmp_lgair_command;
}
#endif // IRMP_SUPPORT_LGAIR_PROTOCOL == 1
#if IRMP_SUPPORT_JVC_PROTOCOL == 1
else if (irmp_param.protocol == IRMP_NEC42_PROTOCOL && (irmp_bit == 16 || irmp_bit == 17)) // it was a JVC stop bit
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to JVC protocol, irmp_bit = %d\n", irmp_bit);
#endif // ANALYZE
irmp_param.stop_bit = TRUE; // set flag
irmp_param.protocol = IRMP_JVC_PROTOCOL; // switch protocol
irmp_param.complete_len = irmp_bit; // patch length: 16 or 17
// 0123456789ABC0123456789ABC0123456701234567
// NEC42: AAAAAAAAAAAAAaaaaaaaaaaaaaCCCCCCCCcccccccc
// JVC: AAAACCCCCCCCCCCC
irmp_tmp_command = (irmp_tmp_address >> 4) | (irmp_tmp_address2 << 9); // set command: upper 12 bits are command bits
irmp_tmp_address = irmp_tmp_address & 0x000F; // lower 4 bits are address bits
}
#endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
#endif // IRMP_SUPPORT_NEC42_PROTOCOL == 1
#if IRMP_SUPPORT_SAMSUNG48_PROTOCOL == 1
else if (irmp_param.protocol == IRMP_SAMSUNG48_PROTOCOL && irmp_bit == 32) // it was a SAMSUNG32 stop bit
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to SAMSUNG32 protocol\n");
#endif // ANALYZE
irmp_param.protocol = IRMP_SAMSUNG32_PROTOCOL;
irmp_param.command_offset = SAMSUNG32_COMMAND_OFFSET;
irmp_param.command_end = SAMSUNG32_COMMAND_OFFSET + SAMSUNG32_COMMAND_LEN;
irmp_param.complete_len = SAMSUNG32_COMPLETE_DATA_LEN;
}
#endif // IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
#if IRMP_SUPPORT_RCMM_PROTOCOL == 1
else if (irmp_param.protocol == IRMP_RCMM32_PROTOCOL && (irmp_bit == 12 || irmp_bit == 24)) // it was a RCMM stop bit
{
if (irmp_bit == 12)
{
irmp_tmp_command = (irmp_tmp_address & 0xFF); // set command: lower 8 bits are command bits
irmp_tmp_address >>= 8; // upper 4 bits are address bits
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to RCMM12 protocol, irmp_bit = %d\n", irmp_bit);
#endif // ANALYZE
irmp_param.protocol = IRMP_RCMM12_PROTOCOL; // switch protocol
}
else // if ((irmp_bit == 24)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to RCMM24 protocol, irmp_bit = %d\n", irmp_bit);
#endif // ANALYZE
irmp_param.protocol = IRMP_RCMM24_PROTOCOL; // switch protocol
}
irmp_param.stop_bit = TRUE; // set flag
irmp_param.complete_len = irmp_bit; // patch length
}
#endif // IRMP_SUPPORT_RCMM_PROTOCOL == 1
#if IRMP_SUPPORT_TECHNICS_PROTOCOL == 1
else if (irmp_param.protocol == IRMP_MATSUSHITA_PROTOCOL && irmp_bit == 22) // it was a TECHNICS stop bit
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to TECHNICS protocol, irmp_bit = %d\n", irmp_bit);
#endif // ANALYZE
// Situation:
// The first 12 bits have been stored in irmp_tmp_command (LSB first)
// The following 10 bits have been stored in irmp_tmp_address (LSB first)
// The code of TECHNICS is:
// cccccccccccCCCCCCCCCCC (11 times c and 11 times C)
// ccccccccccccaaaaaaaaaa
// where C is inverted value of c
irmp_tmp_address <<= 1;
if (irmp_tmp_command & (1<<11))
{
irmp_tmp_address |= 1;
irmp_tmp_command &= ~(1<<11);
}
if (irmp_tmp_command == ((~irmp_tmp_address) & 0x07FF))
{
irmp_tmp_address = 0;
irmp_param.protocol = IRMP_TECHNICS_PROTOCOL; // switch protocol
irmp_param.complete_len = irmp_bit; // patch length
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF ("error 8: TECHNICS frame error\n");
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
irmp_start_bit_detected = 0; // wait for another start bit...
irmp_pulse_time = 0;
irmp_pause_time = 0;
}
}
#endif // IRMP_SUPPORT_TECHNICS_PROTOCOL == 1
else
{
#ifdef ANALYZE
ANALYZE_PRINTF ("error 2: pause %d after data bit %d too long\n", irmp_pause_time, irmp_bit);
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
irmp_start_bit_detected = 0; // wait for another start bit...
irmp_pulse_time = 0;
irmp_pause_time = 0;
}
}
}
}
else
{ // got light now!
got_light = TRUE;
}
if (got_light)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms [bit %2d: pulse = %3d, pause = %3d] ", (double) (time_counter * 1000) / F_INTERRUPTS, irmp_bit, irmp_pulse_time, irmp_pause_time);
#endif // ANALYZE
#if IRMP_SUPPORT_MANCHESTER == 1
if ((irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER)) // Manchester
{
#if 1
if (irmp_pulse_time > irmp_param.pulse_1_len_max /* && irmp_pulse_time <= 2 * irmp_param.pulse_1_len_max */)
#else // better, but some IR-RCs use asymmetric timings :-/
if (irmp_pulse_time > irmp_param.pulse_1_len_max && irmp_pulse_time <= 2 * irmp_param.pulse_1_len_max &&
irmp_pause_time <= 2 * irmp_param.pause_1_len_max)
#endif
{
#if IRMP_SUPPORT_RC6_PROTOCOL == 1
if (irmp_param.protocol == IRMP_RC6_PROTOCOL && irmp_bit == 4 && irmp_pulse_time > RC6_TOGGLE_BIT_LEN_MIN) // RC6 toggle bit
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('T');
#endif // ANALYZE
if (irmp_param.complete_len == RC6_COMPLETE_DATA_LEN_LONG) // RC6 mode 6A
{
irmp_store_bit (1);
last_value = 1;
}
else // RC6 mode 0
{
irmp_store_bit (0);
last_value = 0;
}
#ifdef ANALYZE
ANALYZE_NEWLINE ();
#endif // ANALYZE
}
else
#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? '0' : '1');
#endif // ANALYZE
irmp_store_bit ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 0 : 1 );
#if IRMP_SUPPORT_RC6_PROTOCOL == 1
if (irmp_param.protocol == IRMP_RC6_PROTOCOL && irmp_bit == 4 && irmp_pulse_time > RC6_TOGGLE_BIT_LEN_MIN) // RC6 toggle bit
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('T');
#endif // ANALYZE
irmp_store_bit (1);
if (irmp_pause_time > 2 * irmp_param.pause_1_len_max)
{
last_value = 0;
}
else
{
last_value = 1;
}
#ifdef ANALYZE
ANALYZE_NEWLINE ();
#endif // ANALYZE
}
else
#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? '1' : '0');
#endif // ANALYZE
irmp_store_bit ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 1 : 0 );
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
if (! irmp_param2.protocol)
#endif
{
#ifdef ANALYZE
ANALYZE_NEWLINE ();
#endif // ANALYZE
}
last_value = (irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 1 : 0;
}
}
}
else if (irmp_pulse_time >= irmp_param.pulse_1_len_min && irmp_pulse_time <= irmp_param.pulse_1_len_max
/* && irmp_pause_time <= 2 * irmp_param.pause_1_len_max */)
{
uint_fast8_t manchester_value;
if (last_pause > irmp_param.pause_1_len_max && last_pause <= 2 * irmp_param.pause_1_len_max)
{
manchester_value = last_value ? 0 : 1;
last_value = manchester_value;
}
else
{
manchester_value = last_value;
}
#ifdef ANALYZE
ANALYZE_PUTCHAR (manchester_value + '0');
#endif // ANALYZE
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
if (! irmp_param2.protocol)
#endif
{
#ifdef ANALYZE
ANALYZE_NEWLINE ();
#endif // ANALYZE
}
#if IRMP_SUPPORT_RC6_PROTOCOL == 1
if (irmp_param.protocol == IRMP_RC6_PROTOCOL && irmp_bit == 1 && manchester_value == 1) // RC6 mode != 0 ???
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to RC6A protocol\n");
#endif // ANALYZE
irmp_param.complete_len = RC6_COMPLETE_DATA_LEN_LONG;
irmp_param.address_offset = 5;
irmp_param.address_end = irmp_param.address_offset + 15;
irmp_param.command_offset = irmp_param.address_end + 1; // skip 1 system bit, changes like a toggle bit
irmp_param.command_end = irmp_param.command_offset + 16 - 1;
irmp_tmp_address = 0;
}
#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
irmp_store_bit (manchester_value);
}
else
{
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_FDC_PROTOCOL == 1
if (irmp_param2.protocol == IRMP_FDC_PROTOCOL &&
irmp_pulse_time >= FDC_PULSE_LEN_MIN && irmp_pulse_time <= FDC_PULSE_LEN_MAX &&
((irmp_pause_time >= FDC_1_PAUSE_LEN_MIN && irmp_pause_time <= FDC_1_PAUSE_LEN_MAX) ||
(irmp_pause_time >= FDC_0_PAUSE_LEN_MIN && irmp_pause_time <= FDC_0_PAUSE_LEN_MAX)))
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('?');
#endif // ANALYZE
irmp_param.protocol = 0; // switch to FDC, see below
}
else
#endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_RCCAR_PROTOCOL == 1
if (irmp_param2.protocol == IRMP_RCCAR_PROTOCOL &&
irmp_pulse_time >= RCCAR_PULSE_LEN_MIN && irmp_pulse_time <= RCCAR_PULSE_LEN_MAX &&
((irmp_pause_time >= RCCAR_1_PAUSE_LEN_MIN && irmp_pause_time <= RCCAR_1_PAUSE_LEN_MAX) ||
(irmp_pause_time >= RCCAR_0_PAUSE_LEN_MIN && irmp_pause_time <= RCCAR_0_PAUSE_LEN_MAX)))
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('?');
#endif // ANALYZE
irmp_param.protocol = 0; // switch to RCCAR, see below
}
else
#endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('?');
ANALYZE_NEWLINE ();
ANALYZE_PRINTF ("error 3 manchester: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
irmp_start_bit_detected = 0; // reset flags and wait for next start bit
irmp_pause_time = 0;
}
}
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_FDC_PROTOCOL == 1
if (irmp_param2.protocol == IRMP_FDC_PROTOCOL && irmp_pulse_time >= FDC_PULSE_LEN_MIN && irmp_pulse_time <= FDC_PULSE_LEN_MAX)
{
if (irmp_pause_time >= FDC_1_PAUSE_LEN_MIN && irmp_pause_time <= FDC_1_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF (" 1 (FDC)\n");
#endif // ANALYZE
irmp_store_bit2 (1);
}
else if (irmp_pause_time >= FDC_0_PAUSE_LEN_MIN && irmp_pause_time <= FDC_0_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF (" 0 (FDC)\n");
#endif // ANALYZE
irmp_store_bit2 (0);
}
if (! irmp_param.protocol)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to FDC protocol\n");
#endif // ANALYZE
memcpy (&irmp_param, &irmp_param2, sizeof (IRMP_PARAMETER));
irmp_param2.protocol = 0;
irmp_tmp_address = irmp_tmp_address2;
irmp_tmp_command = irmp_tmp_command2;
}
}
#endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_RCCAR_PROTOCOL == 1
if (irmp_param2.protocol == IRMP_RCCAR_PROTOCOL && irmp_pulse_time >= RCCAR_PULSE_LEN_MIN && irmp_pulse_time <= RCCAR_PULSE_LEN_MAX)
{
if (irmp_pause_time >= RCCAR_1_PAUSE_LEN_MIN && irmp_pause_time <= RCCAR_1_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF (" 1 (RCCAR)\n");
#endif // ANALYZE
irmp_store_bit2 (1);
}
else if (irmp_pause_time >= RCCAR_0_PAUSE_LEN_MIN && irmp_pause_time <= RCCAR_0_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF (" 0 (RCCAR)\n");
#endif // ANALYZE
irmp_store_bit2 (0);
}
if (! irmp_param.protocol)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to RCCAR protocol\n");
#endif // ANALYZE
memcpy (&irmp_param, &irmp_param2, sizeof (IRMP_PARAMETER));
irmp_param2.protocol = 0;
irmp_tmp_address = irmp_tmp_address2;
irmp_tmp_command = irmp_tmp_command2;
}
}
#endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
last_pause = irmp_pause_time;
wait_for_space = 0;
}
else
#endif // IRMP_SUPPORT_MANCHESTER == 1
#if IRMP_SUPPORT_SERIAL == 1
if (irmp_param.flags & IRMP_PARAM_FLAG_IS_SERIAL)
{
while (irmp_bit < irmp_param.complete_len && irmp_pulse_time > irmp_param.pulse_1_len_max)
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('1');
#endif // ANALYZE
irmp_store_bit (1);
if (irmp_pulse_time >= irmp_param.pulse_1_len_min)
{
irmp_pulse_time -= irmp_param.pulse_1_len_min;
}
else
{
irmp_pulse_time = 0;
}
}
while (irmp_bit < irmp_param.complete_len && irmp_pause_time > irmp_param.pause_1_len_max)
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('0');
#endif // ANALYZE
irmp_store_bit (0);
if (irmp_pause_time >= irmp_param.pause_1_len_min)
{
irmp_pause_time -= irmp_param.pause_1_len_min;
}
else
{
irmp_pause_time = 0;
}
}
#ifdef ANALYZE
ANALYZE_NEWLINE ();
#endif // ANALYZE
wait_for_space = 0;
}
else
#endif // IRMP_SUPPORT_SERIAL == 1
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
if (irmp_param.protocol == IRMP_SAMSUNG_PROTOCOL && irmp_bit == 16) // Samsung: 16th bit
{
if (irmp_pulse_time >= SAMSUNG_PULSE_LEN_MIN && irmp_pulse_time <= SAMSUNG_PULSE_LEN_MAX &&
irmp_pause_time >= SAMSUNG_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= SAMSUNG_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("SYNC\n");
#endif // ANALYZE
wait_for_space = 0;
irmp_bit++;
}
else if (irmp_pulse_time >= SAMSUNG_PULSE_LEN_MIN && irmp_pulse_time <= SAMSUNG_PULSE_LEN_MAX)
{
#if IRMP_SUPPORT_SAMSUNG48_PROTOCOL == 1
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to SAMSUNG48 protocol ");
#endif // ANALYZE
irmp_param.protocol = IRMP_SAMSUNG48_PROTOCOL;
irmp_param.command_offset = SAMSUNG48_COMMAND_OFFSET;
irmp_param.command_end = SAMSUNG48_COMMAND_OFFSET + SAMSUNG48_COMMAND_LEN;
irmp_param.complete_len = SAMSUNG48_COMPLETE_DATA_LEN;
#else
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to SAMSUNG32 protocol ");
#endif // ANALYZE
irmp_param.protocol = IRMP_SAMSUNG32_PROTOCOL;
irmp_param.command_offset = SAMSUNG32_COMMAND_OFFSET;
irmp_param.command_end = SAMSUNG32_COMMAND_OFFSET + SAMSUNG32_COMMAND_LEN;
irmp_param.complete_len = SAMSUNG32_COMPLETE_DATA_LEN;
#endif
if (irmp_pause_time >= SAMSUNG_1_PAUSE_LEN_MIN && irmp_pause_time <= SAMSUNG_1_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('1');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (1);
wait_for_space = 0;
}
else
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('0');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (0);
wait_for_space = 0;
}
}
else
{ // timing incorrect!
#ifdef ANALYZE
ANALYZE_PRINTF ("error 3 Samsung: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
irmp_start_bit_detected = 0; // reset flags and wait for next start bit
irmp_pause_time = 0;
}
}
else
#endif // IRMP_SUPPORT_SAMSUNG_PROTOCOL
#if IRMP_SUPPORT_NEC16_PROTOCOL
#if IRMP_SUPPORT_NEC42_PROTOCOL == 1
if (irmp_param.protocol == IRMP_NEC42_PROTOCOL &&
#else // IRMP_SUPPORT_NEC_PROTOCOL instead
if (irmp_param.protocol == IRMP_NEC_PROTOCOL &&
#endif // IRMP_SUPPORT_NEC42_PROTOCOL == 1
irmp_bit == 8 && irmp_pause_time >= NEC_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= NEC_START_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Switching to NEC16 protocol\n");
#endif // ANALYZE
irmp_param.protocol = IRMP_NEC16_PROTOCOL;
irmp_param.address_offset = NEC16_ADDRESS_OFFSET;
irmp_param.address_end = NEC16_ADDRESS_OFFSET + NEC16_ADDRESS_LEN;
irmp_param.command_offset = NEC16_COMMAND_OFFSET;
irmp_param.command_end = NEC16_COMMAND_OFFSET + NEC16_COMMAND_LEN;
irmp_param.complete_len = NEC16_COMPLETE_DATA_LEN;
wait_for_space = 0;
}
else
#endif // IRMP_SUPPORT_NEC16_PROTOCOL
#if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
if (irmp_param.protocol == IRMP_BANG_OLUFSEN_PROTOCOL)
{
if (irmp_pulse_time >= BANG_OLUFSEN_PULSE_LEN_MIN && irmp_pulse_time <= BANG_OLUFSEN_PULSE_LEN_MAX)
{
if (irmp_bit == 1) // Bang & Olufsen: 3rd bit
{
if (irmp_pause_time >= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("3rd start bit\n");
#endif // ANALYZE
wait_for_space = 0;
irmp_bit++;
}
else
{ // timing incorrect!
#ifdef ANALYZE
ANALYZE_PRINTF ("error 3a B&O: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
irmp_start_bit_detected = 0; // reset flags and wait for next start bit
irmp_pause_time = 0;
}
}
else if (irmp_bit == 19) // Bang & Olufsen: trailer bit
{
if (irmp_pause_time >= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("trailer bit\n");
#endif // ANALYZE
wait_for_space = 0;
irmp_bit++;
}
else
{ // timing incorrect!
#ifdef ANALYZE
ANALYZE_PRINTF ("error 3b B&O: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
irmp_start_bit_detected = 0; // reset flags and wait for next start bit
irmp_pause_time = 0;
}
}
else
{
if (irmp_pause_time >= BANG_OLUFSEN_1_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_1_PAUSE_LEN_MAX)
{ // pulse & pause timings correct for "1"?
#ifdef ANALYZE
ANALYZE_PUTCHAR ('1');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (1);
last_value = 1;
wait_for_space = 0;
}
else if (irmp_pause_time >= BANG_OLUFSEN_0_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_0_PAUSE_LEN_MAX)
{ // pulse & pause timings correct for "0"?
#ifdef ANALYZE
ANALYZE_PUTCHAR ('0');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (0);
last_value = 0;
wait_for_space = 0;
}
else if (irmp_pause_time >= BANG_OLUFSEN_R_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_R_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PUTCHAR (last_value + '0');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (last_value);
wait_for_space = 0;
}
else
{ // timing incorrect!
#ifdef ANALYZE
ANALYZE_PRINTF ("error 3c B&O: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
irmp_start_bit_detected = 0; // reset flags and wait for next start bit
irmp_pause_time = 0;
}
}
}
else
{ // timing incorrect!
#ifdef ANALYZE
ANALYZE_PRINTF ("error 3d B&O: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
irmp_start_bit_detected = 0; // reset flags and wait for next start bit
irmp_pause_time = 0;
}
}
else
#endif // IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL
#if IRMP_SUPPORT_RCMM_PROTOCOL == 1
if (irmp_param.protocol == IRMP_RCMM32_PROTOCOL)
{
if (irmp_pause_time >= RCMM32_BIT_00_PAUSE_LEN_MIN && irmp_pause_time <= RCMM32_BIT_00_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('0');
ANALYZE_PUTCHAR ('0');
#endif // ANALYZE
irmp_store_bit (0);
irmp_store_bit (0);
}
else if (irmp_pause_time >= RCMM32_BIT_01_PAUSE_LEN_MIN && irmp_pause_time <= RCMM32_BIT_01_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('0');
ANALYZE_PUTCHAR ('1');
#endif // ANALYZE
irmp_store_bit (0);
irmp_store_bit (1);
}
else if (irmp_pause_time >= RCMM32_BIT_10_PAUSE_LEN_MIN && irmp_pause_time <= RCMM32_BIT_10_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('1');
ANALYZE_PUTCHAR ('0');
#endif // ANALYZE
irmp_store_bit (1);
irmp_store_bit (0);
}
else if (irmp_pause_time >= RCMM32_BIT_11_PAUSE_LEN_MIN && irmp_pause_time <= RCMM32_BIT_11_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('1');
ANALYZE_PUTCHAR ('1');
#endif // ANALYZE
irmp_store_bit (1);
irmp_store_bit (1);
}
#ifdef ANALYZE
ANALYZE_PRINTF ("\n");
#endif // ANALYZE
wait_for_space = 0;
}
else
#endif
if (irmp_pulse_time >= irmp_param.pulse_1_len_min && irmp_pulse_time <= irmp_param.pulse_1_len_max &&
irmp_pause_time >= irmp_param.pause_1_len_min && irmp_pause_time <= irmp_param.pause_1_len_max)
{ // pulse & pause timings correct for "1"?
#ifdef ANALYZE
ANALYZE_PUTCHAR ('1');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (1);
wait_for_space = 0;
}
else if (irmp_pulse_time >= irmp_param.pulse_0_len_min && irmp_pulse_time <= irmp_param.pulse_0_len_max &&
irmp_pause_time >= irmp_param.pause_0_len_min && irmp_pause_time <= irmp_param.pause_0_len_max)
{ // pulse & pause timings correct for "0"?
#ifdef ANALYZE
ANALYZE_PUTCHAR ('0');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (0);
wait_for_space = 0;
}
else
#if IRMP_SUPPORT_KATHREIN_PROTOCOL
if (irmp_param.protocol == IRMP_KATHREIN_PROTOCOL &&
irmp_pulse_time >= KATHREIN_1_PULSE_LEN_MIN && irmp_pulse_time <= KATHREIN_1_PULSE_LEN_MAX &&
(((irmp_bit == 8 || irmp_bit == 6) &&
irmp_pause_time >= KATHREIN_SYNC_BIT_PAUSE_LEN_MIN && irmp_pause_time <= KATHREIN_SYNC_BIT_PAUSE_LEN_MAX) ||
(irmp_bit == 12 &&
irmp_pause_time >= KATHREIN_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= KATHREIN_START_BIT_PAUSE_LEN_MAX)))
{
if (irmp_bit == 8)
{
irmp_bit++;
#ifdef ANALYZE
ANALYZE_PUTCHAR ('S');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_tmp_command <<= 1;
}
else
{
#ifdef ANALYZE
ANALYZE_PUTCHAR ('S');
ANALYZE_NEWLINE ();
#endif // ANALYZE
irmp_store_bit (1);
}
wait_for_space = 0;
}
else
#endif // IRMP_SUPPORT_KATHREIN_PROTOCOL
{ // timing incorrect!
#ifdef ANALYZE
ANALYZE_PRINTF ("error 3: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
irmp_start_bit_detected = 0; // reset flags and wait for next start bit
irmp_pause_time = 0;
}
irmp_pulse_time = 1; // set counter to 1, not 0
}
}
else
{ // counting the pulse length ...
if (! irmp_input) // still light?
{ // yes...
irmp_pulse_time++; // increment counter
}
else
{ // now it's dark!
wait_for_space = 1; // let's count the time (see above)
irmp_pause_time = 1; // set pause counter to 1, not 0
}
}
if (irmp_start_bit_detected && irmp_bit == irmp_param.complete_len && irmp_param.stop_bit == 0) // enough bits received?
{
if (last_irmp_command == irmp_tmp_command && key_repetition_len < AUTO_FRAME_REPETITION_LEN)
{
repetition_frame_number++;
}
else
{
repetition_frame_number = 0;
}
#if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
// if SIRCS protocol and the code will be repeated within 50 ms, we will ignore 2nd and 3rd repetition frame
if (irmp_param.protocol == IRMP_SIRCS_PROTOCOL && (repetition_frame_number == 1 || repetition_frame_number == 2))
{
#ifdef ANALYZE
ANALYZE_PRINTF ("code skipped: SIRCS auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number + 1, key_repetition_len, AUTO_FRAME_REPETITION_LEN);
#endif // ANALYZE
key_repetition_len = 0;
}
else
#endif
#if IRMP_SUPPORT_ORTEK_PROTOCOL == 1
// if ORTEK protocol and the code will be repeated within 50 ms, we will ignore 2nd repetition frame
if (irmp_param.protocol == IRMP_ORTEK_PROTOCOL && repetition_frame_number == 1)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("code skipped: ORTEK auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number + 1, key_repetition_len, AUTO_FRAME_REPETITION_LEN);
#endif // ANALYZE
key_repetition_len = 0;
}
else
#endif
#if 0 && IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1 // fm 2015-12-02: don't ignore every 2nd frame
// if KASEIKYO protocol and the code will be repeated within 50 ms, we will ignore 2nd repetition frame
if (irmp_param.protocol == IRMP_KASEIKYO_PROTOCOL && repetition_frame_number == 1)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("code skipped: KASEIKYO auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number + 1, key_repetition_len, AUTO_FRAME_REPETITION_LEN);
#endif // ANALYZE
key_repetition_len = 0;
}
else
#endif
#if 0 && IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1 // fm 2015-12-02: don't ignore every 2nd frame
// if SAMSUNG32 or SAMSUNG48 protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
if ((irmp_param.protocol == IRMP_SAMSUNG32_PROTOCOL || irmp_param.protocol == IRMP_SAMSUNG48_PROTOCOL) && (repetition_frame_number & 0x01))
{
#ifdef ANALYZE
ANALYZE_PRINTF ("code skipped: SAMSUNG32/SAMSUNG48 auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number + 1, key_repetition_len, AUTO_FRAME_REPETITION_LEN);
#endif // ANALYZE
key_repetition_len = 0;
}
else
#endif
#if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
// if NUBERT protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
if (irmp_param.protocol == IRMP_NUBERT_PROTOCOL && (repetition_frame_number & 0x01))
{
#ifdef ANALYZE
ANALYZE_PRINTF ("code skipped: NUBERT auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number + 1, key_repetition_len, AUTO_FRAME_REPETITION_LEN);
#endif // ANALYZE
key_repetition_len = 0;
}
else
#endif
#if IRMP_SUPPORT_SPEAKER_PROTOCOL == 1
// if SPEAKER protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
if (irmp_param.protocol == IRMP_SPEAKER_PROTOCOL && (repetition_frame_number & 0x01))
{
#ifdef ANALYZE
ANALYZE_PRINTF ("code skipped: SPEAKER auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number + 1, key_repetition_len, AUTO_FRAME_REPETITION_LEN);
#endif // ANALYZE
key_repetition_len = 0;
}
else
#endif
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms code detected, length = %d\n", (double) (time_counter * 1000) / F_INTERRUPTS, irmp_bit);
#endif // ANALYZE
irmp_ir_detected = TRUE;
#if IRMP_SUPPORT_DENON_PROTOCOL == 1
if (irmp_param.protocol == IRMP_DENON_PROTOCOL)
{ // check for repetition frame
if ((~irmp_tmp_command & 0x3FF) == last_irmp_denon_command) // command bits must be inverted
{
irmp_tmp_command = last_irmp_denon_command; // use command received before!
last_irmp_denon_command = 0;
irmp_protocol = irmp_param.protocol; // store protocol
irmp_address = irmp_tmp_address; // store address
irmp_command = irmp_tmp_command; // store command
}
else
{
if ((irmp_tmp_command & 0x01) == 0x00)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms info Denon: waiting for inverted command repetition\n", (double) (time_counter * 1000) / F_INTERRUPTS);
#endif // ANALYZE
last_irmp_denon_command = irmp_tmp_command;
denon_repetition_len = 0;
irmp_ir_detected = FALSE;
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF ("%8.3fms warning Denon: got unexpected inverted command, ignoring it\n", (double) (time_counter * 1000) / F_INTERRUPTS);
#endif // ANALYZE
last_irmp_denon_command = 0;
irmp_ir_detected = FALSE;
}
}
}
else
#endif // IRMP_SUPPORT_DENON_PROTOCOL
#if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1
if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL && irmp_tmp_command == 0x01ff)
{ // Grundig start frame?
#ifdef ANALYZE
ANALYZE_PRINTF ("Detected GRUNDIG start frame, ignoring it\n");
#endif // ANALYZE
irmp_ir_detected = FALSE;
}
else
#endif // IRMP_SUPPORT_GRUNDIG_PROTOCOL
#if IRMP_SUPPORT_NOKIA_PROTOCOL == 1
if (irmp_param.protocol == IRMP_NOKIA_PROTOCOL && irmp_tmp_address == 0x00ff && irmp_tmp_command == 0x00fe)
{ // Nokia start frame?
#ifdef ANALYZE
ANALYZE_PRINTF ("Detected NOKIA start frame, ignoring it\n");
#endif // ANALYZE
irmp_ir_detected = FALSE;
}
else
#endif // IRMP_SUPPORT_NOKIA_PROTOCOL
{
#if IRMP_SUPPORT_NEC_PROTOCOL == 1
if (irmp_param.protocol == IRMP_NEC_PROTOCOL && irmp_bit == 0) // repetition frame
{
if (key_repetition_len < NEC_FRAME_REPEAT_PAUSE_LEN_MAX)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Detected NEC repetition frame, key_repetition_len = %d\n", key_repetition_len);
ANALYZE_ONLY_NORMAL_PRINTF("REPETETION FRAME ");
#endif // ANALYZE
irmp_tmp_address = last_irmp_address; // address is last address
irmp_tmp_command = last_irmp_command; // command is last command
irmp_flags |= IRMP_FLAG_REPETITION;
key_repetition_len = 0;
}
else
{
#ifdef ANALYZE
ANALYZE_PRINTF ("Detected NEC repetition frame, ignoring it: timeout occured, key_repetition_len = %d > %d\n",
key_repetition_len, NEC_FRAME_REPEAT_PAUSE_LEN_MAX);
#endif // ANALYZE
irmp_ir_detected = FALSE;
}
}
#endif // IRMP_SUPPORT_NEC_PROTOCOL
#if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
if (irmp_param.protocol == IRMP_KASEIKYO_PROTOCOL)
{
uint_fast8_t xor_value;
xor_value = (xor_check[0] & 0x0F) ^ ((xor_check[0] & 0xF0) >> 4) ^ (xor_check[1] & 0x0F) ^ ((xor_check[1] & 0xF0) >> 4);
if (xor_value != (xor_check[2] & 0x0F))
{
#ifdef ANALYZE
ANALYZE_PRINTF ("error 4: wrong XOR check for customer id: 0x%1x 0x%1x\n", xor_value, xor_check[2] & 0x0F);
#endif // ANALYZE
irmp_ir_detected = FALSE;
}
xor_value = xor_check[2] ^ xor_check[3] ^ xor_check[4];
if (xor_value != xor_check[5])
{
#ifdef ANALYZE
ANALYZE_PRINTF ("error 5: wrong XOR check for data bits: 0x%02x 0x%02x\n", xor_value, xor_check[5]);
#endif // ANALYZE
irmp_ir_detected = FALSE;
}
irmp_flags |= genre2; // write the genre2 bits into MSB of the flag byte
}
#endif // IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
#if IRMP_SUPPORT_ORTEK_PROTOCOL == 1
if (irmp_param.protocol == IRMP_ORTEK_PROTOCOL)
{
if (parity == PARITY_CHECK_FAILED)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("error 6: parity check failed\n");
#endif // ANALYZE
irmp_ir_detected = FALSE;
}
if ((irmp_tmp_address & 0x03) == 0x02)
{
#ifdef ANALYZE
ANALYZE_PRINTF ("code skipped: ORTEK end of transmission frame (key release)\n");
#endif // ANALYZE
irmp_ir_detected = FALSE;
}
irmp_tmp_address >>= 2;
}
#endif // IRMP_SUPPORT_ORTEK_PROTOCOL == 1
#if IRMP_SUPPORT_RC6_PROTOCOL == 1
if (irmp_param.protocol == IRMP_RC6_PROTOCOL && irmp_param.complete_len == RC6_COMPLETE_DATA_LEN_LONG) // RC6 mode = 6?
{
irmp_protocol = IRMP_RC6A_PROTOCOL;
}
else
#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
{
irmp_protocol = irmp_param.protocol;
}
#if IRMP_SUPPORT_FDC_PROTOCOL == 1
if (irmp_param.protocol == IRMP_FDC_PROTOCOL)
{
if (irmp_tmp_command & 0x000F) // released key?
{
irmp_tmp_command = (irmp_tmp_command >> 4) | 0x80; // yes, set bit 7
}
else
{
irmp_tmp_command >>= 4; // no, it's a pressed key
}
irmp_tmp_command |= (irmp_tmp_address << 2) & 0x0F00; // 000000CCCCAAAAAA -> 0000CCCC00000000
irmp_tmp_address &= 0x003F;
}
#endif
irmp_address = irmp_tmp_address; // store address
#if IRMP_SUPPORT_NEC_PROTOCOL == 1
if (irmp_param.protocol == IRMP_NEC_PROTOCOL)
{
last_irmp_address = irmp_tmp_address; // store as last address, too
}
#endif
#if IRMP_SUPPORT_RC5_PROTOCOL == 1
if (irmp_param.protocol == IRMP_RC5_PROTOCOL)
{
irmp_tmp_command |= rc5_cmd_bit6; // store bit 6
}
#endif
#if IRMP_SUPPORT_S100_PROTOCOL == 1
if (irmp_param.protocol == IRMP_S100_PROTOCOL)
{
irmp_tmp_command |= rc5_cmd_bit6; // store bit 6
}
#endif
irmp_command = irmp_tmp_command; // store command
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
irmp_id = irmp_tmp_id;
#endif
}
}
if (irmp_ir_detected)
{
if (last_irmp_command == irmp_tmp_command &&
last_irmp_address == irmp_tmp_address &&
key_repetition_len < IRMP_KEY_REPETITION_LEN)
{
irmp_flags |= IRMP_FLAG_REPETITION;
}
last_irmp_address = irmp_tmp_address; // store as last address, too
last_irmp_command = irmp_tmp_command; // store as last command, too
key_repetition_len = 0;
}
else
{
#ifdef ANALYZE
ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
#endif // ANALYZE
}
irmp_start_bit_detected = 0; // and wait for next start bit
irmp_tmp_command = 0;
irmp_pulse_time = 0;
irmp_pause_time = 0;
#if IRMP_SUPPORT_JVC_PROTOCOL == 1
if (irmp_protocol == IRMP_JVC_PROTOCOL) // the stop bit of JVC frame is also start bit of next frame
{ // set pulse time here!
irmp_pulse_time = ((uint_fast8_t)(F_INTERRUPTS * JVC_START_BIT_PULSE_TIME));
}
#endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
}
}
}
#if defined(STELLARIS_ARM_CORTEX_M4)
// Clear the timer interrupt
TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
#endif
return (irmp_ir_detected);
}
#ifdef ANALYZE
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* main functions - for Unix/Linux + Windows only!
*
* AVR: see main.c!
*
* Compile it under linux with:
* cc irmp.c -o irmp
*
* usage: ./irmp [-v|-s|-a|-l] < file
*
* options:
* -v verbose
* -s silent
* -a analyze
* -l list pulse/pauses
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
void
print_spectrum (char * text, int * buf, int is_pulse)
{
int i;
int j;
int min;
int max;
int max_value = 0;
int value;
int sum = 0;
int counter = 0;
double average = 0;
double tolerance;
puts ("-----------------------------------------------------------------------------");
printf ("%s:\n", text);
for (i = 0; i < 256; i++)
{
if (buf[i] > max_value)
{
max_value = buf[i];
}
}
for (i = 1; i < 200; i++)
{
if (buf[i] > 0)
{
printf ("%3d ", i);
value = (buf[i] * 60) / max_value;
for (j = 0; j < value; j++)
{
putchar ('o');
}
printf (" %d\n", buf[i]);
sum += i * buf[i];
counter += buf[i];
}
else
{
max = i - 1;
if (counter > 0)
{
average = (float) sum / (float) counter;
if (is_pulse)
{
printf ("pulse ");
}
else
{
printf ("pause ");
}
printf ("avg: %4.1f=%6.1f us, ", average, (1000000. * average) / (float) F_INTERRUPTS);
printf ("min: %2d=%6.1f us, ", min, (1000000. * min) / (float) F_INTERRUPTS);
printf ("max: %2d=%6.1f us, ", max, (1000000. * max) / (float) F_INTERRUPTS);
tolerance = (max - average);
if (average - min > tolerance)
{
tolerance = average - min;
}
tolerance = tolerance * 100 / average;
printf ("tol: %4.1f%%\n", tolerance);
}
counter = 0;
sum = 0;
min = i + 1;
}
}
}
#define STATE_LEFT_SHIFT 0x01
#define STATE_RIGHT_SHIFT 0x02
#define STATE_LEFT_CTRL 0x04
#define STATE_LEFT_ALT 0x08
#define STATE_RIGHT_ALT 0x10
#define KEY_ESCAPE 0x1B // keycode = 0x006e
#define KEY_MENUE 0x80 // keycode = 0x0070
#define KEY_BACK 0x81 // keycode = 0x0071
#define KEY_FORWARD 0x82 // keycode = 0x0072
#define KEY_ADDRESS 0x83 // keycode = 0x0073
#define KEY_WINDOW 0x84 // keycode = 0x0074
#define KEY_1ST_PAGE 0x85 // keycode = 0x0075
#define KEY_STOP 0x86 // keycode = 0x0076
#define KEY_MAIL 0x87 // keycode = 0x0077
#define KEY_FAVORITES 0x88 // keycode = 0x0078
#define KEY_NEW_PAGE 0x89 // keycode = 0x0079
#define KEY_SETUP 0x8A // keycode = 0x007a
#define KEY_FONT 0x8B // keycode = 0x007b
#define KEY_PRINT 0x8C // keycode = 0x007c
#define KEY_ON_OFF 0x8E // keycode = 0x007c
#define KEY_INSERT 0x90 // keycode = 0x004b
#define KEY_DELETE 0x91 // keycode = 0x004c
#define KEY_LEFT 0x92 // keycode = 0x004f
#define KEY_HOME 0x93 // keycode = 0x0050
#define KEY_END 0x94 // keycode = 0x0051
#define KEY_UP 0x95 // keycode = 0x0053
#define KEY_DOWN 0x96 // keycode = 0x0054
#define KEY_PAGE_UP 0x97 // keycode = 0x0055
#define KEY_PAGE_DOWN 0x98 // keycode = 0x0056
#define KEY_RIGHT 0x99 // keycode = 0x0059
#define KEY_MOUSE_1 0x9E // keycode = 0x0400
#define KEY_MOUSE_2 0x9F // keycode = 0x0800
static uint_fast8_t
get_fdc_key (uint_fast16_t cmd)
{
static uint8_t key_table[128] =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
0, '^', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '�', '�', 0, '\b',
'\t','q', 'w', 'e', 'r', 't', 'z', 'u', 'i', 'o', 'p', '�', '+', 0, 0, 'a',
's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', '�', '�', '#', '\r', 0, '<', 'y', 'x',
'c', 'v', 'b', 'n', 'm', ',', '.', '-', 0, 0, 0, 0, 0, ' ', 0, 0,
0, '�', '!', '"', '�', '$', '%', '&', '/', '(', ')', '=', '?', '`', 0, '\b',
'\t','Q', 'W', 'E', 'R', 'T', 'Z', 'U', 'I', 'O', 'P', '�', '*', 0, 0, 'A',
'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', '�', '�', '\'','\r', 0, '>', 'Y', 'X',
'C', 'V', 'B', 'N', 'M', ';', ':', '_', 0, 0, 0, 0, 0, ' ', 0, 0
};
static uint_fast8_t state;
uint_fast8_t key = 0;
switch (cmd)
{
case 0x002C: state |= STATE_LEFT_SHIFT; break; // pressed left shift
case 0x00AC: state &= ~STATE_LEFT_SHIFT; break; // released left shift
case 0x0039: state |= STATE_RIGHT_SHIFT; break; // pressed right shift
case 0x00B9: state &= ~STATE_RIGHT_SHIFT; break; // released right shift
case 0x003A: state |= STATE_LEFT_CTRL; break; // pressed left ctrl
case 0x00BA: state &= ~STATE_LEFT_CTRL; break; // released left ctrl
case 0x003C: state |= STATE_LEFT_ALT; break; // pressed left alt
case 0x00BC: state &= ~STATE_LEFT_ALT; break; // released left alt
case 0x003E: state |= STATE_RIGHT_ALT; break; // pressed left alt
case 0x00BE: state &= ~STATE_RIGHT_ALT; break; // released left alt
case 0x006e: key = KEY_ESCAPE; break;
case 0x004b: key = KEY_INSERT; break;
case 0x004c: key = KEY_DELETE; break;
case 0x004f: key = KEY_LEFT; break;
case 0x0050: key = KEY_HOME; break;
case 0x0051: key = KEY_END; break;
case 0x0053: key = KEY_UP; break;
case 0x0054: key = KEY_DOWN; break;
case 0x0055: key = KEY_PAGE_UP; break;
case 0x0056: key = KEY_PAGE_DOWN; break;
case 0x0059: key = KEY_RIGHT; break;
case 0x0400: key = KEY_MOUSE_1; break;
case 0x0800: key = KEY_MOUSE_2; break;
default:
{
if (!(cmd & 0x80)) // pressed key
{
if (cmd >= 0x70 && cmd <= 0x7F) // function keys
{
key = cmd + 0x10; // 7x -> 8x
}
else if (cmd < 64) // key listed in key_table
{
if (state & (STATE_LEFT_ALT | STATE_RIGHT_ALT))
{
switch (cmd)
{
case 0x0003: key = '�'; break;
case 0x0008: key = '{'; break;
case 0x0009: key = '['; break;
case 0x000A: key = ']'; break;
case 0x000B: key = '}'; break;
case 0x000C: key = '\\'; break;
case 0x001C: key = '~'; break;
case 0x002D: key = '|'; break;
case 0x0034: key = 0xB5; break; // Mu
}
}
else if (state & (STATE_LEFT_CTRL))
{
if (key_table[cmd] >= 'a' && key_table[cmd] <= 'z')
{
key = key_table[cmd] - 'a' + 1;
}
else
{
key = key_table[cmd];
}
}
else
{
int idx = cmd + ((state & (STATE_LEFT_SHIFT | STATE_RIGHT_SHIFT)) ? 64 : 0);
if (key_table[idx])
{
key = key_table[idx];
}
}
}
}
break;
}
}
return (key);
}
static int analyze = FALSE;
static int list = FALSE;
static IRMP_DATA irmp_data;
static int expected_protocol;
static int expected_address;
static int expected_command;
static int do_check_expected_values;
static void
next_tick (void)
{
if (! analyze && ! list)
{
(void) irmp_ISR ();
if (irmp_get_data (&irmp_data))
{
uint_fast8_t key;
ANALYZE_ONLY_NORMAL_PUTCHAR (' ');
if (verbose)
{
printf ("%8.3fms ", (double) (time_counter * 1000) / F_INTERRUPTS);
}
if (irmp_data.protocol == IRMP_ACP24_PROTOCOL)
{
uint16_t temp = (irmp_data.command & 0x000F) + 15;
printf ("p=%2d (%s), a=0x%04x, c=0x%04x, f=0x%02x, temp=%d",
irmp_data.protocol, irmp_protocol_names[irmp_data.protocol], irmp_data.address, irmp_data.command, irmp_data.flags, temp);
}
else if (irmp_data.protocol == IRMP_FDC_PROTOCOL && (key = get_fdc_key (irmp_data.command)) != 0)
{
if ((key >= 0x20 && key < 0x7F) || key >= 0xA0)
{
printf ("p=%2d (%s), a=0x%04x, c=0x%04x, f=0x%02x, asc=0x%02x, key='%c'",
irmp_data.protocol, irmp_protocol_names[irmp_data.protocol], irmp_data.address, irmp_data.command, irmp_data.flags, key, key);
}
else if (key == '\r' || key == '\t' || key == KEY_ESCAPE || (key >= 0x80 && key <= 0x9F)) // function keys
{
char * p = (char *) NULL;
switch (key)
{
case '\t' : p = "TAB"; break;
case '\r' : p = "CR"; break;
case KEY_ESCAPE : p = "ESCAPE"; break;
case KEY_MENUE : p = "MENUE"; break;
case KEY_BACK : p = "BACK"; break;
case KEY_FORWARD : p = "FORWARD"; break;
case KEY_ADDRESS : p = "ADDRESS"; break;
case KEY_WINDOW : p = "WINDOW"; break;
case KEY_1ST_PAGE : p = "1ST_PAGE"; break;
case KEY_STOP : p = "STOP"; break;
case KEY_MAIL : p = "MAIL"; break;
case KEY_FAVORITES : p = "FAVORITES"; break;
case KEY_NEW_PAGE : p = "NEW_PAGE"; break;
case KEY_SETUP : p = "SETUP"; break;
case KEY_FONT : p = "FONT"; break;
case KEY_PRINT : p = "PRINT"; break;
case KEY_ON_OFF : p = "ON_OFF"; break;
case KEY_INSERT : p = "INSERT"; break;
case KEY_DELETE : p = "DELETE"; break;
case KEY_LEFT : p = "LEFT"; break;
case KEY_HOME : p = "HOME"; break;
case KEY_END : p = "END"; break;
case KEY_UP : p = "UP"; break;
case KEY_DOWN : p = "DOWN"; break;
case KEY_PAGE_UP : p = "PAGE_UP"; break;
case KEY_PAGE_DOWN : p = "PAGE_DOWN"; break;
case KEY_RIGHT : p = "RIGHT"; break;
case KEY_MOUSE_1 : p = "KEY_MOUSE_1"; break;
case KEY_MOUSE_2 : p = "KEY_MOUSE_2"; break;
default : p = "<UNKNWON>"; break;
}
printf ("p=%2d (%s), a=0x%04x, c=0x%04x, f=0x%02x, asc=0x%02x, key=%s",
irmp_data.protocol, irmp_protocol_names[irmp_data.protocol], irmp_data.address, irmp_data.command, irmp_data.flags, key, p);
}
else
{
printf ("p=%2d (%s), a=0x%04x, c=0x%04x, f=0x%02x, asc=0x%02x",
irmp_data.protocol, irmp_protocol_names[irmp_data.protocol], irmp_data.address, irmp_data.command, irmp_data.flags, key);
}
}
else
{
printf ("p=%2d (%s), a=0x%04x, c=0x%04x, f=0x%02x",
irmp_data.protocol, irmp_protocol_names[irmp_data.protocol], irmp_data.address, irmp_data.command, irmp_data.flags);
}
if (do_check_expected_values)
{
if (irmp_data.protocol != expected_protocol ||
irmp_data.address != expected_address ||
irmp_data.command != expected_command)
{
printf ("\nerror 7: expected values differ: p=%2d (%s), a=0x%04x, c=0x%04x\n",
expected_protocol, irmp_protocol_names[expected_protocol], expected_address, expected_command);
}
else
{
printf (" checked!\n");
}
do_check_expected_values = FALSE; // only check 1st frame in a line!
}
else
{
putchar ('\n');
}
}
}
}
int
main (int argc, char ** argv)
{
int i;
int ch;
int last_ch = 0;
int pulse = 0;
int pause = 0;
int start_pulses[256];
int start_pauses[256];
int pulses[256];
int pauses[256];
int first_pulse = TRUE;
int first_pause = TRUE;
if (argc == 2)
{
if (! strcmp (argv[1], "-v"))
{
verbose = TRUE;
}
else if (! strcmp (argv[1], "-l"))
{
list = TRUE;
}
else if (! strcmp (argv[1], "-a"))
{
analyze = TRUE;
}
else if (! strcmp (argv[1], "-s"))
{
silent = TRUE;
}
else if (! strcmp (argv[1], "-r"))
{
radio = TRUE;
}
}
for (i = 0; i < 256; i++)
{
start_pulses[i] = 0;
start_pauses[i] = 0;
pulses[i] = 0;
pauses[i] = 0;
}
IRMP_PIN = 0xFF;
while ((ch = getchar ()) != EOF)
{
if (ch == '_' || ch == '0')
{
if (last_ch != ch)
{
if (pause > 0)
{
if (list)
{
printf ("pause: %d\n", pause);
}
if (analyze)
{
if (first_pause)
{
if (pause < 256)
{
start_pauses[pause]++;
}
first_pause = FALSE;
}
else
{
if (pause < 256)
{
pauses[pause]++;
}
}
}
}
pause = 0;
}
pulse++;
IRMP_PIN = 0x00;
}
else if (ch == 0xaf || ch == '-' || ch == '1')
{
if (last_ch != ch)
{
if (list)
{
printf ("pulse: %d ", pulse);
}
if (analyze)
{
if (first_pulse)
{
if (pulse < 256)
{
start_pulses[pulse]++;
}
first_pulse = FALSE;
}
else
{
if (pulse < 256)
{
pulses[pulse]++;
}
}
}
pulse = 0;
}
pause++;
IRMP_PIN = 0xff;
}
else if (ch == '\n')
{
IRMP_PIN = 0xff;
time_counter = 0;
if (list && pause > 0)
{
printf ("pause: %d\n", pause);
}
pause = 0;
if (! analyze)
{
for (i = 0; i < (int) ((10000.0 * F_INTERRUPTS) / 10000); i++) // newline: long pause of 10000 msec
{
next_tick ();
}
}
first_pulse = TRUE;
first_pause = TRUE;
}
else if (ch == '#')
{
time_counter = 0;
if (analyze)
{
while ((ch = getchar()) != '\n' && ch != EOF)
{
;
}
}
else
{
char buf[1024];
char * p;
int idx = -1;
puts ("----------------------------------------------------------------------");
putchar (ch);
while ((ch = getchar()) != '\n' && ch != EOF)
{
if (ch != '\r') // ignore CR in DOS/Windows files
{
if (ch == '[' && idx == -1)
{
idx = 0;
}
else if (idx >= 0)
{
if (ch == ']')
{
do_check_expected_values = FALSE;
buf[idx] = '\0';
idx = -1;
expected_protocol = atoi (buf);
if (expected_protocol > 0)
{
p = buf;
while (*p)
{
if (*p == 'x')
{
p++;
if (sscanf (p, "%x", &expected_address) == 1)
{
do_check_expected_values = TRUE;
}
break;
}
p++;
}
if (do_check_expected_values)
{
do_check_expected_values = FALSE;
while (*p)
{
if (*p == 'x')
{
p++;
if (sscanf (p, "%x", &expected_command) == 1)
{
do_check_expected_values = TRUE;
}
break;
}
p++;
}
if (do_check_expected_values)
{
// printf ("!%2d %04x %04x!\n", expected_protocol, expected_address, expected_command);
}
}
}
}
else if (idx < 1024 - 2)
{
buf[idx++] = ch;
}
}
putchar (ch);
}
}
putchar ('\n');
}
}
last_ch = ch;
next_tick ();
}
if (analyze)
{
print_spectrum ("START PULSES", start_pulses, TRUE);
print_spectrum ("START PAUSES", start_pauses, FALSE);
print_spectrum ("PULSES", pulses, TRUE);
print_spectrum ("PAUSES", pauses, FALSE);
puts ("-----------------------------------------------------------------------------");
}
return 0;
}
#endif // ANALYZE