/*---------------------------------------------------------------------------------------------------------------------------------------------------
* irmp.c - infrared multi-protocol decoder, supports several remote control protocols
*
* Copyright (c) 2009-2010 Frank Meyer - frank(at)fli4l.de
*
* $Id: irmp.c,v 1.87 2011/01/18 13:02:15 fm Exp $
*
* ATMEGA88 @ 8 MHz
*
* Typical manufacturers:
*
* SIRCS - Sony
* NEC - NEC, Yamaha, Canon, Tevion, Harman/Kardon, Hitachi, JVC, Pioneer, Toshiba, Xoro, Orion, and many other Japanese manufacturers
* SAMSUNG - Samsung
* SAMSUNG32 - Samsung
* MATSUSHITA - Matsushita
* KASEIKYO - Panasonic, Denon & other Japanese manufacturers (members of "Japan's Association for Electric Home Application")
* RECS80 - Philips, Nokia, Thomson, Nordmende, Telefunken, Saba
* RC5 - Philips and other European manufacturers
* DENON - Denon, Sharp
* RC6 - Philips and other European manufacturers
* APPLE - Apple
* NUBERT - Nubert Subwoofer System
* B&O - Bang & Olufsen
* PANASONIC - Panasonic (older, yet not implemented)
* GRUNDIG - Grundig
* NOKIA - Nokia
* SIEMENS - Siemens, e.g. Gigaset M740AV
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* SIRCS
* -----
*
* frame: 1 start bit + 12-20 data bits + no stop bit
* data: 7 command bits + 5 address bits + 0 to 8 additional bits
*
* start bit: data "0": data "1": stop bit:
* -----------------_________ ------_____ ------------______
* 2400us 600us 600us 600us 1200us 600 us no stop bit
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* NEC + extended NEC
* -------------------------
*
* frame: 1 start bit + 32 data bits + 1 stop bit
* data NEC: 8 address bits + 8 inverted address bits + 8 command bits + 8 inverted command bits
* data extended NEC: 16 address bits + 8 command bits + 8 inverted command bits
*
* start bit: data "0": data "1": stop bit:
* -----------------_________ ------______ ------________________ ------______....
* 9000us 4500us 560us 560us 560us 1690 us 560us
*
*
* Repetition frame:
*
* -----------------_________------______ .... ~100ms Pause, then repeat
* 9000us 2250us 560us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* SAMSUNG
* -------
*
* frame: 1 start bit + 16 data(1) bits + 1 sync bit + additional 20 data(2) bits + 1 stop bit
* data(1): 16 address bits
* data(2): 4 ID bits + 8 command bits + 8 inverted command bits
*
* start bit: data "0": data "1": sync bit: stop bit:
* ----------______________ ------______ ------________________ ------______________ ------______....
* 4500us 4500us 550us 450us 550us 1450us 550us 4500us 550us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* SAMSUNG32
* ----------
*
* frame: 1 start bit + 32 data bits + 1 stop bit
* data: 16 address bits + 16 command bits
*
* start bit: data "0": data "1": stop bit:
* ----------______________ ------______ ------________________ ------______....
* 4500us 4500us 550us 450us 550us 1450us 550us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* MATSUSHITA
* ----------
*
* frame: 1 start bit + 24 data bits + 1 stop bit
* data: 6 custom bits + 6 command bits + 12 address bits
*
* start bit: data "0": data "1": stop bit:
* ----------_________ ------______ ------________________ ------______....
* 3488us 3488us 872us 872us 872us 2616us 872us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* KASEIKYO
* --------
*
* frame: 1 start bit + 48 data bits + 1 stop bit
* data: 16 manufacturer bits + 4 parity bits + 4 genre1 bits + 4 genre2 bits + 10 command bits + 2 id bits + 8 parity bits
*
* start bit: data "0": data "1": stop bit:
* ----------______ ------______ ------________________ ------______....
* 3380us 1690us 423us 423us 423us 1269us 423us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* RECS80
* ------
*
* frame: 2 start bits + 10 data bits + 1 stop bit
* data: 1 toggle bit + 3 address bits + 6 command bits
*
* start bit: data "0": data "1": stop bit:
* -----_____________________ -----____________ -----______________ ------_______....
* 158us 7432us 158us 4902us 158us 7432us 158us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* RECS80EXT
* ---------
*
* frame: 2 start bits + 11 data bits + 1 stop bit
* data: 1 toggle bit + 4 address bits + 6 command bits
*
* start bit: data "0": data "1": stop bit:
* -----_____________________ -----____________ -----______________ ------_______....
* 158us 3637us 158us 4902us 158us 7432us 158us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* RC5 + RC5X
* ----------
*
* RC5 frame: 2 start bits + 12 data bits + no stop bit
* RC5 data: 1 toggle bit + 5 address bits + 6 command bits
* RC5X frame: 1 start bit + 13 data bits + no stop bit
* RC5X data: 1 inverted command bit + 1 toggle bit + 5 address bits + 6 command bits
*
* start bit: data "0": data "1":
* ______----- ------______ ______------
* 889us 889us 889us 889us 889us 889us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* DENON
* -----
*
* frame: 0 start bits + 16 data bits + stop bit + 65ms pause + 16 inverted data bits + stop bit
* data: 5 address bits + 10 command bits
*
* Theory:
*
* data "0": data "1":
* ------________________ ------______________
* 275us 775us 275us 1900us
*
* Practice:
*
* data "0": data "1":
* ------________________ ------______________
* 310us 745us 310us 1780us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* RC6
* ---
*
* RC6 frame: 1 start bit + 1 bit "1" + 3 mode bits + 1 toggle bit + 16 data bits + 2666 µs pause
* RC6 data: 8 address bits + 8 command bits
*
* start bit toggle bit "0": toggle bit "1": data/mode "0": data/mode "1":
* ____________------- _______------- -------_______ _______------- -------_______
* 2666us 889us 889us 889us 889us 889us 444us 444us 444us 444us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* APPLE
* -----
*
* frame: 1 start bit + 32 data bits + 1 stop bit
* data: 16 address bits + 11100000 + 8 command bits
*
* start bit: data "0": data "1": stop bit:
* -----------------_________ ------______ ------________________ ------______....
* 9000us 4500us 560us 560us 560us 1690 us 560us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* NUBERT (subwoofer system)
* -------------------------
*
* frame: 1 start bit + 10 data bits + 1 stop bit
* data: 0 address bits + 10 command bits ?
*
* start bit: data "0": data "1": stop bit:
* ----------_____ ------______ ------________________ ------______....
* 1340us 340us 500us 1300us 1340us 340us 500us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* BANG_OLUFSEN
* ------------
*
* frame: 4 start bits + 16 data bits + 1 trailer bit + 1 stop bit
* data: 0 address bits + 16 command bits
*
* 1st start bit: 2nd start bit: 3rd start bit: 4th start bit:
* -----________ -----________ -----_____________ -----________
* 210us 3000us 210us 3000us 210us 15000us 210us 3000us
*
* data "0": data "1": data "repeat bit": trailer bit: stop bit:
* -----________ -----_____________ -----___________ -----_____________ -----____...
* 210us 3000us 210us 9000us 210us 6000us 210us 12000us 210us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* GRUNDIG
* -------
*
* packet: 1 start frame + 19,968ms pause + N info frames + 117,76ms pause + 1 stop frame
* frame: 1 pre bit + 1 start bit + 9 data bits + no stop bit
* pause between info frames: 117,76ms
*
* data of start frame: 9 x 1
* data of info frame: 9 command bits
* data of stop frame: 9 x 1
*
* pre bit: start bit data "0": data "1":
* ------____________ ------______ ______------ ------______
* 528us 2639us 528us 528us 528us 528us 528us 528us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* NOKIA:
* ------
*
* Timing similar to Grundig, but 16 data bits:
* frame: 1 pre bit + 1 start bit + 8 command bits + 8 address bits + no stop bit
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* SIEMENS:
* --------
*
* SIEMENS frame: 1 start bit + 22 data bits + no stop bit
* SIEMENS data: 13 address bits + 1 repeat bit + 7 data bits + 1 unknown bit
*
* start bit data "0": data "1":
* -------_______ _______------- -------_______
* 250us 250us 250us 250us 250us 250us
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* PANASONIC (older protocol, yet not implemented, see also MATSUSHITA, timing very similar)
* -----------------------------------------------------------------------------------------
*
* frame: 1 start bit + 22 data bits + 1 stop bit
* 22 data bits = 5 custom bits + 6 data bits + 5 inverted custom bits + 6 inverted data bits
*
* European version: T = 456us
* USA & Canada version: T = 422us
*
* start bit: data "0": data "1": stop bit:
* 8T 8T 2T 2T 2T 6T 2T
* -------------____________ ------_____ ------_____________ ------_______....
* 3648us 3648us 912us 912us 912us 2736us 912us (Europe)
* 3376us 3376us 844us 844us 844us 2532us 844us (US)
*
*---------------------------------------------------------------------------------------------------------------------------------------------------
*
* 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.
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
#if defined(__PCM__) || defined(__PCB__) || defined(__PCH__) // CCS PIC Compiler instead of AVR
#define PIC_CCS_COMPILER
#endif
#ifdef unix // test on linux/unix
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#define ANALYZE
#define PROGMEM
#define memcpy_P memcpy
#else // not unix:
#ifdef WIN32
#include <stdio.h>
#include <string.h>
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
#define ANALYZE
#define PROGMEM
#define memcpy_P memcpy
#else
#ifndef CODEVISION
#ifdef PIC_CCS_COMPILER
#include <string.h>
typedef unsigned int8 uint8_t;
typedef unsigned int16 uint16_t;
#define PROGMEM
#define memcpy_P memcpy
#else // AVR:
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <avr/io.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#endif // PIC_CCS_COMPILER
#endif // CODEVISION
#endif // windows
#endif // unix
#ifndef IRMP_USE_AS_LIB
#include "irmpconfig.h"
#endif
#include "irmp.h"
#if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 || IRMP_SUPPORT_NOKIA_PROTOCOL == 1
#define IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL 1
#else
#define IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL 0
#endif
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 || IRMP_SUPPORT_RC6_PROTOCOL == 1 || IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1 || IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
#define IRMP_SUPPORT_MANCHESTER 1
#else
#define IRMP_SUPPORT_MANCHESTER 0
#endif
#define IRMP_KEY_REPETITION_LEN (uint16_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_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 ((uint8_t)(F_INTERRUPTS * SIRCS_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIRCS_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIRCS_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SIRCS_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIRCS_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define SIRCS_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIRCS_START_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1) // only 5% to avoid conflict with RC6
#define SIRCS_1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIRCS_1_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIRCS_1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIRCS_1_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SIRCS_0_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIRCS_0_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIRCS_0_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIRCS_0_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SIRCS_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIRCS_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SIRCS_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIRCS_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define NEC_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_START_BIT_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define NEC_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_START_BIT_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define NEC_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_START_BIT_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define NEC_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_START_BIT_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define NEC_REPEAT_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_REPEAT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define NEC_REPEAT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_REPEAT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define NEC_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define NEC_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define NEC_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define NEC_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define NEC_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define NEC_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_0_PAUSE_TIME * MAX_TOLERANCE_40 + 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 (uint16_t)(F_INTERRUPTS * NEC_FRAME_REPEAT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5)
#else
#define NEC_FRAME_REPEAT_PAUSE_LEN_MAX (uint16_t)(F_INTERRUPTS * 100.0e-3 * MAX_TOLERANCE_20 + 0.5)
#endif
#define SAMSUNG_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SAMSUNG_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SAMSUNG_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define SAMSUNG_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define SAMSUNG_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define SAMSUNG_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define SAMSUNG_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define SAMSUNG_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define SAMSUNG_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define SAMSUNG_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define MATSUSHITA_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define MATSUSHITA_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define MATSUSHITA_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define MATSUSHITA_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define MATSUSHITA_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define MATSUSHITA_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define MATSUSHITA_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define MATSUSHITA_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define MATSUSHITA_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define MATSUSHITA_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_0_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define KASEIKYO_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define KASEIKYO_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define KASEIKYO_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define KASEIKYO_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define KASEIKYO_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_PULSE_TIME * MIN_TOLERANCE_50 + 0.5) - 1)
#define KASEIKYO_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_PULSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
#define KASEIKYO_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define KASEIKYO_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define KASEIKYO_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_0_PAUSE_TIME * MIN_TOLERANCE_50 + 0.5) - 1)
#define KASEIKYO_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_0_PAUSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
#define RECS80_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PULSE_TIME * MIN_TOLERANCE_00 + 0.5) - 1)
#define RECS80_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC5_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC5_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC5_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC5_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define DENON_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define DENON_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define DENON_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define DENON_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define DENON_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define DENON_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC6_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC6_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC6_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC6_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC6_TOGGLE_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_TOGGLE_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC6_TOGGLE_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_TOGGLE_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RC6_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RC6_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_BIT_TIME * MAX_TOLERANCE_30 + 0.5) + 1) // pulses: 300 - 700
#define RC6_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1) // pauses: 300 - 600
#define RC6_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80EXT_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PULSE_TIME * MIN_TOLERANCE_00 + 0.5) - 1)
#define RECS80EXT_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PULSE_TIME * MAX_TOLERANCE_00 + 0.5) + 1)
#define RECS80EXT_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
#define RECS80EXT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
#define RECS80EXT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80EXT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80EXT_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80EXT_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RECS80EXT_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RECS80EXT_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define NUBERT_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_1_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_1_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_0_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_0_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_0_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_0_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NUBERT_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NUBERT_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN ((uint8_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 ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_R_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_R_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define GRUNDIG_OR_NOKIA_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define GRUNDIG_OR_NOKIA_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) + 1)
#define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define SIEMENS_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) - 1)
#define SIEMENS_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) + 1)
#define SIEMENS_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) - 1)
#define SIEMENS_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) + 1)
#define FDC_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define FDC_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define FDC_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define FDC_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define FDC_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define FDC_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
#define FDC_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define FDC_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#if 0
#define FDC_0_PAUSE_LEN_MIN ((uint8_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 ((uint8_t)(F_INTERRUPTS * FDC_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RCCAR_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RCCAR_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RCCAR_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
#define RCCAR_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
#define RCCAR_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define RCCAR_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define RCCAR_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define RCCAR_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define RCCAR_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
#define RCCAR_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
#define JVC_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * JVC_START_BIT_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define JVC_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * JVC_START_BIT_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define JVC_REPEAT_START_BIT_PAUSE_LEN_MIN ((uint8_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 ((uint8_t)(F_INTERRUPTS * (JVC_FRAME_REPEAT_PAUSE_TIME - IRMP_TIMEOUT_TIME) * MAX_TOLERANCE_70 + 0.5) - 1) // HACK!
#define JVC_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * JVC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define JVC_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * JVC_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define JVC_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * JVC_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define JVC_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * JVC_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
#define JVC_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * JVC_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
#define JVC_0_PAUSE_LEN_MAX ((uint8_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 (uint16_t)(F_INTERRUPTS * JVC_FRAME_REPEAT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5)
#define NIKON_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NIKON_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NIKON_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_START_BIT_PAUSE_LEN_MIN ((uint16_t)(F_INTERRUPTS * NIKON_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_START_BIT_PAUSE_LEN_MAX ((uint16_t)(F_INTERRUPTS * NIKON_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_REPEAT_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NIKON_REPEAT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_REPEAT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NIKON_REPEAT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NIKON_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NIKON_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NIKON_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NIKON_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NIKON_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
#define NIKON_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NIKON_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
#define NIKON_FRAME_REPEAT_PAUSE_LEN_MAX (uint16_t)(F_INTERRUPTS * NIKON_FRAME_REPEAT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5)
#define AUTO_FRAME_REPETITION_LEN (uint16_t)(F_INTERRUPTS * AUTO_FRAME_REPETITION_TIME + 0.5) // use uint16_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_NEWLINE() { if (verbose) { putchar ('\n'); } }
static int silent
;
static int time_counter
;
static int verbose
;
#else
#define ANALYZE_PUTCHAR(a)
#define ANALYZE_ONLY_NORMAL_PUTCHAR(a)
#define ANALYZE_PRINTF(...)
#define ANALYZE_NEWLINE()
#endif
#if IRMP_LOGGING == 1
#define BAUD 9600L
#include <util/setbaud.h>
#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
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Initialize UART
* @details Initializes UART
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
void
irmp_uart_init
(void)
{
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
}
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Send character
* @details Sends character
* @param ch character to be transmitted
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
void
irmp_uart_putc
(unsigned char ch
)
{
while (!(UART0_UCSRA
& UART0_UDRE_BIT_VALUE
))
{
;
}
UART0_UDR
= ch
;
}
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* 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
(uint8_t val
)
{
static uint8_t buf
[DATALEN
]; // logging buffer
static uint16_t buf_idx
; // number of written bits
static uint8_t startcycles
; // current number of start-zeros
static uint16_t cnt
; // counts sequenced highbits - to detect end
if (! val
&& (startcycles
< STARTCYCLES
) && !buf_idx
) // prevent that single random zeros init logging
{
startcycles
++;
}
else
{
startcycles
= 0;
if (! val
|| (val
&& buf_idx
!= 0)) // start or continue logging on "0", "1" cannot init logging
{
if (buf_idx
< DATALEN
* 8) // index in range?
{ // yes
if (val
)
{
buf
[(buf_idx
/ 8)] |= (1<<(buf_idx
% 8)); // set bit
}
else
{
buf
[(buf_idx
/ 8)] &= ~
(1<<(buf_idx
% 8)); // reset bit
}
buf_idx
++;
}
if (val
)
{ // if high received then look at log-stop condition
cnt
++;
if (cnt
> ENDBITS
)
{ // if stop condition is true, output on uart
uint16_t i
;
for (i
= 0; i
< STARTCYCLES
; i
++)
{
irmp_uart_putc
('0'); // the ignored starting zeros
}
for (i
= 0; i
< (buf_idx
- ENDBITS
+ 20) / 8; i
++) // transform bitset into uart chars
{
uint8_t d
= buf
[i
];
uint8_t j
;
for (j
= 0; j
< 8; j
++)
{
irmp_uart_putc
((d
& 1) + '0');
d
>>= 1;
}
}
irmp_uart_putc
('\n');
buf_idx
= 0;
}
}
else
{
cnt
= 0;
}
}
}
}
#else
#define irmp_log(val)
#endif
typedef struct
{
uint8_t protocol
; // ir protocol
uint8_t pulse_1_len_min
; // minimum length of pulse with bit value 1
uint8_t pulse_1_len_max
; // maximum length of pulse with bit value 1
uint8_t pause_1_len_min
; // minimum length of pause with bit value 1
uint8_t pause_1_len_max
; // maximum length of pause with bit value 1
uint8_t pulse_0_len_min
; // minimum length of pulse with bit value 0
uint8_t pulse_0_len_max
; // maximum length of pulse with bit value 0
uint8_t pause_0_len_min
; // minimum length of pause with bit value 0
uint8_t pause_0_len_max
; // maximum length of pause with bit value 0
uint8_t address_offset
; // address offset
uint8_t address_end
; // end of address
uint8_t command_offset
; // command offset
uint8_t command_end
; // end of command
uint8_t complete_len
; // complete length of frame
uint8_t stop_bit
; // flag: frame has stop bit
uint8_t lsb_first
; // flag: LSB first
uint8_t flags
; // some flags
} IRMP_PARAMETER
;
#if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
static 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 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 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_SAMSUNG_PROTOCOL == 1
static 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_MATSUSHITA_PROTOCOL == 1
static 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 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_RECS80_PROTOCOL == 1
static 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 PROGMEM IRMP_PARAMETER rc5_param
=
{
IRMP_RC5_PROTOCOL
, // protocol: ir protocol
RC5_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
RC5_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
RC5_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
RC5_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1, // pulse_0_len_max: maximum length of pulse with bit value 0
1, // pause_0_len_min: minimum length of pause with bit value 0
1, // pause_0_len_max: maximum length of pause with bit value 0
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_DENON_PROTOCOL == 1
static 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 PROGMEM IRMP_PARAMETER rc6_param
=
{
IRMP_RC6_PROTOCOL
, // protocol: ir protocol
RC6_BIT_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
RC6_BIT_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
RC6_BIT_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
RC6_BIT_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1, // pulse_0_len_max: maximum length of pulse with bit value 0
1, // pause_0_len_min: minimum length of pause with bit value 0
1, // pause_0_len_max: maximum length of pause with bit value 0
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 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 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_BANG_OLUFSEN_PROTOCOL == 1
static 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_OR_NOKIA_PROTOCOL == 1
static PROGMEM IRMP_PARAMETER grundig_param
=
{
IRMP_GRUNDIG_PROTOCOL
, // protocol: ir protocol
GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
GRUNDIG_OR_NOKIA_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
GRUNDIG_OR_NOKIA_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1, // pulse_0_len_max: maximum length of pulse with bit value 0
1, // pause_0_len_min: minimum length of pause with bit value 0
1, // pause_0_len_max: maximum length of pause with bit value 0
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_OR_NOKIA_STOP_BIT
, // stop_bit: flag: frame has stop bit
GRUNDIG_OR_NOKIA_LSB
, // lsb_first: flag: LSB first
GRUNDIG_OR_NOKIA_FLAGS
// flags: some flags
};
#endif
#if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
static PROGMEM IRMP_PARAMETER siemens_param
=
{
IRMP_SIEMENS_PROTOCOL
, // protocol: ir protocol
SIEMENS_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
SIEMENS_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
SIEMENS_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
SIEMENS_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1, // pulse_0_len_max: maximum length of pulse with bit value 0
1, // pause_0_len_min: minimum length of pause with bit value 0
1, // pause_0_len_max: maximum length of pause with bit value 0
SIEMENS_ADDRESS_OFFSET
, // address_offset: address offset
SIEMENS_ADDRESS_OFFSET
+ SIEMENS_ADDRESS_LEN
, // address_end: end of address
SIEMENS_COMMAND_OFFSET
, // command_offset: command offset
SIEMENS_COMMAND_OFFSET
+ SIEMENS_COMMAND_LEN
, // command_end: end of command
SIEMENS_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
SIEMENS_STOP_BIT
, // stop_bit: flag: frame has stop bit
SIEMENS_LSB
, // lsb_first: flag: LSB first
SIEMENS_FLAGS
// flags: some flags
};
#endif
#if IRMP_SUPPORT_FDC_PROTOCOL == 1
static 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 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 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
static uint8_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 uint8_t irmp_ir_detected
;
static volatile uint8_t irmp_protocol
;
static volatile uint16_t irmp_address
;
static volatile uint16_t irmp_command
;
static volatile uint16_t irmp_id
; // only used for SAMSUNG protocol
static volatile uint8_t irmp_flags
;
#ifdef ANALYZE
static uint8_t IRMP_PIN
;
#endif
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* Initialize IRMP decoder
* @details Configures IRMP input pin
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
#ifndef ANALYZE
void
irmp_init
(void)
{
#ifndef PIC_CCS_COMPILER
IRMP_PORT
&= ~
(1<<IRMP_BIT
); // deactivate pullup
IRMP_DDR
&= ~
(1<<IRMP_BIT
); // set pin to input
#endif // PIC_CCS_COMPILER
#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
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
uint8_t
irmp_get_data
(IRMP_DATA
* irmp_data_p
)
{
uint8_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;
#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)
{
ANALYZE_PRINTF
("Switching to APPLE protocol\n");
irmp_protocol
= IRMP_APPLE_PROTOCOL
;
irmp_address
= (irmp_command
& 0xFF00) >> 8;
irmp_command
&= 0x00FF;
rtc
= TRUE
;
}
break;
#endif
#if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
case IRMP_SIEMENS_PROTOCOL
:
if (((irmp_command
>> 1) & 0x0001) == (~irmp_command
& 0x0001))
{
irmp_command
>>= 1;
rtc
= TRUE
;
}
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
default:
rtc
= TRUE
;
}
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
;
}
// these statics must not be volatile, because they are only used by irmp_store_bit(), which is called by irmp_ISR()
static uint16_t irmp_tmp_address
; // ir address
static uint16_t irmp_tmp_command
; // ir command
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
static uint16_t irmp_tmp_address2
; // ir address
static uint16_t irmp_tmp_command2
; // ir command
#endif
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
static uint16_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
#endif
static uint8_t irmp_bit
; // current bit position
/*---------------------------------------------------------------------------------------------------------------------------------------------------
* 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 (uint8_t) __attribute__ ((noinline));
static void
irmp_store_bit
(uint8_t value
)
{
if (irmp_bit
>= irmp_param.
address_offset && irmp_bit
< irmp_param.
address_end)
{
if (irmp_param.
lsb_first)
{
irmp_tmp_address
|= (((uint16_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)
{
irmp_tmp_command
|= (((uint16_t) (value
)) << (irmp_bit
- irmp_param.
command_offset)); // CV wants cast
}
else
{
irmp_tmp_command
<<= 1;
irmp_tmp_command
|= value
;
}
}
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
else if (irmp_param.
protocol == IRMP_SAMSUNG_PROTOCOL
&& irmp_bit
>= SAMSUNG_ID_OFFSET
&& irmp_bit
< SAMSUNG_ID_OFFSET
+ SAMSUNG_ID_LEN
)
{
irmp_tmp_id
|= (((uint16_t) (value
)) << (irmp_bit
- SAMSUNG_ID_OFFSET
)); // store with LSB first
}
#endif
#if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
else if (irmp_param.
protocol == IRMP_KASEIKYO_PROTOCOL
&& irmp_bit
>= 20 && irmp_bit
< 24)
{
irmp_tmp_command
|= (((uint16_t) (value
)) << (irmp_bit
- 8)); // store 4 system bits in upper nibble with LSB first
}
if (irmp_param.
protocol == IRMP_KASEIKYO_PROTOCOL
&& 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));
}
}
#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
(uint8_t value
)
{
uint8_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
|= (((uint16_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
|= (((uint16_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
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
uint8_t
irmp_ISR
(void)
{
static uint8_t irmp_start_bit_detected
; // flag: start bit detected
static uint8_t wait_for_space
; // flag: wait for data bit space
static uint8_t wait_for_start_space
; // flag: wait for start bit space
static uint8_t irmp_pulse_time
; // count bit time for pulse
static PAUSE_LEN irmp_pause_time
; // count bit time for pause
static uint16_t last_irmp_address
= 0xFFFF; // save last irmp address to recognize key repetition
static uint16_t last_irmp_command
= 0xFFFF; // save last irmp command to recognize key repetition
static uint16_t repetition_len
; // SIRCS repeats frame 2-5 times with 45 ms pause
static uint8_t repetition_frame_number
;
#if IRMP_SUPPORT_DENON_PROTOCOL == 1
static uint16_t last_irmp_denon_command
; // save last irmp command to recognize DENON frame repetition
#endif
#if IRMP_SUPPORT_RC5_PROTOCOL == 1
static uint8_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 uint8_t last_value
; // last bit value
#endif
uint8_t irmp_input
; // input value
#ifdef ANALYZE
time_counter
++;
#endif
irmp_input
= input
(IRMP_PIN
);
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...
#ifdef ANALYZE
if (! irmp_pulse_time
)
{
ANALYZE_PRINTF
("%8d [starting pulse]\n", time_counter
);
}
#endif
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_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
irmp_tmp_command2
= 0;
irmp_tmp_address2
= 0;
#endif
irmp_bit
= 0xff;
irmp_pause_time
= 1; // 1st pause: set to 1, not to 0!
#if IRMP_SUPPORT_RC5_PROTOCOL == 1
rc5_cmd_bit6
= 0; // fm 2010-03-07: bugfix: reset it after incomplete RC5 frame!
#endif
}
else
{
if (repetition_len
< 0xFFFF) // avoid overflow of counter
{
repetition_len
++;
}
}
}
}
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
{
ANALYZE_PRINTF
("%8d error 1: pause after start bit pulse %d too long: %d\n", time_counter
, irmp_pulse_time
, irmp_pause_time
);
ANALYZE_ONLY_NORMAL_PUTCHAR
('\n');
}
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_PARAMETER
*) 0;
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
irmp_param2.
protocol = 0;
#endif
ANALYZE_PRINTF
("%8d [start-bit: pulse = %2d, pause = %2d]\n", time_counter
, irmp_pulse_time
, irmp_pause_time
);
#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
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
);
irmp_param_p
= (IRMP_PARAMETER
*) (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
)
{
ANALYZE_PRINTF
("protocol = NEC or JVC 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
);
irmp_param_p
= (IRMP_PARAMETER
*) &nec_param
; // tricky: use nec parameters
}
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
)
{
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
);
irmp_param_p
= (IRMP_PARAMETER
*) &nec_param
;
}
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
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
);
irmp_param_p
= (IRMP_PARAMETER
*) &nec_rep_param
;
}
else
#endif // IRMP_SUPPORT_NEC_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
)
{
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
);
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
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
);
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
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
);
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
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
);
irmp_param_p
= (IRMP_PARAMETER
*) &kaseikyo_param
;
}
else
#endif // IRMP_SUPPORT_KASEIKYO_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
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
);
irmp_param_p
= (IRMP_PARAMETER
*) &recs80_param
;
}
else
#endif // IRMP_SUPPORT_RECS80_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
)
{
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
);
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
)
{
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
);
memcpy_P
(&irmp_param2
, &rccar_param
, sizeof (IRMP_PARAMETER
));
}
else
#endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
{
ANALYZE_PRINTF
("protocol = 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
);
}
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
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
);
irmp_param_p
= (IRMP_PARAMETER
*) &denon_param
;
}
else
#endif // IRMP_SUPPORT_DENON_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
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
);
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
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
);
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
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
);
irmp_param_p
= (IRMP_PARAMETER
*) &nubert_param
;
}
else
#endif // IRMP_SUPPORT_NUBERT_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
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
);
irmp_param_p
= (IRMP_PARAMETER
*) &bang_olufsen_param
;
last_value
= 0;
}
else
#endif // IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
#if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
if (irmp_pulse_time
>= GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN
&& irmp_pulse_time
<= GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX
&&
irmp_pause_time
>= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN
&& irmp_pause_time
<= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX
)
{ // it's GRUNDIG
ANALYZE_PRINTF
("protocol = GRUNDIG, pre bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN
, GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX
,
GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN
, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX
);
irmp_param_p
= (IRMP_PARAMETER
*) &grundig_param
;
last_pause
= irmp_pause_time
;
last_value
= 1;
}
else
#endif // IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
#if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
if (((irmp_pulse_time
>= SIEMENS_START_BIT_LEN_MIN
&& irmp_pulse_time
<= SIEMENS_START_BIT_LEN_MAX
) ||
(irmp_pulse_time
>= 2 * SIEMENS_START_BIT_LEN_MIN
&& irmp_pulse_time
<= 2 * SIEMENS_START_BIT_LEN_MAX
)) &&
((irmp_pause_time
>= SIEMENS_START_BIT_LEN_MIN
&& irmp_pause_time
<= SIEMENS_START_BIT_LEN_MAX
) ||
(irmp_pause_time
>= 2 * SIEMENS_START_BIT_LEN_MIN
&& irmp_pause_time
<= 2 * SIEMENS_START_BIT_LEN_MAX
)))
{ // it's SIEMENS
ANALYZE_PRINTF
("protocol = SIEMENS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
,
SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
);
irmp_param_p
= (IRMP_PARAMETER
*) &siemens_param
;
last_pause
= irmp_pause_time
;
last_value
= 1;
}
else
#endif // IRMP_SUPPORT_SIEMENS_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
)
{
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
);
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
)
{
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
);
irmp_param_p
= (IRMP_PARAMETER
*) &rccar_param
;
}
else
#endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
{
ANALYZE_PRINTF
("protocol = UNKNOWN\n");
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
));
#ifdef ANALYZE
if (! (irmp_param.
flags & IRMP_PARAM_FLAG_IS_MANCHESTER
))
{
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);
}
else
{
ANALYZE_PRINTF
("pulse: %3d - %3d or %3d - %3d\n", irmp_param.
pulse_1_len_min, irmp_param.
pulse_1_len_max,
irmp_param.
pulse_1_len_max + 1, 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,
irmp_param.
pause_1_len_max + 1, 2 * irmp_param.
pause_1_len_max);
}
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
if (irmp_param2.
protocol)
{
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
#if IRMP_SUPPORT_RC6_PROTOCOL == 1
if (irmp_param.
protocol == IRMP_RC6_PROTOCOL
)
{
ANALYZE_PRINTF
("pulse_toggle: %3d - %3d\n", RC6_TOGGLE_BIT_LEN_MIN
, RC6_TOGGLE_BIT_LEN_MAX
);
}
#endif
if (! (irmp_param.
flags & IRMP_PARAM_FLAG_IS_MANCHESTER
))
{
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);
}
#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_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)
{
ANALYZE_PRINTF
("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
ANALYZE_PUTCHAR
((irmp_param.
flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '0' : '1');
ANALYZE_NEWLINE
();
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)
{
ANALYZE_PRINTF
("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
ANALYZE_PUTCHAR
((irmp_param.
flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '1' : '0');
ANALYZE_NEWLINE
();
irmp_store_bit
((irmp_param.
flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0);
}
}
else
#endif // IRMP_SUPPORT_MANCHESTER == 1
#if IRMP_SUPPORT_DENON_PROTOCOL == 1
if (irmp_param.
protocol == IRMP_DENON_PROTOCOL
)
{
ANALYZE_PRINTF
("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
if (irmp_pause_time
>= DENON_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_1_PAUSE_LEN_MAX
)
{ // pause timings correct for "1"?
ANALYZE_PUTCHAR
('1'); // yes, store 1
ANALYZE_NEWLINE
();
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"?
ANALYZE_PUTCHAR
('0'); // yes, store 0
ANALYZE_NEWLINE
();
irmp_store_bit
(0);
}
}
else
#endif // IRMP_SUPPORT_DENON_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....
uint8_t got_light
= FALSE
;
if (irmp_input
) // still dark?
{ // yes...
if (irmp_bit
== irmp_param.
complete_len && irmp_param.
stop_bit == 1)
{
if (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
irmp_param.
stop_bit = 0;
}
else
{
ANALYZE_PRINTF
("stop bit timing wrong\n");
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_GRUNDIG_OR_NOKIA_PROTOCOL == 1
if (irmp_param.
protocol == IRMP_GRUNDIG_PROTOCOL
&& !irmp_param.
stop_bit)
{
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
)
{
ANALYZE_PRINTF
("Switching to NOKIA protocol\n");
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_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
{
ANALYZE_PRINTF
("Switching to JVC protocol\n");
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
else
{
ANALYZE_PRINTF
("error 2: pause %d after data bit %d too long\n", irmp_pause_time
, irmp_bit
);
ANALYZE_ONLY_NORMAL_PUTCHAR
('\n');
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
)
{
ANALYZE_PRINTF
("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
#if IRMP_SUPPORT_MANCHESTER == 1
if ((irmp_param.
flags & IRMP_PARAM_FLAG_IS_MANCHESTER
)) // Manchester
{
if (irmp_pulse_time
> irmp_param.
pulse_1_len_max /* && irmp_pulse_time <= 2 * irmp_param.pulse_1_len_max */)
{
#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
{
ANALYZE_PUTCHAR
('T');
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;
}
ANALYZE_NEWLINE
();
}
else
#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
{
ANALYZE_PUTCHAR
((irmp_param.
flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '0' : '1');
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
{
ANALYZE_PUTCHAR
('T');
irmp_store_bit
(1);
if (irmp_pause_time
> 2 * irmp_param.
pause_1_len_max)
{
last_value
= 0;
}
else
{
last_value
= 1;
}
ANALYZE_NEWLINE
();
}
else
#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
{
ANALYZE_PUTCHAR
((irmp_param.
flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '1' : '0');
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
{
ANALYZE_NEWLINE
();
}
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)
{
uint8_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
;
}
ANALYZE_PUTCHAR
(manchester_value
+ '0');
#if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
if (! irmp_param2.
protocol)
#endif
{
ANALYZE_NEWLINE
();
}
#if IRMP_SUPPORT_RC6_PROTOCOL == 1
if (irmp_param.
protocol == IRMP_RC6_PROTOCOL
&& irmp_bit
== 1 && manchester_value
== 1) // RC6 mode != 0 ???
{
ANALYZE_PRINTF
("Switching to RC6A protocol\n");
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
)))
{
ANALYZE_PUTCHAR
('?');
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
)))
{
ANALYZE_PUTCHAR
('?');
irmp_param.
protocol = 0; // switch to RCCAR, see below
}
else
#endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
{
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');
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
)
{
ANALYZE_PRINTF
(" 1 (FDC)\n");
irmp_store_bit2
(1);
}
else if (irmp_pause_time
>= FDC_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_0_PAUSE_LEN_MAX
)
{
ANALYZE_PRINTF
(" 0 (FDC)\n");
irmp_store_bit2
(0);
}
if (! irmp_param.
protocol)
{
ANALYZE_PRINTF
("Switching to FDC protocol\n");
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
)
{
ANALYZE_PRINTF
(" 1 (RCCAR)\n");
irmp_store_bit2
(1);
}
else if (irmp_pause_time
>= RCCAR_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_0_PAUSE_LEN_MAX
)
{
ANALYZE_PRINTF
(" 0 (RCCAR)\n");
irmp_store_bit2
(0);
}
if (! irmp_param.
protocol)
{
ANALYZE_PRINTF
("Switching to RCCAR protocol\n");
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_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
)
{
ANALYZE_PRINTF
("SYNC\n");
wait_for_space
= 0;
irmp_tmp_id
= 0;
irmp_bit
++;
}
else if (irmp_pulse_time
>= SAMSUNG_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_PULSE_LEN_MAX
)
{
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
;
if (irmp_pause_time
>= SAMSUNG_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_1_PAUSE_LEN_MAX
)
{
ANALYZE_PUTCHAR
('1');
ANALYZE_NEWLINE
();
irmp_store_bit
(1);
wait_for_space
= 0;
}
else
{
ANALYZE_PUTCHAR
('0');
ANALYZE_NEWLINE
();
irmp_store_bit
(0);
wait_for_space
= 0;
}
ANALYZE_PRINTF
("Switching to SAMSUNG32 protocol\n");
}
else
{ // timing incorrect!
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');
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_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
)
{
ANALYZE_PRINTF
("3rd start bit\n");
wait_for_space
= 0;
irmp_bit
++;
}
else
{ // timing incorrect!
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');
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
)
{
ANALYZE_PRINTF
("trailer bit\n");
wait_for_space
= 0;
irmp_bit
++;
}
else
{ // timing incorrect!
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');
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"?
ANALYZE_PUTCHAR
('1');
ANALYZE_NEWLINE
();
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"?
ANALYZE_PUTCHAR
('0');
ANALYZE_NEWLINE
();
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
)
{
ANALYZE_PUTCHAR
(last_value
+ '0');
ANALYZE_NEWLINE
();
irmp_store_bit
(last_value
);
wait_for_space
= 0;
}
else
{ // timing incorrect!
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');
irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
irmp_pause_time
= 0;
}
}
}
else
{ // timing incorrect!
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');
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_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"?
ANALYZE_PUTCHAR
('1');
ANALYZE_NEWLINE
();
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"?
ANALYZE_PUTCHAR
('0');
ANALYZE_NEWLINE
();
irmp_store_bit
(0);
wait_for_space
= 0;
}
else
{ // timing incorrect!
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');
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
&& 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))
{
ANALYZE_PRINTF
("code skipped: SIRCS auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number
+ 1, repetition_len
, AUTO_FRAME_REPETITION_LEN
);
repetition_len
= 0;
}
else
#endif
#if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
// 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)
{
ANALYZE_PRINTF
("code skipped: KASEIKYO auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number
+ 1, repetition_len
, AUTO_FRAME_REPETITION_LEN
);
repetition_len
= 0;
}
else
#endif
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
// if SAMSUNG32 protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
if (irmp_param.
protocol == IRMP_SAMSUNG32_PROTOCOL
&& (repetition_frame_number
& 0x01))
{
ANALYZE_PRINTF
("code skipped: SAMSUNG32 auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number
+ 1, repetition_len
, AUTO_FRAME_REPETITION_LEN
);
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))
{
ANALYZE_PRINTF
("code skipped: NUBERT auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
repetition_frame_number
+ 1, repetition_len
, AUTO_FRAME_REPETITION_LEN
);
repetition_len
= 0;
}
else
#endif
{
ANALYZE_PRINTF
("%8d code detected, length = %d\n", time_counter
, irmp_bit
);
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!
irmp_protocol
= irmp_param.
protocol; // store protocol
irmp_address
= irmp_tmp_address
; // store address
irmp_command
= irmp_tmp_command
; // store command
}
else
{
ANALYZE_PRINTF
("waiting for inverted command repetition\n");
irmp_ir_detected
= FALSE
;
last_irmp_denon_command
= irmp_tmp_command
;
}
}
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?
ANALYZE_PRINTF
("Detected GRUNDIG start frame, ignoring it\n");
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?
ANALYZE_PRINTF
("Detected NOKIA start frame, ignoring it\n");
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 (repetition_len
< NEC_FRAME_REPEAT_PAUSE_LEN_MAX
)
{
ANALYZE_PRINTF
("Detected NEC repetition frame, repetition_len = %d\n", repetition_len
);
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
;
repetition_len
= 0;
}
else
{
ANALYZE_PRINTF
("Detected NEC repetition frame, ignoring it: timeout occured, repetition_len = %d > %d\n",
repetition_len
, NEC_FRAME_REPEAT_PAUSE_LEN_MAX
);
irmp_ir_detected
= FALSE
;
}
}
#endif // IRMP_SUPPORT_NEC_PROTOCOL
#if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
if (irmp_param.
protocol == IRMP_KASEIKYO_PROTOCOL
)
{
uint8_t xor
;
// ANALYZE_PRINTF ("0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
// xor_check[0], xor_check[1], xor_check[2], xor_check[3], xor_check[4], xor_check[5]);
xor
= (xor_check
[0] & 0x0F) ^ ((xor_check
[0] & 0xF0) >> 4) ^ (xor_check
[1] & 0x0F) ^ ((xor_check
[1] & 0xF0) >> 4);
if (xor
!= (xor_check
[2] & 0x0F))
{
ANALYZE_PRINTF
("error 4: wrong XOR check for customer id: 0x%1x 0x%1x\n", xor
, xor_check
[2] & 0x0F);
irmp_ir_detected
= FALSE
;
}
xor
= xor_check
[2] ^ xor_check
[3] ^ xor_check
[4];
if (xor
!= xor_check
[5])
{
ANALYZE_PRINTF
("error 4: wrong XOR check for data bits: 0x%02x 0x%02x\n", xor
, xor_check
[5]);
irmp_ir_detected
= FALSE
;
}
}
#endif // IRMP_SUPPORT_KASEIKYO_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
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
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_command
&&
last_irmp_address
== irmp_address
&&
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
repetition_len
= 0;
}
else
{
ANALYZE_ONLY_NORMAL_PUTCHAR
('\n');
}
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
= ((uint8_t)(F_INTERRUPTS
* JVC_START_BIT_PULSE_TIME
));
}
#endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
}
}
}
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|-p] < file
*
* options:
* -v verbose
* -s silent
* -a analyze
* -l list pulse/pauses
* -p print timings
*---------------------------------------------------------------------------------------------------------------------------------------------------
*/
static void
print_timings
(void)
{
printf ("IRMP_TIMEOUT_LEN: %d [%d byte(s)]\n", IRMP_TIMEOUT_LEN
, sizeof (PAUSE_LEN
));
printf ("IRMP_KEY_REPETITION_LEN %d\n", IRMP_KEY_REPETITION_LEN
);
puts ("");
printf ("PROTOCOL S S-PULSE S-PAUSE PULSE-0 PAUSE-0 PULSE-1 PAUSE-1\n");
printf ("====================================================================================\n");
printf ("SIRCS 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
SIRCS_0_PULSE_LEN_MIN
, SIRCS_0_PULSE_LEN_MAX
, SIRCS_PAUSE_LEN_MIN
, SIRCS_PAUSE_LEN_MAX
,
SIRCS_1_PULSE_LEN_MIN
, SIRCS_1_PULSE_LEN_MAX
, SIRCS_PAUSE_LEN_MIN
, SIRCS_PAUSE_LEN_MAX
);
printf ("NEC 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_0_PAUSE_LEN_MIN
, NEC_0_PAUSE_LEN_MAX
,
NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_1_PAUSE_LEN_MIN
, NEC_1_PAUSE_LEN_MAX
);
printf ("NEC (rep) 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_0_PAUSE_LEN_MIN
, NEC_0_PAUSE_LEN_MAX
,
NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_1_PAUSE_LEN_MIN
, NEC_1_PAUSE_LEN_MAX
);
printf ("SAMSUNG 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
SAMSUNG_PULSE_LEN_MIN
, SAMSUNG_PULSE_LEN_MAX
, SAMSUNG_0_PAUSE_LEN_MIN
, SAMSUNG_0_PAUSE_LEN_MAX
,
SAMSUNG_PULSE_LEN_MIN
, SAMSUNG_PULSE_LEN_MAX
, SAMSUNG_1_PAUSE_LEN_MIN
, SAMSUNG_1_PAUSE_LEN_MAX
);
printf ("MATSUSHITA 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
MATSUSHITA_PULSE_LEN_MIN
, MATSUSHITA_PULSE_LEN_MAX
, MATSUSHITA_0_PAUSE_LEN_MIN
, MATSUSHITA_0_PAUSE_LEN_MAX
,
MATSUSHITA_PULSE_LEN_MIN
, MATSUSHITA_PULSE_LEN_MAX
, MATSUSHITA_1_PAUSE_LEN_MIN
, MATSUSHITA_1_PAUSE_LEN_MAX
);
printf ("KASEIKYO 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
KASEIKYO_PULSE_LEN_MIN
, KASEIKYO_PULSE_LEN_MAX
, KASEIKYO_0_PAUSE_LEN_MIN
, KASEIKYO_0_PAUSE_LEN_MAX
,
KASEIKYO_PULSE_LEN_MIN
, KASEIKYO_PULSE_LEN_MAX
, KASEIKYO_1_PAUSE_LEN_MIN
, KASEIKYO_1_PAUSE_LEN_MAX
);
printf ("RECS80 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
RECS80_PULSE_LEN_MIN
, RECS80_PULSE_LEN_MAX
, RECS80_0_PAUSE_LEN_MIN
, RECS80_0_PAUSE_LEN_MAX
,
RECS80_PULSE_LEN_MIN
, RECS80_PULSE_LEN_MAX
, RECS80_1_PAUSE_LEN_MIN
, RECS80_1_PAUSE_LEN_MAX
);
printf ("RC5 1 %3d - %3d %3d - %3d %3d - %3d\n",
RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
, RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
RC5_BIT_LEN_MIN
, RC5_BIT_LEN_MAX
);
printf ("DENON 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
,
DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
, DENON_0_PAUSE_LEN_MIN
, DENON_0_PAUSE_LEN_MAX
,
DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
, DENON_1_PAUSE_LEN_MIN
, DENON_1_PAUSE_LEN_MAX
);
printf ("RC6 1 %3d - %3d %3d - %3d %3d - %3d %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
,
RC6_BIT_PULSE_LEN_MIN
, RC6_BIT_PULSE_LEN_MAX
, RC6_BIT_PAUSE_LEN_MIN
, RC6_BIT_PAUSE_LEN_MAX
);
printf ("RECS80EXT 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
RECS80EXT_PULSE_LEN_MIN
, RECS80EXT_PULSE_LEN_MAX
, RECS80EXT_0_PAUSE_LEN_MIN
, RECS80EXT_0_PAUSE_LEN_MAX
,
RECS80EXT_PULSE_LEN_MIN
, RECS80EXT_PULSE_LEN_MAX
, RECS80EXT_1_PAUSE_LEN_MIN
, RECS80EXT_1_PAUSE_LEN_MAX
);
printf ("NUBERT 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
NUBERT_0_PULSE_LEN_MIN
, NUBERT_0_PULSE_LEN_MAX
, NUBERT_0_PAUSE_LEN_MIN
, NUBERT_0_PAUSE_LEN_MAX
,
NUBERT_1_PULSE_LEN_MIN
, NUBERT_1_PULSE_LEN_MAX
, NUBERT_1_PAUSE_LEN_MIN
, NUBERT_1_PAUSE_LEN_MAX
);
printf ("BANG_OLUFSEN 1 %3d - %3d %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
);
printf ("BANG_OLUFSEN 2 %3d - %3d %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
);
printf ("BANG_OLUFSEN 3 %3d - %3d %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
);
printf ("BANG_OLUFSEN 4 %3d - %3d %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
);
printf ("BANG_OLUFSEN - %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
BANG_OLUFSEN_PULSE_LEN_MIN
, BANG_OLUFSEN_PULSE_LEN_MAX
, BANG_OLUFSEN_0_PAUSE_LEN_MIN
, BANG_OLUFSEN_0_PAUSE_LEN_MAX
,
BANG_OLUFSEN_PULSE_LEN_MIN
, BANG_OLUFSEN_PULSE_LEN_MAX
, BANG_OLUFSEN_1_PAUSE_LEN_MIN
, BANG_OLUFSEN_1_PAUSE_LEN_MAX
);
printf ("GRUNDIG/NOKIA 1 %3d - %3d %3d - %3d %3d - %3d\n",
GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN
, GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX
, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN
, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX
,
GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, GRUNDIG_OR_NOKIA_BIT_LEN_MAX
);
printf ("SIEMENS 1 %3d - %3d %3d - %3d %3d - %3d\n",
SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
, SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
,
SIEMENS_BIT_LEN_MIN
, SIEMENS_BIT_LEN_MAX
);
printf ("FDC 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
FDC_PULSE_LEN_MIN
, FDC_PULSE_LEN_MAX
, FDC_0_PAUSE_LEN_MIN
, FDC_0_PAUSE_LEN_MAX
,
FDC_PULSE_LEN_MIN
, FDC_PULSE_LEN_MAX
, FDC_1_PAUSE_LEN_MIN
, FDC_1_PAUSE_LEN_MAX
);
printf ("RCCAR 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
RCCAR_PULSE_LEN_MIN
, RCCAR_PULSE_LEN_MAX
, RCCAR_0_PAUSE_LEN_MIN
, RCCAR_0_PAUSE_LEN_MAX
,
RCCAR_PULSE_LEN_MIN
, RCCAR_PULSE_LEN_MAX
, RCCAR_1_PAUSE_LEN_MIN
, RCCAR_1_PAUSE_LEN_MAX
);
printf ("NIKON 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %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
,
NIKON_PULSE_LEN_MIN
, NIKON_PULSE_LEN_MAX
, NIKON_0_PAUSE_LEN_MIN
, NIKON_0_PAUSE_LEN_MAX
,
NIKON_PULSE_LEN_MIN
, NIKON_PULSE_LEN_MAX
, NIKON_1_PAUSE_LEN_MIN
, NIKON_1_PAUSE_LEN_MAX
);
}
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
< 100; 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 uint8_t
get_fdc_key
(uint16_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 uint8_t state
;
uint8_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
= 'µ'; break;
}
}
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 void
next_tick
(void)
{
if (! analyze
&& ! list
)
{
(void) irmp_ISR
();
if (irmp_get_data
(&irmp_data
))
{
uint8_t key
;
ANALYZE_ONLY_NORMAL_PUTCHAR
(' ');
if (verbose
)
{
printf ("%8d ", time_counter
);
}
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, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x, key = '%c'\n",
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, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x, key = %s\n",
irmp_data.
protocol, irmp_data.
address, irmp_data.
command, irmp_data.
flags, key
, p
);
}
else
{
printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x\n",
irmp_data.
protocol, irmp_data.
address, irmp_data.
command, irmp_data.
flags, key
);
}
}
else
{
printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x\n",
irmp_data.
protocol, irmp_data.
address, irmp_data.
command, irmp_data.
flags);
}
}
}
}
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], "-p"))
{
print_timings
();
return (0);
}
}
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;
if (list
&& pause
> 0)
{
printf ("pause: %d\n", pause
);
}
pause
= 0;
if (! analyze
)
{
for (i
= 0; i
< (int) ((8000.0 * F_INTERRUPTS
) / 10000); i
++) // newline: long pause of 800 msec
{
next_tick
();
}
}
first_pulse
= TRUE
;
first_pause
= TRUE
;
}
else if (ch
== '#')
{
if (analyze
)
{
while ((ch
= getchar()) != '\n' && ch
!= EOF
)
{
;
}
}
else
{
puts ("-------------------------------------------------------------------");
putchar (ch
);
while ((ch
= getchar()) != '\n' && ch
!= EOF
)
{
if (ch
!= '\r') // ignore CR in DOS/Windows files
{
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