1 /*---------------------------------------------------------------------------------------------------------------------------------------------------
2 * irmp.c - infrared multi-protocol decoder, supports several remote control protocols
4 * Copyright (c) 2009-2010 Frank Meyer - frank(at)fli4l.de
6 * $Id: irmp.c,v 1.79 2010/08/28 22:14:56 fm Exp $
10 * Typical manufacturers:
13 * NEC - NEC, Yamaha, Canon, Tevion, Harman/Kardon, Hitachi, JVC, Pioneer, Toshiba, Xoro, Orion, and many other Japanese manufacturers
16 * MATSUSHITA - Matsushita
17 * KASEIKYO - Panasonic, Denon & other Japanese manufacturers (members of "Japan's Association for Electric Home Application")
18 * RECS80 - Philips, Nokia, Thomson, Nordmende, Telefunken, Saba
19 * RC5 - Philips and other European manufacturers
21 * RC6 - Philips and other European manufacturers
23 * NUBERT - Nubert Subwoofer System
24 * B&O - Bang & Olufsen
25 * PANASONIC - Panasonic (older, yet not implemented)
28 * SIEMENS - Siemens, e.g. Gigaset M740AV
30 *---------------------------------------------------------------------------------------------------------------------------------------------------
35 * frame: 1 start bit + 12-20 data bits + no stop bit
36 * data: 7 command bits + 5 address bits + 0 to 8 additional bits
38 * start bit: data "0": data "1": stop bit:
39 * -----------------_________ ------_____ ------------______
40 * 2400us 600us 600us 600us 1200us 600 us no stop bit
42 *---------------------------------------------------------------------------------------------------------------------------------------------------
45 * -------------------------
47 * frame: 1 start bit + 32 data bits + 1 stop bit
48 * data NEC: 8 address bits + 8 inverted address bits + 8 command bits + 8 inverted command bits
49 * data extended NEC: 16 address bits + 8 command bits + 8 inverted command bits
51 * start bit: data "0": data "1": stop bit:
52 * -----------------_________ ------______ ------________________ ------______....
53 * 9000us 4500us 560us 560us 560us 1690 us 560us
58 * -----------------_________------______ .... ~100ms Pause, then repeat
61 *---------------------------------------------------------------------------------------------------------------------------------------------------
66 * frame: 1 start bit + 16 data(1) bits + 1 sync bit + additional 20 data(2) bits + 1 stop bit
67 * data(1): 16 address bits
68 * data(2): 4 ID bits + 8 command bits + 8 inverted command bits
70 * start bit: data "0": data "1": sync bit: stop bit:
71 * ----------______________ ------______ ------________________ ------______________ ------______....
72 * 4500us 4500us 550us 450us 550us 1450us 550us 4500us 550us
74 *---------------------------------------------------------------------------------------------------------------------------------------------------
79 * frame: 1 start bit + 32 data bits + 1 stop bit
80 * data: 16 address bits + 16 command bits
82 * start bit: data "0": data "1": stop bit:
83 * ----------______________ ------______ ------________________ ------______....
84 * 4500us 4500us 550us 450us 550us 1450us 550us
86 *---------------------------------------------------------------------------------------------------------------------------------------------------
91 * frame: 1 start bit + 24 data bits + 1 stop bit
92 * data: 6 custom bits + 6 command bits + 12 address bits
94 * start bit: data "0": data "1": stop bit:
95 * ----------_________ ------______ ------________________ ------______....
96 * 3488us 3488us 872us 872us 872us 2616us 872us
98 *---------------------------------------------------------------------------------------------------------------------------------------------------
103 * frame: 1 start bit + 48 data bits + 1 stop bit
104 * data: 16 manufacturer bits + 4 parity bits + 4 genre1 bits + 4 genre2 bits + 10 command bits + 2 id bits + 8 parity bits
106 * start bit: data "0": data "1": stop bit:
107 * ----------______ ------______ ------________________ ------______....
108 * 3380us 1690us 423us 423us 423us 1269us 423us
110 *---------------------------------------------------------------------------------------------------------------------------------------------------
115 * frame: 2 start bits + 10 data bits + 1 stop bit
116 * data: 1 toggle bit + 3 address bits + 6 command bits
118 * start bit: data "0": data "1": stop bit:
119 * -----_____________________ -----____________ -----______________ ------_______....
120 * 158us 7432us 158us 4902us 158us 7432us 158us
122 *---------------------------------------------------------------------------------------------------------------------------------------------------
127 * frame: 2 start bits + 11 data bits + 1 stop bit
128 * data: 1 toggle bit + 4 address bits + 6 command bits
130 * start bit: data "0": data "1": stop bit:
131 * -----_____________________ -----____________ -----______________ ------_______....
132 * 158us 3637us 158us 4902us 158us 7432us 158us
134 *---------------------------------------------------------------------------------------------------------------------------------------------------
139 * RC5 frame: 2 start bits + 12 data bits + no stop bit
140 * RC5 data: 1 toggle bit + 5 address bits + 6 command bits
141 * RC5X frame: 1 start bit + 13 data bits + no stop bit
142 * RC5X data: 1 inverted command bit + 1 toggle bit + 5 address bits + 6 command bits
144 * start bit: data "0": data "1":
145 * ______----- ------______ ______------
146 * 889us 889us 889us 889us 889us 889us
148 *---------------------------------------------------------------------------------------------------------------------------------------------------
153 * frame: 0 start bits + 16 data bits + stop bit + 65ms pause + 16 inverted data bits + stop bit
154 * data: 5 address bits + 10 command bits
156 * data "0": data "1":
157 * ------________________ ------______________
158 * 275us 775us 275us 1900us
160 *---------------------------------------------------------------------------------------------------------------------------------------------------
165 * RC6 frame: 1 start bit + 1 bit "1" + 3 mode bits + 1 toggle bit + 16 data bits + 2666 µs pause
166 * RC6 data: 8 address bits + 8 command bits
168 * start bit toggle bit "0": toggle bit "1": data/mode "0": data/mode "1":
169 * ____________------- _______------- -------_______ _______------- -------_______
170 * 2666us 889us 889us 889us 889us 889us 444us 444us 444us 444us
172 *---------------------------------------------------------------------------------------------------------------------------------------------------
177 * frame: 1 start bit + 32 data bits + 1 stop bit
178 * data: 16 address bits + 11100000 + 8 command bits
180 * start bit: data "0": data "1": stop bit:
181 * -----------------_________ ------______ ------________________ ------______....
182 * 9000us 4500us 560us 560us 560us 1690 us 560us
184 *---------------------------------------------------------------------------------------------------------------------------------------------------
186 * NUBERT (subwoofer system)
187 * -------------------------
189 * frame: 1 start bit + 10 data bits + 1 stop bit
190 * data: 0 address bits + 10 command bits ?
192 * start bit: data "0": data "1": stop bit:
193 * ----------_____ ------______ ------________________ ------______....
194 * 1340us 340us 500us 1300us 1340us 340us 500us
196 *---------------------------------------------------------------------------------------------------------------------------------------------------
201 * frame: 4 start bits + 16 data bits + 1 trailer bit + 1 stop bit
202 * data: 0 address bits + 16 command bits
204 * 1st start bit: 2nd start bit: 3rd start bit: 4th start bit:
205 * -----________ -----________ -----_____________ -----________
206 * 210us 3000us 210us 3000us 210us 15000us 210us 3000us
208 * data "0": data "1": data "repeat bit": trailer bit: stop bit:
209 * -----________ -----_____________ -----___________ -----_____________ -----____...
210 * 210us 3000us 210us 9000us 210us 6000us 210us 12000us 210us
212 *---------------------------------------------------------------------------------------------------------------------------------------------------
217 * packet: 1 start frame + 19,968ms pause + N info frames + 117,76ms pause + 1 stop frame
218 * frame: 1 pre bit + 1 start bit + 9 data bits + no stop bit
219 * pause between info frames: 117,76ms
221 * data of start frame: 9 x 1
222 * data of info frame: 9 command bits
223 * data of stop frame: 9 x 1
225 * pre bit: start bit data "0": data "1":
226 * ------____________ ------______ ______------ ------______
227 * 528us 2639us 528us 528us 528us 528us 528us 528us
229 *---------------------------------------------------------------------------------------------------------------------------------------------------
234 * Timing similar to Grundig, but 16 data bits:
235 * frame: 1 pre bit + 1 start bit + 8 command bits + 8 address bits + no stop bit
237 *---------------------------------------------------------------------------------------------------------------------------------------------------
242 * SIEMENS frame: 1 start bit + 22 data bits + no stop bit
243 * SIEMENS data: 13 address bits + 1 repeat bit + 7 data bits + 1 unknown bit
245 * start bit data "0": data "1":
246 * -------_______ _______------- -------_______
247 * 250us 250us 250us 250us 250us 250us
249 *---------------------------------------------------------------------------------------------------------------------------------------------------
251 * PANASONIC (older protocol, yet not implemented, see also MATSUSHITA, timing very similar)
252 * -----------------------------------------------------------------------------------------
254 * frame: 1 start bit + 22 data bits + 1 stop bit
255 * 22 data bits = 5 custom bits + 6 data bits + 5 inverted custom bits + 6 inverted data bits
257 * European version: T = 456us
258 * USA & Canada version: T = 422us
260 * start bit: data "0": data "1": stop bit:
261 * 8T 8T 2T 2T 2T 6T 2T
262 * -------------____________ ------_____ ------_____________ ------_______....
263 * 3648us 3648us 912us 912us 912us 2736us 912us (Europe)
264 * 3376us 3376us 844us 844us 844us 2532us 844us (US)
266 *---------------------------------------------------------------------------------------------------------------------------------------------------
268 * This program is free software; you can redistribute it and/or modify
269 * it under the terms of the GNU General Public License as published by
270 * the Free Software Foundation; either version 2 of the License, or
271 * (at your option) any later version.
272 *---------------------------------------------------------------------------------------------------------------------------------------------------
275 #if defined(__PCM__) || defined(__PCB__) || defined(__PCH__) // CCS PIC Compiler instead of AVR
276 #define PIC_CCS_COMPILER
279 #ifdef unix // test on linux/unix
284 #include <inttypes.h>
288 #define memcpy_P memcpy
295 typedef unsigned char uint8_t;
296 typedef unsigned short uint16_t;
299 #define memcpy_P memcpy
305 #ifdef PIC_CCS_COMPILER
308 typedef unsigned int8
uint8_t;
309 typedef unsigned int16
uint16_t;
311 #define memcpy_P memcpy
315 #include <inttypes.h>
319 #include <util/delay.h>
320 #include <avr/pgmspace.h>
322 #endif // PIC_CCS_COMPILER
329 #ifndef IRMP_USE_AS_LIB
330 #include "irmpconfig.h"
333 #if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1 || IRMP_SUPPORT_NOKIA_PROTOCOL == 1
334 #define IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL 1
336 #define IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL 0
339 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 || IRMP_SUPPORT_RC6_PROTOCOL == 1 || IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1 || IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
340 #define IRMP_SUPPORT_MANCHESTER 1
342 #define IRMP_SUPPORT_MANCHESTER 0
345 #define IRMP_TIMEOUT_TIME 16500.0e-6 // timeout after 16.5 ms darkness
346 #define IRMP_TIMEOUT_TIME_MS 16500L // timeout after 16.5 ms darkness
348 #if (F_INTERRUPTS * IRMP_TIMEOUT_TIME_MS) / 1000000 >= 254
349 typedef uint16_t PAUSE_LEN
;
351 typedef uint8_t PAUSE_LEN
;
354 #define IRMP_TIMEOUT_LEN (PAUSE_LEN)(F_INTERRUPTS * IRMP_TIMEOUT_TIME + 0.5)
355 #define IRMP_KEY_REPETITION_LEN (uint16_t)(F_INTERRUPTS * 150.0e-3 + 0.5) // autodetect key repetition within 150 msec
357 #define MIN_TOLERANCE_00 1.0 // -0%
358 #define MAX_TOLERANCE_00 1.0 // +0%
360 #define MIN_TOLERANCE_05 0.95 // -5%
361 #define MAX_TOLERANCE_05 1.05 // +5%
363 #define MIN_TOLERANCE_10 0.9 // -10%
364 #define MAX_TOLERANCE_10 1.1 // +10%
366 #define MIN_TOLERANCE_15 0.85 // -15%
367 #define MAX_TOLERANCE_15 1.15 // +15%
369 #define MIN_TOLERANCE_20 0.8 // -20%
370 #define MAX_TOLERANCE_20 1.2 // +20%
372 #define MIN_TOLERANCE_30 0.7 // -30%
373 #define MAX_TOLERANCE_30 1.3 // +30%
375 #define MIN_TOLERANCE_40 0.6 // -40%
376 #define MAX_TOLERANCE_40 1.4 // +40%
378 #define MIN_TOLERANCE_50 0.5 // -50%
379 #define MAX_TOLERANCE_50 1.5 // +50%
381 #define MIN_TOLERANCE_60 0.4 // -60%
382 #define MAX_TOLERANCE_60 1.6 // +60%
384 #define SIRCS_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIRCS_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
385 #define SIRCS_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIRCS_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
386 #define SIRCS_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIRCS_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
387 #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
388 #define SIRCS_1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIRCS_1_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
389 #define SIRCS_1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIRCS_1_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
390 #define SIRCS_0_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIRCS_0_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
391 #define SIRCS_0_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIRCS_0_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
392 #define SIRCS_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIRCS_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
393 #define SIRCS_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIRCS_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
395 #define NEC_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_START_BIT_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
396 #define NEC_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_START_BIT_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
397 #define NEC_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_START_BIT_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
398 #define NEC_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_START_BIT_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
399 #define NEC_REPEAT_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_REPEAT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
400 #define NEC_REPEAT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_REPEAT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
401 #define NEC_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
402 #define NEC_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
403 #define NEC_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
404 #define NEC_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
405 #define NEC_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NEC_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
406 #define NEC_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NEC_0_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
407 // autodetect nec repetition frame within 50 msec:
408 // NEC seems to send the first repetition frame after 40ms, further repetition frames after 100 ms
410 #define NEC_FRAME_REPEAT_PAUSE_LEN_MAX (uint16_t)(F_INTERRUPTS * NEC_FRAME_REPEAT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5)
412 #define NEC_FRAME_REPEAT_PAUSE_LEN_MAX (uint16_t)(F_INTERRUPTS * 100.0e-3 * MAX_TOLERANCE_20 + 0.5)
415 #define SAMSUNG_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
416 #define SAMSUNG_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
417 #define SAMSUNG_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
418 #define SAMSUNG_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
419 #define SAMSUNG_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
420 #define SAMSUNG_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
421 #define SAMSUNG_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
422 #define SAMSUNG_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
423 #define SAMSUNG_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
424 #define SAMSUNG_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
426 #define MATSUSHITA_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
427 #define MATSUSHITA_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
428 #define MATSUSHITA_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
429 #define MATSUSHITA_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
430 #define MATSUSHITA_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
431 #define MATSUSHITA_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
432 #define MATSUSHITA_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
433 #define MATSUSHITA_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
434 #define MATSUSHITA_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
435 #define MATSUSHITA_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_0_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
437 #define KASEIKYO_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
438 #define KASEIKYO_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
439 #define KASEIKYO_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
440 #define KASEIKYO_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
441 #define KASEIKYO_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_PULSE_TIME * MIN_TOLERANCE_50 + 0.5) - 1)
442 #define KASEIKYO_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_PULSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
443 #define KASEIKYO_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
444 #define KASEIKYO_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
445 #define KASEIKYO_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_0_PAUSE_TIME * MIN_TOLERANCE_50 + 0.5) - 1)
446 #define KASEIKYO_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_0_PAUSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
448 #define RECS80_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PULSE_TIME * MIN_TOLERANCE_00 + 0.5) - 1)
449 #define RECS80_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
450 #define RECS80_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
451 #define RECS80_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
452 #define RECS80_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
453 #define RECS80_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
454 #define RECS80_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
455 #define RECS80_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
456 #define RECS80_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
457 #define RECS80_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
459 #define RC5_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
460 #define RC5_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
461 #define RC5_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
462 #define RC5_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
464 #define DENON_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
465 #define DENON_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
466 #define DENON_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
467 #define DENON_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
468 #define DENON_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
469 #define DENON_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
471 #define RC6_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
472 #define RC6_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
473 #define RC6_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
474 #define RC6_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
475 #define RC6_TOGGLE_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_TOGGLE_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
476 #define RC6_TOGGLE_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_TOGGLE_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
477 #define RC6_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
478 #define RC6_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
480 #define RECS80EXT_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PULSE_TIME * MIN_TOLERANCE_00 + 0.5) - 1)
481 #define RECS80EXT_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PULSE_TIME * MAX_TOLERANCE_00 + 0.5) + 1)
482 #define RECS80EXT_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
483 #define RECS80EXT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
484 #define RECS80EXT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
485 #define RECS80EXT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
486 #define RECS80EXT_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
487 #define RECS80EXT_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
488 #define RECS80EXT_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
489 #define RECS80EXT_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
491 #define NUBERT_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
492 #define NUBERT_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
493 #define NUBERT_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
494 #define NUBERT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
495 #define NUBERT_1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_1_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
496 #define NUBERT_1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_1_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
497 #define NUBERT_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
498 #define NUBERT_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
499 #define NUBERT_0_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_0_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
500 #define NUBERT_0_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_0_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
501 #define NUBERT_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
502 #define NUBERT_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
504 #define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
505 #define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
506 #define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
507 #define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
508 #define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
509 #define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
510 #define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
511 #define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
512 #define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
513 #define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
514 #define BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
515 #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
516 #define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
517 #define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
518 #define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
519 #define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
520 #define BANG_OLUFSEN_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
521 #define BANG_OLUFSEN_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
522 #define BANG_OLUFSEN_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
523 #define BANG_OLUFSEN_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
524 #define BANG_OLUFSEN_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
525 #define BANG_OLUFSEN_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
526 #define BANG_OLUFSEN_R_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
527 #define BANG_OLUFSEN_R_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
528 #define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
529 #define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
531 #define GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
532 #define GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
533 #define GRUNDIG_OR_NOKIA_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
534 #define GRUNDIG_OR_NOKIA_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
535 #define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) + 1)
536 #define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
538 #define SIEMENS_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) - 1)
539 #define SIEMENS_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) + 1)
540 #define SIEMENS_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) - 1)
541 #define SIEMENS_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) + 1)
543 #define FDC_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
544 #define FDC_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
545 #define FDC_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
546 #define FDC_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
547 #define FDC_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
548 #define FDC_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
549 #define FDC_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
550 #define FDC_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
552 #define FDC_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1) // could be negative: 255
554 #define FDC_0_PAUSE_LEN_MIN (1) // simply use 1
556 #define FDC_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
558 #define RCCAR_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
559 #define RCCAR_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
560 #define RCCAR_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
561 #define RCCAR_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
562 #define RCCAR_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
563 #define RCCAR_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
564 #define RCCAR_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
565 #define RCCAR_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
566 #define RCCAR_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
567 #define RCCAR_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
569 #define JVC_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * JVC_START_BIT_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
570 #define JVC_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * JVC_START_BIT_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
571 #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!
572 #define JVC_REPEAT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * (JVC_FRAME_REPEAT_PAUSE_TIME - IRMP_TIMEOUT_TIME) * MAX_TOLERANCE_40 + 0.5) - 1) // HACK!
573 #define JVC_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * JVC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
574 #define JVC_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * JVC_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
575 #define JVC_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * JVC_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
576 #define JVC_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * JVC_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
577 #define JVC_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * JVC_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
578 #define JVC_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * JVC_0_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
579 // autodetect JVC repetition frame within 50 msec:
580 #define JVC_FRAME_REPEAT_PAUSE_LEN_MAX (uint16_t)(F_INTERRUPTS * JVC_FRAME_REPEAT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5)
582 #define AUTO_FRAME_REPETITION_LEN (uint16_t)(F_INTERRUPTS * AUTO_FRAME_REPETITION_TIME + 0.5) // use uint16_t!
585 #define ANALYZE_PUTCHAR(a) { if (! silent) { putchar (a); } }
586 #define ANALYZE_ONLY_NORMAL_PUTCHAR(a) { if (! silent && !verbose) { putchar (a); } }
587 #define ANALYZE_PRINTF(...) { if (verbose) { printf (__VA_ARGS__); } }
588 #define ANALYZE_NEWLINE() { if (verbose) { putchar ('\n'); } }
590 static int time_counter
;
593 #define ANALYZE_PUTCHAR(a)
594 #define ANALYZE_ONLY_NORMAL_PUTCHAR(a)
595 #define ANALYZE_PRINTF(...)
596 #define ANALYZE_NEWLINE()
599 #if IRMP_LOGGING == 1
601 #include <util/setbaud.h>
605 #define UART0_UBRRH UBRR0H
606 #define UART0_UBRRL UBRR0L
607 #define UART0_UCSRA UCSR0A
608 #define UART0_UCSRB UCSR0B
609 #define UART0_UCSRC UCSR0C
610 #define UART0_UDRE_BIT_VALUE (1<<UDRE0)
611 #define UART0_UCSZ1_BIT_VALUE (1<<UCSZ01)
612 #define UART0_UCSZ0_BIT_VALUE (1<<UCSZ00)
614 #define UART0_URSEL_BIT_VALUE (1<<URSEL0)
616 #define UART0_URSEL_BIT_VALUE (0)
618 #define UART0_TXEN_BIT_VALUE (1<<TXEN0)
619 #define UART0_UDR UDR0
623 #define UART0_UBRRH UBRRH
624 #define UART0_UBRRL UBRRL
625 #define UART0_UCSRA UCSRA
626 #define UART0_UCSRB UCSRB
627 #define UART0_UCSRC UCSRC
628 #define UART0_UDRE_BIT_VALUE (1<<UDRE)
629 #define UART0_UCSZ1_BIT_VALUE (1<<UCSZ1)
630 #define UART0_UCSZ0_BIT_VALUE (1<<UCSZ0)
632 #define UART0_URSEL_BIT_VALUE (1<<URSEL)
634 #define UART0_URSEL_BIT_VALUE (0)
636 #define UART0_TXEN_BIT_VALUE (1<<TXEN)
637 #define UART0_UDR UDR
641 /*---------------------------------------------------------------------------------------------------------------------------------------------------
643 * @details Initializes UART
644 *---------------------------------------------------------------------------------------------------------------------------------------------------
647 irmp_uart_init (void)
649 UART0_UBRRH
= UBRRH_VALUE
; // set baud rate
650 UART0_UBRRL
= UBRRL_VALUE
;
653 UART0_UCSRA
|= (1<<U2X
);
655 UART0_UCSRA
&= ~(1<<U2X
);
658 UART0_UCSRC
= UART0_UCSZ1_BIT_VALUE
| UART0_UCSZ0_BIT_VALUE
| UART0_URSEL_BIT_VALUE
;
659 UART0_UCSRB
|= UART0_TXEN_BIT_VALUE
; // enable UART TX
662 /*---------------------------------------------------------------------------------------------------------------------------------------------------
664 * @details Sends character
665 * @param ch character to be transmitted
666 *---------------------------------------------------------------------------------------------------------------------------------------------------
669 irmp_uart_putc (unsigned char ch
)
671 while (!(UART0_UCSRA
& UART0_UDRE_BIT_VALUE
))
679 /*---------------------------------------------------------------------------------------------------------------------------------------------------
681 *---------------------------------------------------------------------------------------------------------------------------------------------------
684 #define STARTCYCLES 2 // min count of zeros before start of logging
685 #define ENDBITS 1000 // number of sequenced highbits to detect end
686 #define DATALEN 700 // log buffer size
689 irmp_log (uint8_t val
)
691 static uint8_t buf
[DATALEN
]; // logging buffer
692 static uint16_t buf_idx
; // number of written bits
693 static uint8_t startcycles
; // current number of start-zeros
694 static uint16_t cnt
; // counts sequenced highbits - to detect end
696 if (! val
&& (startcycles
< STARTCYCLES
) && !buf_idx
) // prevent that single random zeros init logging
704 if (! val
|| (val
&& buf_idx
!= 0)) // start or continue logging on "0", "1" cannot init logging
706 if (buf_idx
< DATALEN
* 8) // index in range?
710 buf
[(buf_idx
/ 8)] |= (1<<(buf_idx
% 8)); // set bit
714 buf
[(buf_idx
/ 8)] &= ~(1<<(buf_idx
% 8)); // reset bit
721 { // if high received then look at log-stop condition
725 { // if stop condition is true, output on uart
728 for (i
= 0; i
< STARTCYCLES
; i
++)
730 irmp_uart_putc ('0'); // the ignored starting zeros
733 for (i
= 0; i
< (buf_idx
- ENDBITS
+ 20) / 8; i
++) // transform bitset into uart chars
738 for (j
= 0; j
< 8; j
++)
740 irmp_uart_putc ((d
& 1) + '0');
745 irmp_uart_putc ('\n');
758 #define irmp_log(val)
763 uint8_t protocol
; // ir protocol
764 uint8_t pulse_1_len_min
; // minimum length of pulse with bit value 1
765 uint8_t pulse_1_len_max
; // maximum length of pulse with bit value 1
766 uint8_t pause_1_len_min
; // minimum length of pause with bit value 1
767 uint8_t pause_1_len_max
; // maximum length of pause with bit value 1
768 uint8_t pulse_0_len_min
; // minimum length of pulse with bit value 0
769 uint8_t pulse_0_len_max
; // maximum length of pulse with bit value 0
770 uint8_t pause_0_len_min
; // minimum length of pause with bit value 0
771 uint8_t pause_0_len_max
; // maximum length of pause with bit value 0
772 uint8_t address_offset
; // address offset
773 uint8_t address_end
; // end of address
774 uint8_t command_offset
; // command offset
775 uint8_t command_end
; // end of command
776 uint8_t complete_len
; // complete length of frame
777 uint8_t stop_bit
; // flag: frame has stop bit
778 uint8_t lsb_first
; // flag: LSB first
779 uint8_t flags
; // some flags
782 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
784 static PROGMEM IRMP_PARAMETER sircs_param
=
786 IRMP_SIRCS_PROTOCOL
, // protocol: ir protocol
787 SIRCS_1_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
788 SIRCS_1_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
789 SIRCS_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
790 SIRCS_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
791 SIRCS_0_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
792 SIRCS_0_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
793 SIRCS_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
794 SIRCS_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
795 SIRCS_ADDRESS_OFFSET
, // address_offset: address offset
796 SIRCS_ADDRESS_OFFSET
+ SIRCS_ADDRESS_LEN
, // address_end: end of address
797 SIRCS_COMMAND_OFFSET
, // command_offset: command offset
798 SIRCS_COMMAND_OFFSET
+ SIRCS_COMMAND_LEN
, // command_end: end of command
799 SIRCS_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
800 SIRCS_STOP_BIT
, // stop_bit: flag: frame has stop bit
801 SIRCS_LSB
, // lsb_first: flag: LSB first
802 SIRCS_FLAGS
// flags: some flags
807 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
809 static PROGMEM IRMP_PARAMETER nec_param
=
811 IRMP_NEC_PROTOCOL
, // protocol: ir protocol
812 NEC_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
813 NEC_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
814 NEC_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
815 NEC_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
816 NEC_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
817 NEC_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
818 NEC_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
819 NEC_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
820 NEC_ADDRESS_OFFSET
, // address_offset: address offset
821 NEC_ADDRESS_OFFSET
+ NEC_ADDRESS_LEN
, // address_end: end of address
822 NEC_COMMAND_OFFSET
, // command_offset: command offset
823 NEC_COMMAND_OFFSET
+ NEC_COMMAND_LEN
, // command_end: end of command
824 NEC_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
825 NEC_STOP_BIT
, // stop_bit: flag: frame has stop bit
826 NEC_LSB
, // lsb_first: flag: LSB first
827 NEC_FLAGS
// flags: some flags
830 static PROGMEM IRMP_PARAMETER nec_rep_param
=
832 IRMP_NEC_PROTOCOL
, // protocol: ir protocol
833 NEC_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
834 NEC_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
835 NEC_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
836 NEC_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
837 NEC_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
838 NEC_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
839 NEC_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
840 NEC_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
841 0, // address_offset: address offset
842 0, // address_end: end of address
843 0, // command_offset: command offset
844 0, // command_end: end of command
845 0, // complete_len: complete length of frame
846 NEC_STOP_BIT
, // stop_bit: flag: frame has stop bit
847 NEC_LSB
, // lsb_first: flag: LSB first
848 NEC_FLAGS
// flags: some flags
853 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
855 static PROGMEM IRMP_PARAMETER samsung_param
=
857 IRMP_SAMSUNG_PROTOCOL
, // protocol: ir protocol
858 SAMSUNG_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
859 SAMSUNG_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
860 SAMSUNG_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
861 SAMSUNG_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
862 SAMSUNG_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
863 SAMSUNG_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
864 SAMSUNG_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
865 SAMSUNG_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
866 SAMSUNG_ADDRESS_OFFSET
, // address_offset: address offset
867 SAMSUNG_ADDRESS_OFFSET
+ SAMSUNG_ADDRESS_LEN
, // address_end: end of address
868 SAMSUNG_COMMAND_OFFSET
, // command_offset: command offset
869 SAMSUNG_COMMAND_OFFSET
+ SAMSUNG_COMMAND_LEN
, // command_end: end of command
870 SAMSUNG_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
871 SAMSUNG_STOP_BIT
, // stop_bit: flag: frame has stop bit
872 SAMSUNG_LSB
, // lsb_first: flag: LSB first
873 SAMSUNG_FLAGS
// flags: some flags
878 #if IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
880 static PROGMEM IRMP_PARAMETER matsushita_param
=
882 IRMP_MATSUSHITA_PROTOCOL
, // protocol: ir protocol
883 MATSUSHITA_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
884 MATSUSHITA_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
885 MATSUSHITA_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
886 MATSUSHITA_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
887 MATSUSHITA_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
888 MATSUSHITA_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
889 MATSUSHITA_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
890 MATSUSHITA_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
891 MATSUSHITA_ADDRESS_OFFSET
, // address_offset: address offset
892 MATSUSHITA_ADDRESS_OFFSET
+ MATSUSHITA_ADDRESS_LEN
, // address_end: end of address
893 MATSUSHITA_COMMAND_OFFSET
, // command_offset: command offset
894 MATSUSHITA_COMMAND_OFFSET
+ MATSUSHITA_COMMAND_LEN
, // command_end: end of command
895 MATSUSHITA_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
896 MATSUSHITA_STOP_BIT
, // stop_bit: flag: frame has stop bit
897 MATSUSHITA_LSB
, // lsb_first: flag: LSB first
898 MATSUSHITA_FLAGS
// flags: some flags
903 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
905 static PROGMEM IRMP_PARAMETER kaseikyo_param
=
907 IRMP_KASEIKYO_PROTOCOL
, // protocol: ir protocol
908 KASEIKYO_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
909 KASEIKYO_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
910 KASEIKYO_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
911 KASEIKYO_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
912 KASEIKYO_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
913 KASEIKYO_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
914 KASEIKYO_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
915 KASEIKYO_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
916 KASEIKYO_ADDRESS_OFFSET
, // address_offset: address offset
917 KASEIKYO_ADDRESS_OFFSET
+ KASEIKYO_ADDRESS_LEN
, // address_end: end of address
918 KASEIKYO_COMMAND_OFFSET
, // command_offset: command offset
919 KASEIKYO_COMMAND_OFFSET
+ KASEIKYO_COMMAND_LEN
, // command_end: end of command
920 KASEIKYO_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
921 KASEIKYO_STOP_BIT
, // stop_bit: flag: frame has stop bit
922 KASEIKYO_LSB
, // lsb_first: flag: LSB first
923 KASEIKYO_FLAGS
// flags: some flags
928 #if IRMP_SUPPORT_RECS80_PROTOCOL == 1
930 static PROGMEM IRMP_PARAMETER recs80_param
=
932 IRMP_RECS80_PROTOCOL
, // protocol: ir protocol
933 RECS80_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
934 RECS80_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
935 RECS80_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
936 RECS80_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
937 RECS80_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
938 RECS80_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
939 RECS80_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
940 RECS80_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
941 RECS80_ADDRESS_OFFSET
, // address_offset: address offset
942 RECS80_ADDRESS_OFFSET
+ RECS80_ADDRESS_LEN
, // address_end: end of address
943 RECS80_COMMAND_OFFSET
, // command_offset: command offset
944 RECS80_COMMAND_OFFSET
+ RECS80_COMMAND_LEN
, // command_end: end of command
945 RECS80_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
946 RECS80_STOP_BIT
, // stop_bit: flag: frame has stop bit
947 RECS80_LSB
, // lsb_first: flag: LSB first
948 RECS80_FLAGS
// flags: some flags
953 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
955 static PROGMEM IRMP_PARAMETER rc5_param
=
957 IRMP_RC5_PROTOCOL
, // protocol: ir protocol
958 RC5_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
959 RC5_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
960 RC5_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
961 RC5_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
962 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
963 1, // pulse_0_len_max: maximum length of pulse with bit value 0
964 1, // pause_0_len_min: minimum length of pause with bit value 0
965 1, // pause_0_len_max: maximum length of pause with bit value 0
966 RC5_ADDRESS_OFFSET
, // address_offset: address offset
967 RC5_ADDRESS_OFFSET
+ RC5_ADDRESS_LEN
, // address_end: end of address
968 RC5_COMMAND_OFFSET
, // command_offset: command offset
969 RC5_COMMAND_OFFSET
+ RC5_COMMAND_LEN
, // command_end: end of command
970 RC5_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
971 RC5_STOP_BIT
, // stop_bit: flag: frame has stop bit
972 RC5_LSB
, // lsb_first: flag: LSB first
973 RC5_FLAGS
// flags: some flags
978 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
980 static PROGMEM IRMP_PARAMETER denon_param
=
982 IRMP_DENON_PROTOCOL
, // protocol: ir protocol
983 DENON_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
984 DENON_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
985 DENON_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
986 DENON_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
987 DENON_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
988 DENON_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
989 DENON_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
990 DENON_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
991 DENON_ADDRESS_OFFSET
, // address_offset: address offset
992 DENON_ADDRESS_OFFSET
+ DENON_ADDRESS_LEN
, // address_end: end of address
993 DENON_COMMAND_OFFSET
, // command_offset: command offset
994 DENON_COMMAND_OFFSET
+ DENON_COMMAND_LEN
, // command_end: end of command
995 DENON_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
996 DENON_STOP_BIT
, // stop_bit: flag: frame has stop bit
997 DENON_LSB
, // lsb_first: flag: LSB first
998 DENON_FLAGS
// flags: some flags
1003 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
1005 static PROGMEM IRMP_PARAMETER rc6_param
=
1007 IRMP_RC6_PROTOCOL
, // protocol: ir protocol
1008 RC6_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1009 RC6_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1010 RC6_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1011 RC6_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1012 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1013 1, // pulse_0_len_max: maximum length of pulse with bit value 0
1014 1, // pause_0_len_min: minimum length of pause with bit value 0
1015 1, // pause_0_len_max: maximum length of pause with bit value 0
1016 RC6_ADDRESS_OFFSET
, // address_offset: address offset
1017 RC6_ADDRESS_OFFSET
+ RC6_ADDRESS_LEN
, // address_end: end of address
1018 RC6_COMMAND_OFFSET
, // command_offset: command offset
1019 RC6_COMMAND_OFFSET
+ RC6_COMMAND_LEN
, // command_end: end of command
1020 RC6_COMPLETE_DATA_LEN_SHORT
, // complete_len: complete length of frame
1021 RC6_STOP_BIT
, // stop_bit: flag: frame has stop bit
1022 RC6_LSB
, // lsb_first: flag: LSB first
1023 RC6_FLAGS
// flags: some flags
1028 #if IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
1030 static PROGMEM IRMP_PARAMETER recs80ext_param
=
1032 IRMP_RECS80EXT_PROTOCOL
, // protocol: ir protocol
1033 RECS80EXT_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1034 RECS80EXT_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1035 RECS80EXT_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1036 RECS80EXT_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1037 RECS80EXT_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1038 RECS80EXT_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1039 RECS80EXT_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1040 RECS80EXT_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1041 RECS80EXT_ADDRESS_OFFSET
, // address_offset: address offset
1042 RECS80EXT_ADDRESS_OFFSET
+ RECS80EXT_ADDRESS_LEN
, // address_end: end of address
1043 RECS80EXT_COMMAND_OFFSET
, // command_offset: command offset
1044 RECS80EXT_COMMAND_OFFSET
+ RECS80EXT_COMMAND_LEN
, // command_end: end of command
1045 RECS80EXT_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1046 RECS80EXT_STOP_BIT
, // stop_bit: flag: frame has stop bit
1047 RECS80EXT_LSB
, // lsb_first: flag: LSB first
1048 RECS80EXT_FLAGS
// flags: some flags
1053 #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
1055 static PROGMEM IRMP_PARAMETER nubert_param
=
1057 IRMP_NUBERT_PROTOCOL
, // protocol: ir protocol
1058 NUBERT_1_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1059 NUBERT_1_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1060 NUBERT_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1061 NUBERT_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1062 NUBERT_0_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1063 NUBERT_0_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1064 NUBERT_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1065 NUBERT_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1066 NUBERT_ADDRESS_OFFSET
, // address_offset: address offset
1067 NUBERT_ADDRESS_OFFSET
+ NUBERT_ADDRESS_LEN
, // address_end: end of address
1068 NUBERT_COMMAND_OFFSET
, // command_offset: command offset
1069 NUBERT_COMMAND_OFFSET
+ NUBERT_COMMAND_LEN
, // command_end: end of command
1070 NUBERT_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1071 NUBERT_STOP_BIT
, // stop_bit: flag: frame has stop bit
1072 NUBERT_LSB
, // lsb_first: flag: LSB first
1073 NUBERT_FLAGS
// flags: some flags
1078 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1080 static PROGMEM IRMP_PARAMETER bang_olufsen_param
=
1082 IRMP_BANG_OLUFSEN_PROTOCOL
, // protocol: ir protocol
1083 BANG_OLUFSEN_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1084 BANG_OLUFSEN_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1085 BANG_OLUFSEN_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1086 BANG_OLUFSEN_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1087 BANG_OLUFSEN_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1088 BANG_OLUFSEN_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1089 BANG_OLUFSEN_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1090 BANG_OLUFSEN_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1091 BANG_OLUFSEN_ADDRESS_OFFSET
, // address_offset: address offset
1092 BANG_OLUFSEN_ADDRESS_OFFSET
+ BANG_OLUFSEN_ADDRESS_LEN
, // address_end: end of address
1093 BANG_OLUFSEN_COMMAND_OFFSET
, // command_offset: command offset
1094 BANG_OLUFSEN_COMMAND_OFFSET
+ BANG_OLUFSEN_COMMAND_LEN
, // command_end: end of command
1095 BANG_OLUFSEN_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1096 BANG_OLUFSEN_STOP_BIT
, // stop_bit: flag: frame has stop bit
1097 BANG_OLUFSEN_LSB
, // lsb_first: flag: LSB first
1098 BANG_OLUFSEN_FLAGS
// flags: some flags
1103 #if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1105 static PROGMEM IRMP_PARAMETER grundig_param
=
1107 IRMP_GRUNDIG_PROTOCOL
, // protocol: ir protocol
1108 GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1109 GRUNDIG_OR_NOKIA_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1110 GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1111 GRUNDIG_OR_NOKIA_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1112 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1113 1, // pulse_0_len_max: maximum length of pulse with bit value 0
1114 1, // pause_0_len_min: minimum length of pause with bit value 0
1115 1, // pause_0_len_max: maximum length of pause with bit value 0
1116 GRUNDIG_ADDRESS_OFFSET
, // address_offset: address offset
1117 GRUNDIG_ADDRESS_OFFSET
+ GRUNDIG_ADDRESS_LEN
, // address_end: end of address
1118 GRUNDIG_COMMAND_OFFSET
, // command_offset: command offset
1119 GRUNDIG_COMMAND_OFFSET
+ GRUNDIG_COMMAND_LEN
+ 1, // command_end: end of command (USE 1 bit MORE to STORE NOKIA DATA!)
1120 NOKIA_COMPLETE_DATA_LEN
, // complete_len: complete length of frame, here: NOKIA instead of GRUNDIG!
1121 GRUNDIG_OR_NOKIA_STOP_BIT
, // stop_bit: flag: frame has stop bit
1122 GRUNDIG_OR_NOKIA_LSB
, // lsb_first: flag: LSB first
1123 GRUNDIG_OR_NOKIA_FLAGS
// flags: some flags
1128 #if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
1130 static PROGMEM IRMP_PARAMETER siemens_param
=
1132 IRMP_SIEMENS_PROTOCOL
, // protocol: ir protocol
1133 SIEMENS_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1134 SIEMENS_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1135 SIEMENS_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1136 SIEMENS_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1137 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1138 1, // pulse_0_len_max: maximum length of pulse with bit value 0
1139 1, // pause_0_len_min: minimum length of pause with bit value 0
1140 1, // pause_0_len_max: maximum length of pause with bit value 0
1141 SIEMENS_ADDRESS_OFFSET
, // address_offset: address offset
1142 SIEMENS_ADDRESS_OFFSET
+ SIEMENS_ADDRESS_LEN
, // address_end: end of address
1143 SIEMENS_COMMAND_OFFSET
, // command_offset: command offset
1144 SIEMENS_COMMAND_OFFSET
+ SIEMENS_COMMAND_LEN
, // command_end: end of command
1145 SIEMENS_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1146 SIEMENS_STOP_BIT
, // stop_bit: flag: frame has stop bit
1147 SIEMENS_LSB
, // lsb_first: flag: LSB first
1148 SIEMENS_FLAGS
// flags: some flags
1153 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
1155 static PROGMEM IRMP_PARAMETER fdc_param
=
1157 IRMP_FDC_PROTOCOL
, // protocol: ir protocol
1158 FDC_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1159 FDC_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1160 FDC_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1161 FDC_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1162 FDC_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1163 FDC_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1164 FDC_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1165 FDC_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1166 FDC_ADDRESS_OFFSET
, // address_offset: address offset
1167 FDC_ADDRESS_OFFSET
+ FDC_ADDRESS_LEN
, // address_end: end of address
1168 FDC_COMMAND_OFFSET
, // command_offset: command offset
1169 FDC_COMMAND_OFFSET
+ FDC_COMMAND_LEN
, // command_end: end of command
1170 FDC_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1171 FDC_STOP_BIT
, // stop_bit: flag: frame has stop bit
1172 FDC_LSB
, // lsb_first: flag: LSB first
1173 FDC_FLAGS
// flags: some flags
1178 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1180 static PROGMEM IRMP_PARAMETER rccar_param
=
1182 IRMP_RCCAR_PROTOCOL
, // protocol: ir protocol
1183 RCCAR_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1184 RCCAR_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1185 RCCAR_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1186 RCCAR_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1187 RCCAR_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1188 RCCAR_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1189 RCCAR_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1190 RCCAR_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1191 RCCAR_ADDRESS_OFFSET
, // address_offset: address offset
1192 RCCAR_ADDRESS_OFFSET
+ RCCAR_ADDRESS_LEN
, // address_end: end of address
1193 RCCAR_COMMAND_OFFSET
, // command_offset: command offset
1194 RCCAR_COMMAND_OFFSET
+ RCCAR_COMMAND_LEN
, // command_end: end of command
1195 RCCAR_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1196 RCCAR_STOP_BIT
, // stop_bit: flag: frame has stop bit
1197 RCCAR_LSB
, // lsb_first: flag: LSB first
1198 RCCAR_FLAGS
// flags: some flags
1203 static uint8_t irmp_bit
; // current bit position
1204 static IRMP_PARAMETER irmp_param
;
1206 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1207 static IRMP_PARAMETER irmp_param2
;
1210 static volatile uint8_t irmp_ir_detected
;
1211 static volatile uint8_t irmp_protocol
;
1212 static volatile uint16_t irmp_address
;
1213 static volatile uint16_t irmp_command
;
1214 static volatile uint16_t irmp_id
; // only used for SAMSUNG protocol
1215 static volatile uint8_t irmp_flags
;
1218 static uint8_t IRMP_PIN
;
1221 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1222 * Initialize IRMP decoder
1223 * @details Configures IRMP input pin
1224 *---------------------------------------------------------------------------------------------------------------------------------------------------
1230 #ifndef PIC_CCS_COMPILER
1231 IRMP_PORT
&= ~(1<<IRMP_BIT
); // deactivate pullup
1232 IRMP_DDR
&= ~(1<<IRMP_BIT
); // set pin to input
1233 #endif // PIC_CCS_COMPILER
1235 #if IRMP_LOGGING == 1
1240 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1242 * @details gets decoded IRMP data
1243 * @param pointer in order to store IRMP data
1244 * @return TRUE: successful, FALSE: failed
1245 *---------------------------------------------------------------------------------------------------------------------------------------------------
1248 irmp_get_data (IRMP_DATA
* irmp_data_p
)
1250 uint8_t rtc
= FALSE
;
1252 if (irmp_ir_detected
)
1254 switch (irmp_protocol
)
1256 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1257 case IRMP_SAMSUNG_PROTOCOL
:
1258 if ((irmp_command
>> 8) == (~irmp_command
& 0x00FF))
1260 irmp_command
&= 0xff;
1261 irmp_command
|= irmp_id
<< 8;
1266 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
1267 case IRMP_NEC_PROTOCOL
:
1268 if ((irmp_command
>> 8) == (~irmp_command
& 0x00FF))
1270 irmp_command
&= 0xff;
1273 else if (irmp_address
== 0x87EE)
1275 ANALYZE_PRINTF ("Switching to APPLE protocol\n");
1276 irmp_protocol
= IRMP_APPLE_PROTOCOL
;
1277 irmp_address
= (irmp_command
& 0xFF00) >> 8;
1278 irmp_command
&= 0x00FF;
1283 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1284 case IRMP_RCCAR_PROTOCOL
:
1285 // frame in irmp_data:
1286 // Bit 12 11 10 9 8 7 6 5 4 3 2 1 0
1287 // V D7 D6 D5 D4 D3 D2 D1 D0 A1 A0 C1 C0 // 10 9 8 7 6 5 4 3 2 1 0
1288 irmp_address
= (irmp_command
& 0x000C) >> 2; // addr: 0 0 0 0 0 0 0 0 0 A1 A0
1289 irmp_command
= ((irmp_command
& 0x1000) >> 2) | // V-Bit: V 0 0 0 0 0 0 0 0 0 0
1290 ((irmp_command
& 0x0003) << 8) | // C-Bits: 0 C1 C0 0 0 0 0 0 0 0 0
1291 ((irmp_command
& 0x0FF0) >> 4); // D-Bits: D7 D6 D5 D4 D3 D2 D1 D0
1292 rtc
= TRUE
; // Summe: V C1 C0 D7 D6 D5 D4 D3 D2 D1 D0
1301 irmp_data_p
->protocol
= irmp_protocol
;
1302 irmp_data_p
->address
= irmp_address
;
1303 irmp_data_p
->command
= irmp_command
;
1304 irmp_data_p
->flags
= irmp_flags
;
1310 irmp_ir_detected
= FALSE
;
1316 // these statics must not be volatile, because they are only used by irmp_store_bit(), which is called by irmp_ISR()
1317 static uint16_t irmp_tmp_address
; // ir address
1318 static uint16_t irmp_tmp_command
; // ir command
1320 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1321 static uint16_t irmp_tmp_address2
; // ir address
1322 static uint16_t irmp_tmp_command2
; // ir command
1325 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1326 static uint16_t irmp_tmp_id
; // ir id (only SAMSUNG)
1328 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
1329 static uint8_t xor_check
[6]; // check kaseikyo "parity" bits
1332 static uint8_t irmp_bit
; // current bit position
1334 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1336 * @details store bit in temp address or temp command
1337 * @param value to store: 0 or 1
1338 *---------------------------------------------------------------------------------------------------------------------------------------------------
1340 // verhindert, dass irmp_store_bit() inline compiliert wird:
1341 // static void irmp_store_bit (uint8_t) __attribute__ ((noinline));
1344 irmp_store_bit (uint8_t value
)
1347 if (irmp_bit
>= irmp_param
.address_offset
&& irmp_bit
< irmp_param
.address_end
)
1349 if (irmp_param
.lsb_first
)
1351 irmp_tmp_address
|= (((uint16_t) (value
)) << (irmp_bit
- irmp_param
.address_offset
)); // CV wants cast
1355 irmp_tmp_address
<<= 1;
1356 irmp_tmp_address
|= value
;
1359 else if (irmp_bit
>= irmp_param
.command_offset
&& irmp_bit
< irmp_param
.command_end
)
1361 if (irmp_param
.lsb_first
)
1363 irmp_tmp_command
|= (((uint16_t) (value
)) << (irmp_bit
- irmp_param
.command_offset
)); // CV wants cast
1367 irmp_tmp_command
<<= 1;
1368 irmp_tmp_command
|= value
;
1372 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1373 else if (irmp_param
.protocol
== IRMP_SAMSUNG_PROTOCOL
&& irmp_bit
>= SAMSUNG_ID_OFFSET
&& irmp_bit
< SAMSUNG_ID_OFFSET
+ SAMSUNG_ID_LEN
)
1375 irmp_tmp_id
|= (((uint16_t) (value
)) << (irmp_bit
- SAMSUNG_ID_OFFSET
)); // store with LSB first
1379 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
1380 else if (irmp_param
.protocol
== IRMP_KASEIKYO_PROTOCOL
&& irmp_bit
>= 20 && irmp_bit
< 24)
1382 irmp_tmp_command
|= (((uint16_t) (value
)) << (irmp_bit
- 8)); // store 4 system bits in upper nibble with LSB first
1385 if (irmp_param
.protocol
== IRMP_KASEIKYO_PROTOCOL
&& irmp_bit
< KASEIKYO_COMPLETE_DATA_LEN
)
1389 xor_check
[irmp_bit
/ 8] |= 1 << (irmp_bit
% 8);
1393 xor_check
[irmp_bit
/ 8] &= ~(1 << (irmp_bit
% 8));
1402 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1404 * @details store bit in temp address or temp command
1405 * @param value to store: 0 or 1
1406 *---------------------------------------------------------------------------------------------------------------------------------------------------
1408 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1410 irmp_store_bit2 (uint8_t value
)
1414 if (irmp_param
.protocol
)
1416 irmp_bit2
= irmp_bit
- 2;
1420 irmp_bit2
= irmp_bit
- 1;
1423 if (irmp_bit2
>= irmp_param2
.address_offset
&& irmp_bit2
< irmp_param2
.address_end
)
1425 irmp_tmp_address2
|= (((uint16_t) (value
)) << (irmp_bit2
- irmp_param2
.address_offset
)); // CV wants cast
1427 else if (irmp_bit2
>= irmp_param2
.command_offset
&& irmp_bit2
< irmp_param2
.command_end
)
1429 irmp_tmp_command2
|= (((uint16_t) (value
)) << (irmp_bit2
- irmp_param2
.command_offset
)); // CV wants cast
1432 #endif // IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1434 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1436 * @details ISR routine, called 10000 times per second
1437 *---------------------------------------------------------------------------------------------------------------------------------------------------
1442 static uint8_t irmp_start_bit_detected
; // flag: start bit detected
1443 static uint8_t wait_for_space
; // flag: wait for data bit space
1444 static uint8_t wait_for_start_space
; // flag: wait for start bit space
1445 static uint8_t irmp_pulse_time
; // count bit time for pulse
1446 static PAUSE_LEN irmp_pause_time
; // count bit time for pause
1447 static uint16_t last_irmp_address
= 0xFFFF; // save last irmp address to recognize key repetition
1448 static uint16_t last_irmp_command
= 0xFFFF; // save last irmp command to recognize key repetition
1449 static uint16_t repetition_counter
; // SIRCS repeats frame 2-5 times with 45 ms pause
1450 static uint8_t repetition_frame_number
;
1451 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
1452 static uint16_t last_irmp_denon_command
; // save last irmp command to recognize DENON frame repetition
1454 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
1455 static uint8_t rc5_cmd_bit6
; // bit 6 of RC5 command is the inverted 2nd start bit
1457 #if IRMP_SUPPORT_MANCHESTER == 1
1458 static PAUSE_LEN last_pause
; // last pause value
1460 #if IRMP_SUPPORT_MANCHESTER == 1 || IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1461 static uint8_t last_value
; // last bit value
1463 uint8_t irmp_input
; // input value
1469 irmp_input
= input(IRMP_PIN
);
1471 irmp_log(irmp_input
); // log ir signal, if IRMP_LOGGING defined
1473 if (! irmp_ir_detected
) // ir code already detected?
1475 if (! irmp_start_bit_detected
) // start bit detected?
1477 if (! irmp_input
) // receiving burst?
1480 if (! irmp_pulse_time
)
1482 ANALYZE_PRINTF("%8d [starting pulse]\n", time_counter
);
1485 irmp_pulse_time
++; // increment counter
1489 if (irmp_pulse_time
) // it's dark....
1490 { // set flags for counting the time of darkness...
1491 irmp_start_bit_detected
= 1;
1492 wait_for_start_space
= 1;
1494 irmp_tmp_command
= 0;
1495 irmp_tmp_address
= 0;
1497 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1498 irmp_tmp_command2
= 0;
1499 irmp_tmp_address2
= 0;
1503 irmp_pause_time
= 1; // 1st pause: set to 1, not to 0!
1504 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
1505 rc5_cmd_bit6
= 0; // fm 2010-03-07: bugfix: reset it after incomplete RC5 frame!
1510 if (repetition_counter
< 0xFFFF) // avoid overflow of counter
1512 repetition_counter
++;
1519 if (wait_for_start_space
) // we have received start bit...
1520 { // ...and are counting the time of darkness
1521 if (irmp_input
) // still dark?
1523 irmp_pause_time
++; // increment counter
1525 if (irmp_pause_time
> IRMP_TIMEOUT_LEN
) // timeout?
1527 ANALYZE_PRINTF ("error 1: pause after start bit pulse %d too long: %d\n", irmp_pulse_time
, irmp_pause_time
);
1528 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
1529 irmp_start_bit_detected
= 0; // reset flags, let's wait for another start bit
1530 irmp_pulse_time
= 0;
1531 irmp_pause_time
= 0;
1535 { // receiving first data pulse!
1536 IRMP_PARAMETER
* irmp_param_p
= (IRMP_PARAMETER
*) 0;
1538 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1539 irmp_param2
.protocol
= 0;
1542 ANALYZE_PRINTF ("start-bit: pulse = %d, pause = %d\n", irmp_pulse_time
, irmp_pause_time
);
1544 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
1545 if (irmp_pulse_time
>= SIRCS_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= SIRCS_START_BIT_PULSE_LEN_MAX
&&
1546 irmp_pause_time
>= SIRCS_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= SIRCS_START_BIT_PAUSE_LEN_MAX
)
1548 ANALYZE_PRINTF ("protocol = SIRCS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1549 SIRCS_START_BIT_PULSE_LEN_MIN
, SIRCS_START_BIT_PULSE_LEN_MAX
,
1550 SIRCS_START_BIT_PAUSE_LEN_MIN
, SIRCS_START_BIT_PAUSE_LEN_MAX
);
1551 irmp_param_p
= (IRMP_PARAMETER
*) (IRMP_PARAMETER
*) &sircs_param
;
1554 #endif // IRMP_SUPPORT_SIRCS_PROTOCOL == 1
1556 #if IRMP_SUPPORT_JVC_PROTOCOL == 1
1557 if (irmp_protocol
== IRMP_JVC_PROTOCOL
&& // last protocol was JVC, awaiting repeat frame
1558 irmp_pulse_time
>= JVC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= JVC_START_BIT_PULSE_LEN_MAX
&&
1559 irmp_pause_time
>= JVC_REPEAT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= JVC_REPEAT_START_BIT_PAUSE_LEN_MAX
)
1561 ANALYZE_PRINTF ("protocol = NEC or JVC repeat frame, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1562 JVC_START_BIT_PULSE_LEN_MIN
, JVC_START_BIT_PULSE_LEN_MAX
,
1563 JVC_REPEAT_START_BIT_PAUSE_LEN_MIN
, JVC_REPEAT_START_BIT_PAUSE_LEN_MAX
);
1564 irmp_param_p
= (IRMP_PARAMETER
*) &nec_param
; // tricky: use nec parameters
1567 #endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
1569 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
1570 if (irmp_pulse_time
>= NEC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= NEC_START_BIT_PULSE_LEN_MAX
&&
1571 irmp_pause_time
>= NEC_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= NEC_START_BIT_PAUSE_LEN_MAX
)
1573 ANALYZE_PRINTF ("protocol = NEC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1574 NEC_START_BIT_PULSE_LEN_MIN
, NEC_START_BIT_PULSE_LEN_MAX
,
1575 NEC_START_BIT_PAUSE_LEN_MIN
, NEC_START_BIT_PAUSE_LEN_MAX
);
1576 irmp_param_p
= (IRMP_PARAMETER
*) &nec_param
;
1578 else if (irmp_pulse_time
>= NEC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= NEC_START_BIT_PULSE_LEN_MAX
&&
1579 irmp_pause_time
>= NEC_REPEAT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= NEC_REPEAT_START_BIT_PAUSE_LEN_MAX
)
1581 ANALYZE_PRINTF ("protocol = NEC (repetition frame), start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1582 NEC_START_BIT_PULSE_LEN_MIN
, NEC_START_BIT_PULSE_LEN_MAX
,
1583 NEC_REPEAT_START_BIT_PAUSE_LEN_MIN
, NEC_REPEAT_START_BIT_PAUSE_LEN_MAX
);
1585 irmp_param_p
= (IRMP_PARAMETER
*) &nec_rep_param
;
1588 #endif // IRMP_SUPPORT_NEC_PROTOCOL == 1
1590 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1591 if (irmp_pulse_time
>= SAMSUNG_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_START_BIT_PULSE_LEN_MAX
&&
1592 irmp_pause_time
>= SAMSUNG_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_START_BIT_PAUSE_LEN_MAX
)
1594 ANALYZE_PRINTF ("protocol = SAMSUNG, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1595 SAMSUNG_START_BIT_PULSE_LEN_MIN
, SAMSUNG_START_BIT_PULSE_LEN_MAX
,
1596 SAMSUNG_START_BIT_PAUSE_LEN_MIN
, SAMSUNG_START_BIT_PAUSE_LEN_MAX
);
1597 irmp_param_p
= (IRMP_PARAMETER
*) &samsung_param
;
1600 #endif // IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1602 #if IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
1603 if (irmp_pulse_time
>= MATSUSHITA_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= MATSUSHITA_START_BIT_PULSE_LEN_MAX
&&
1604 irmp_pause_time
>= MATSUSHITA_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= MATSUSHITA_START_BIT_PAUSE_LEN_MAX
)
1605 { // it's MATSUSHITA
1606 ANALYZE_PRINTF ("protocol = MATSUSHITA, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1607 MATSUSHITA_START_BIT_PULSE_LEN_MIN
, MATSUSHITA_START_BIT_PULSE_LEN_MAX
,
1608 MATSUSHITA_START_BIT_PAUSE_LEN_MIN
, MATSUSHITA_START_BIT_PAUSE_LEN_MAX
);
1609 irmp_param_p
= (IRMP_PARAMETER
*) &matsushita_param
;
1612 #endif // IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
1614 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
1615 if (irmp_pulse_time
>= KASEIKYO_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= KASEIKYO_START_BIT_PULSE_LEN_MAX
&&
1616 irmp_pause_time
>= KASEIKYO_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= KASEIKYO_START_BIT_PAUSE_LEN_MAX
)
1618 ANALYZE_PRINTF ("protocol = KASEIKYO, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1619 KASEIKYO_START_BIT_PULSE_LEN_MIN
, KASEIKYO_START_BIT_PULSE_LEN_MAX
,
1620 KASEIKYO_START_BIT_PAUSE_LEN_MIN
, KASEIKYO_START_BIT_PAUSE_LEN_MAX
);
1621 irmp_param_p
= (IRMP_PARAMETER
*) &kaseikyo_param
;
1624 #endif // IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
1626 #if IRMP_SUPPORT_RECS80_PROTOCOL == 1
1627 if (irmp_pulse_time
>= RECS80_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RECS80_START_BIT_PULSE_LEN_MAX
&&
1628 irmp_pause_time
>= RECS80_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RECS80_START_BIT_PAUSE_LEN_MAX
)
1630 ANALYZE_PRINTF ("protocol = RECS80, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1631 RECS80_START_BIT_PULSE_LEN_MIN
, RECS80_START_BIT_PULSE_LEN_MAX
,
1632 RECS80_START_BIT_PAUSE_LEN_MIN
, RECS80_START_BIT_PAUSE_LEN_MAX
);
1633 irmp_param_p
= (IRMP_PARAMETER
*) &recs80_param
;
1636 #endif // IRMP_SUPPORT_RECS80_PROTOCOL == 1
1638 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
1639 if (((irmp_pulse_time
>= RC5_START_BIT_LEN_MIN
&& irmp_pulse_time
<= RC5_START_BIT_LEN_MAX
) ||
1640 (irmp_pulse_time
>= 2 * RC5_START_BIT_LEN_MIN
&& irmp_pulse_time
<= 2 * RC5_START_BIT_LEN_MAX
)) &&
1641 ((irmp_pause_time
>= RC5_START_BIT_LEN_MIN
&& irmp_pause_time
<= RC5_START_BIT_LEN_MAX
) ||
1642 (irmp_pause_time
>= 2 * RC5_START_BIT_LEN_MIN
&& irmp_pause_time
<= 2 * RC5_START_BIT_LEN_MAX
)))
1644 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
1645 if (irmp_pulse_time
>= FDC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_START_BIT_PULSE_LEN_MAX
&&
1646 irmp_pause_time
>= FDC_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_START_BIT_PAUSE_LEN_MAX
)
1648 ANALYZE_PRINTF ("protocol = RC5 or FDC\n");
1649 ANALYZE_PRINTF ("FDC start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1650 FDC_START_BIT_PULSE_LEN_MIN
, FDC_START_BIT_PULSE_LEN_MAX
,
1651 FDC_START_BIT_PAUSE_LEN_MIN
, FDC_START_BIT_PAUSE_LEN_MAX
);
1652 ANALYZE_PRINTF ("RC5 start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1653 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
1654 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
);
1655 memcpy_P (&irmp_param2
, &fdc_param
, sizeof (IRMP_PARAMETER
));
1658 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
1659 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1660 if (irmp_pulse_time
>= RCCAR_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_START_BIT_PULSE_LEN_MAX
&&
1661 irmp_pause_time
>= RCCAR_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_START_BIT_PAUSE_LEN_MAX
)
1663 ANALYZE_PRINTF ("protocol = RC5 or RCCAR\n");
1664 ANALYZE_PRINTF ("RCCAR start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1665 RCCAR_START_BIT_PULSE_LEN_MIN
, RCCAR_START_BIT_PULSE_LEN_MAX
,
1666 RCCAR_START_BIT_PAUSE_LEN_MIN
, RCCAR_START_BIT_PAUSE_LEN_MAX
);
1667 ANALYZE_PRINTF ("RC5 start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1668 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
1669 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
);
1670 memcpy_P (&irmp_param2
, &rccar_param
, sizeof (IRMP_PARAMETER
));
1673 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1675 ANALYZE_PRINTF ("protocol = RC5, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1676 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
1677 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
);
1680 irmp_param_p
= (IRMP_PARAMETER
*) &rc5_param
;
1681 last_pause
= irmp_pause_time
;
1683 if ((irmp_pulse_time
> RC5_START_BIT_LEN_MAX
&& irmp_pulse_time
<= 2 * RC5_START_BIT_LEN_MAX
) ||
1684 (irmp_pause_time
> RC5_START_BIT_LEN_MAX
&& irmp_pause_time
<= 2 * RC5_START_BIT_LEN_MAX
))
1687 rc5_cmd_bit6
= 1<<6;
1695 #endif // IRMP_SUPPORT_RC5_PROTOCOL == 1
1697 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
1698 if ( (irmp_pulse_time
>= DENON_PULSE_LEN_MIN
&& irmp_pulse_time
<= DENON_PULSE_LEN_MAX
) &&
1699 ((irmp_pause_time
>= DENON_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_1_PAUSE_LEN_MAX
) ||
1700 (irmp_pause_time
>= DENON_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_0_PAUSE_LEN_MAX
)))
1702 ANALYZE_PRINTF ("protocol = DENON, start bit timings: pulse: %3d - %3d, pause: %3d - %3d or %3d - %3d\n",
1703 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
,
1704 DENON_1_PAUSE_LEN_MIN
, DENON_1_PAUSE_LEN_MAX
,
1705 DENON_0_PAUSE_LEN_MIN
, DENON_0_PAUSE_LEN_MAX
);
1706 irmp_param_p
= (IRMP_PARAMETER
*) &denon_param
;
1709 #endif // IRMP_SUPPORT_DENON_PROTOCOL == 1
1711 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
1712 if (irmp_pulse_time
>= RC6_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RC6_START_BIT_PULSE_LEN_MAX
&&
1713 irmp_pause_time
>= RC6_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RC6_START_BIT_PAUSE_LEN_MAX
)
1715 ANALYZE_PRINTF ("protocol = RC6, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1716 RC6_START_BIT_PULSE_LEN_MIN
, RC6_START_BIT_PULSE_LEN_MAX
,
1717 RC6_START_BIT_PAUSE_LEN_MIN
, RC6_START_BIT_PAUSE_LEN_MAX
);
1718 irmp_param_p
= (IRMP_PARAMETER
*) &rc6_param
;
1723 #endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
1725 #if IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
1726 if (irmp_pulse_time
>= RECS80EXT_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RECS80EXT_START_BIT_PULSE_LEN_MAX
&&
1727 irmp_pause_time
>= RECS80EXT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RECS80EXT_START_BIT_PAUSE_LEN_MAX
)
1729 ANALYZE_PRINTF ("protocol = RECS80EXT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1730 RECS80EXT_START_BIT_PULSE_LEN_MIN
, RECS80EXT_START_BIT_PULSE_LEN_MAX
,
1731 RECS80EXT_START_BIT_PAUSE_LEN_MIN
, RECS80EXT_START_BIT_PAUSE_LEN_MAX
);
1732 irmp_param_p
= (IRMP_PARAMETER
*) &recs80ext_param
;
1735 #endif // IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
1737 #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
1738 if (irmp_pulse_time
>= NUBERT_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= NUBERT_START_BIT_PULSE_LEN_MAX
&&
1739 irmp_pause_time
>= NUBERT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= NUBERT_START_BIT_PAUSE_LEN_MAX
)
1741 ANALYZE_PRINTF ("protocol = NUBERT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1742 NUBERT_START_BIT_PULSE_LEN_MIN
, NUBERT_START_BIT_PULSE_LEN_MAX
,
1743 NUBERT_START_BIT_PAUSE_LEN_MIN
, NUBERT_START_BIT_PAUSE_LEN_MAX
);
1744 irmp_param_p
= (IRMP_PARAMETER
*) &nubert_param
;
1747 #endif // IRMP_SUPPORT_NUBERT_PROTOCOL == 1
1749 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1750 if (irmp_pulse_time
>= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN
&& irmp_pulse_time
<= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX
&&
1751 irmp_pause_time
>= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX
)
1752 { // it's BANG_OLUFSEN
1753 ANALYZE_PRINTF ("protocol = BANG_OLUFSEN\n");
1754 ANALYZE_PRINTF ("start bit 1 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1755 BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX
,
1756 BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX
);
1757 ANALYZE_PRINTF ("start bit 2 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1758 BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX
,
1759 BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX
);
1760 ANALYZE_PRINTF ("start bit 3 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1761 BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX
,
1762 BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX
);
1763 ANALYZE_PRINTF ("start bit 4 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1764 BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX
,
1765 BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX
);
1766 irmp_param_p
= (IRMP_PARAMETER
*) &bang_olufsen_param
;
1770 #endif // IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1772 #if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1773 if (irmp_pulse_time
>= GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN
&& irmp_pulse_time
<= GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX
&&
1774 irmp_pause_time
>= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN
&& irmp_pause_time
<= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX
)
1776 ANALYZE_PRINTF ("protocol = GRUNDIG, pre bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1777 GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN
, GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX
,
1778 GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN
, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX
);
1779 irmp_param_p
= (IRMP_PARAMETER
*) &grundig_param
;
1780 last_pause
= irmp_pause_time
;
1784 #endif // IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1786 #if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
1787 if (((irmp_pulse_time
>= SIEMENS_START_BIT_LEN_MIN
&& irmp_pulse_time
<= SIEMENS_START_BIT_LEN_MAX
) ||
1788 (irmp_pulse_time
>= 2 * SIEMENS_START_BIT_LEN_MIN
&& irmp_pulse_time
<= 2 * SIEMENS_START_BIT_LEN_MAX
)) &&
1789 ((irmp_pause_time
>= SIEMENS_START_BIT_LEN_MIN
&& irmp_pause_time
<= SIEMENS_START_BIT_LEN_MAX
) ||
1790 (irmp_pause_time
>= 2 * SIEMENS_START_BIT_LEN_MIN
&& irmp_pause_time
<= 2 * SIEMENS_START_BIT_LEN_MAX
)))
1792 ANALYZE_PRINTF ("protocol = SIEMENS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1793 SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
,
1794 SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
);
1795 irmp_param_p
= (IRMP_PARAMETER
*) &siemens_param
;
1796 last_pause
= irmp_pause_time
;
1800 #endif // IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
1801 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
1802 if (irmp_pulse_time
>= FDC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_START_BIT_PULSE_LEN_MAX
&&
1803 irmp_pause_time
>= FDC_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_START_BIT_PAUSE_LEN_MAX
)
1805 ANALYZE_PRINTF ("protocol = FDC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1806 FDC_START_BIT_PULSE_LEN_MIN
, FDC_START_BIT_PULSE_LEN_MAX
,
1807 FDC_START_BIT_PAUSE_LEN_MIN
, FDC_START_BIT_PAUSE_LEN_MAX
);
1808 irmp_param_p
= (IRMP_PARAMETER
*) &fdc_param
;
1811 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
1812 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1813 if (irmp_pulse_time
>= RCCAR_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_START_BIT_PULSE_LEN_MAX
&&
1814 irmp_pause_time
>= RCCAR_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_START_BIT_PAUSE_LEN_MAX
)
1816 ANALYZE_PRINTF ("protocol = RCCAR, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1817 RCCAR_START_BIT_PULSE_LEN_MIN
, RCCAR_START_BIT_PULSE_LEN_MAX
,
1818 RCCAR_START_BIT_PAUSE_LEN_MIN
, RCCAR_START_BIT_PAUSE_LEN_MAX
);
1819 irmp_param_p
= (IRMP_PARAMETER
*) &rccar_param
;
1822 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1824 ANALYZE_PRINTF ("protocol = UNKNOWN\n");
1825 irmp_start_bit_detected
= 0; // wait for another start bit...
1828 if (irmp_start_bit_detected
)
1830 memcpy_P (&irmp_param
, irmp_param_p
, sizeof (IRMP_PARAMETER
));
1833 if (! (irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
))
1835 ANALYZE_PRINTF ("pulse_1: %3d - %3d\n", irmp_param
.pulse_1_len_min
, irmp_param
.pulse_1_len_max
);
1836 ANALYZE_PRINTF ("pause_1: %3d - %3d\n", irmp_param
.pause_1_len_min
, irmp_param
.pause_1_len_max
);
1840 ANALYZE_PRINTF ("pulse: %3d - %3d or %3d - %3d\n", irmp_param
.pulse_1_len_min
, irmp_param
.pulse_1_len_max
,
1841 2 * irmp_param
.pulse_1_len_min
, 2 * irmp_param
.pulse_1_len_max
);
1842 ANALYZE_PRINTF ("pause: %3d - %3d or %3d - %3d\n", irmp_param
.pause_1_len_min
, irmp_param
.pause_1_len_max
,
1843 2 * irmp_param
.pause_1_len_min
, 2 * irmp_param
.pause_1_len_max
);
1846 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1847 if (irmp_param2
.protocol
)
1849 ANALYZE_PRINTF ("pulse_0: %3d - %3d\n", irmp_param2
.pulse_0_len_min
, irmp_param2
.pulse_0_len_max
);
1850 ANALYZE_PRINTF ("pause_0: %3d - %3d\n", irmp_param2
.pause_0_len_min
, irmp_param2
.pause_0_len_max
);
1851 ANALYZE_PRINTF ("pulse_1: %3d - %3d\n", irmp_param2
.pulse_1_len_min
, irmp_param2
.pulse_1_len_max
);
1852 ANALYZE_PRINTF ("pause_1: %3d - %3d\n", irmp_param2
.pause_1_len_min
, irmp_param2
.pause_1_len_max
);
1857 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
1858 if (irmp_param
.protocol
== IRMP_RC6_PROTOCOL
)
1860 ANALYZE_PRINTF ("pulse_toggle: %3d - %3d\n", RC6_TOGGLE_BIT_LEN_MIN
, RC6_TOGGLE_BIT_LEN_MAX
);
1864 if (! (irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
))
1866 ANALYZE_PRINTF ("pulse_0: %3d - %3d\n", irmp_param
.pulse_0_len_min
, irmp_param
.pulse_0_len_max
);
1867 ANALYZE_PRINTF ("pause_0: %3d - %3d\n", irmp_param
.pause_0_len_min
, irmp_param
.pause_0_len_max
);
1870 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1871 if (irmp_param
.protocol
== IRMP_BANG_OLUFSEN_PROTOCOL
)
1873 ANALYZE_PRINTF ("pulse_r: %3d - %3d\n", irmp_param
.pulse_0_len_min
, irmp_param
.pulse_0_len_max
);
1874 ANALYZE_PRINTF ("pause_r: %3d - %3d\n", BANG_OLUFSEN_R_PAUSE_LEN_MIN
, BANG_OLUFSEN_R_PAUSE_LEN_MAX
);
1878 ANALYZE_PRINTF ("command_offset: %2d\n", irmp_param
.command_offset
);
1879 ANALYZE_PRINTF ("command_len: %3d\n", irmp_param
.command_end
- irmp_param
.command_offset
);
1880 ANALYZE_PRINTF ("complete_len: %3d\n", irmp_param
.complete_len
);
1881 ANALYZE_PRINTF ("stop_bit: %3d\n", irmp_param
.stop_bit
);
1887 #if IRMP_SUPPORT_MANCHESTER == 1
1888 if ((irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
) && irmp_param
.protocol
!= IRMP_RC6_PROTOCOL
) // Manchester, but not RC6
1890 if (irmp_pause_time
> irmp_param
.pulse_1_len_max
&& irmp_pause_time
<= 2 * irmp_param
.pulse_1_len_max
)
1892 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1893 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '0' : '1');
1895 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 0 : 1);
1897 else if (! last_value
) // && irmp_pause_time >= irmp_param.pause_1_len_min && irmp_pause_time <= irmp_param.pause_1_len_max)
1899 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1901 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '1' : '0');
1903 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0);
1907 #endif // IRMP_SUPPORT_MANCHESTER == 1
1909 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
1910 if (irmp_param
.protocol
== IRMP_DENON_PROTOCOL
)
1912 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1914 if (irmp_pause_time
>= DENON_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_1_PAUSE_LEN_MAX
)
1915 { // pause timings correct for "1"?
1916 ANALYZE_PUTCHAR ('1'); // yes, store 1
1920 else // if (irmp_pause_time >= DENON_0_PAUSE_LEN_MIN && irmp_pause_time <= DENON_0_PAUSE_LEN_MAX)
1921 { // pause timings correct for "0"?
1922 ANALYZE_PUTCHAR ('0'); // yes, store 0
1928 #endif // IRMP_SUPPORT_DENON_PROTOCOL == 1
1930 ; // else do nothing
1933 irmp_pulse_time
= 1; // set counter to 1, not 0
1934 irmp_pause_time
= 0;
1935 wait_for_start_space
= 0;
1938 else if (wait_for_space
) // the data section....
1939 { // counting the time of darkness....
1940 uint8_t got_light
= FALSE
;
1942 if (irmp_input
) // still dark?
1944 if (irmp_bit
== irmp_param
.complete_len
&& irmp_param
.stop_bit
== 1)
1946 if (irmp_pulse_time
>= irmp_param
.pulse_0_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_0_len_max
)
1949 if (! (irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
))
1951 ANALYZE_PRINTF ("stop bit detected\n");
1954 irmp_param
.stop_bit
= 0;
1958 ANALYZE_PRINTF ("stop bit timing wrong\n");
1960 irmp_start_bit_detected
= 0; // wait for another start bit...
1961 irmp_pulse_time
= 0;
1962 irmp_pause_time
= 0;
1967 irmp_pause_time
++; // increment counter
1969 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
1970 if (irmp_param
.protocol
== IRMP_SIRCS_PROTOCOL
&& // Sony has a variable number of bits:
1971 irmp_pause_time
> SIRCS_PAUSE_LEN_MAX
&& // minimum is 12
1972 irmp_bit
>= 12 - 1) // pause too long?
1973 { // yes, break and close this frame
1974 irmp_param
.complete_len
= irmp_bit
+ 1; // set new complete length
1975 got_light
= TRUE
; // this is a lie, but helps (generates stop bit)
1976 irmp_param
.command_end
= irmp_param
.command_offset
+ irmp_bit
+ 1; // correct command length
1977 irmp_pause_time
= SIRCS_PAUSE_LEN_MAX
- 1; // correct pause length
1981 #if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1982 if (irmp_param
.protocol
== IRMP_GRUNDIG_PROTOCOL
&& !irmp_param
.stop_bit
)
1984 if (irmp_pause_time
> 2 * irmp_param
.pause_1_len_max
&& irmp_bit
>= GRUNDIG_COMPLETE_DATA_LEN
- 2)
1985 { // special manchester decoder
1986 irmp_param
.complete_len
= GRUNDIG_COMPLETE_DATA_LEN
; // correct complete len
1987 got_light
= TRUE
; // this is a lie, but generates a stop bit ;-)
1988 irmp_param
.stop_bit
= TRUE
; // set flag
1990 else if (irmp_bit
>= GRUNDIG_COMPLETE_DATA_LEN
)
1992 ANALYZE_PRINTF ("Switching to NOKIA protocol\n");
1993 irmp_param
.protocol
= IRMP_NOKIA_PROTOCOL
; // change protocol
1994 irmp_param
.address_offset
= NOKIA_ADDRESS_OFFSET
;
1995 irmp_param
.address_end
= NOKIA_ADDRESS_OFFSET
+ NOKIA_ADDRESS_LEN
;
1996 irmp_param
.command_offset
= NOKIA_COMMAND_OFFSET
;
1997 irmp_param
.command_end
= NOKIA_COMMAND_OFFSET
+ NOKIA_COMMAND_LEN
;
1999 if (irmp_tmp_command
& 0x300)
2001 irmp_tmp_address
= (irmp_tmp_command
>> 8);
2002 irmp_tmp_command
&= 0xFF;
2008 #if IRMP_SUPPORT_MANCHESTER == 1
2009 if ((irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
) &&
2010 irmp_pause_time
> 2 * irmp_param
.pause_1_len_max
&& irmp_bit
>= irmp_param
.complete_len
- 2 && !irmp_param
.stop_bit
)
2011 { // special manchester decoder
2012 got_light
= TRUE
; // this is a lie, but generates a stop bit ;-)
2013 irmp_param
.stop_bit
= TRUE
; // set flag
2016 #endif // IRMP_SUPPORT_MANCHESTER == 1
2017 if (irmp_pause_time
> IRMP_TIMEOUT_LEN
) // timeout?
2019 if (irmp_bit
== irmp_param
.complete_len
- 1 && irmp_param
.stop_bit
== 0)
2023 #if IRMP_SUPPORT_JVC_PROTOCOL == 1
2024 else if (irmp_param
.protocol
== IRMP_NEC_PROTOCOL
&& (irmp_bit
== 16 || irmp_bit
== 17)) // it was a JVC stop bit
2026 ANALYZE_PRINTF ("Switching to JVC protocol\n");
2027 irmp_param
.stop_bit
= TRUE
; // set flag
2028 irmp_param
.protocol
= IRMP_JVC_PROTOCOL
; // switch protocol
2029 irmp_param
.complete_len
= irmp_bit
; // patch length: 16 or 17
2030 irmp_tmp_command
= (irmp_tmp_address
>> 4); // set command: upper 12 bits are command bits
2031 irmp_tmp_address
= irmp_tmp_address
& 0x000F; // lower 4 bits are address bits
2032 irmp_start_bit_detected
= 1; // tricky: don't wait for another start bit...
2034 #endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
2037 ANALYZE_PRINTF ("error 2: pause %d after data bit %d too long\n", irmp_pause_time
, irmp_bit
);
2038 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2040 irmp_start_bit_detected
= 0; // wait for another start bit...
2041 irmp_pulse_time
= 0;
2042 irmp_pause_time
= 0;
2054 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2056 #if IRMP_SUPPORT_MANCHESTER == 1
2057 if ((irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
)) // Manchester
2059 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
2060 if (irmp_param
.protocol
== IRMP_RC6_PROTOCOL
&& irmp_bit
>= 3 && irmp_bit
<= 5) // special bits of RC6
2062 if (irmp_pulse_time
> RC6_TOGGLE_BIT_LEN_MAX
&& irmp_pause_time
> RC6_TOGGLE_BIT_LEN_MAX
)
2064 ANALYZE_PUTCHAR ('1');
2068 ANALYZE_PUTCHAR ('0');
2074 #endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
2075 if (irmp_pulse_time
> irmp_param
.pulse_1_len_max
&& irmp_pulse_time
<= 2 * irmp_param
.pulse_1_len_max
)
2077 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '0' : '1');
2078 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 0 : 1 );
2079 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '1' : '0');
2080 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0 );
2081 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
2082 if (! irmp_param2
.protocol
)
2087 last_value
= (irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0;
2089 else if (irmp_pulse_time
>= irmp_param
.pulse_1_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_1_len_max
)
2091 uint8_t manchester_value
;
2093 if (last_pause
> irmp_param
.pause_1_len_max
&& last_pause
<= 2 * irmp_param
.pause_1_len_max
)
2095 manchester_value
= last_value
? 0 : 1;
2096 last_value
= manchester_value
;
2100 manchester_value
= last_value
;
2104 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
2105 if (irmp_param
.protocol
== IRMP_RC6_PROTOCOL
&& irmp_bit
== 1 && manchester_value
== 0) // RC6 mode != 0 ???
2107 irmp_param
.complete_len
= RC6_COMPLETE_DATA_LEN_LONG
;
2109 #endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
2112 ANALYZE_PUTCHAR (manchester_value
+ '0');
2113 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
2114 if (! irmp_param2
.protocol
)
2119 irmp_store_bit (manchester_value
);
2123 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_FDC_PROTOCOL == 1
2124 if (irmp_param2
.protocol
== IRMP_FDC_PROTOCOL
&&
2125 irmp_pulse_time
>= FDC_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_PULSE_LEN_MAX
&&
2126 ((irmp_pause_time
>= FDC_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_1_PAUSE_LEN_MAX
) ||
2127 (irmp_pause_time
>= FDC_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_0_PAUSE_LEN_MAX
)))
2129 ANALYZE_PUTCHAR ('?');
2130 irmp_param
.protocol
= 0; // switch to FDC, see below
2133 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
2134 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2135 if (irmp_param2
.protocol
== IRMP_RCCAR_PROTOCOL
&&
2136 irmp_pulse_time
>= RCCAR_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_PULSE_LEN_MAX
&&
2137 ((irmp_pause_time
>= RCCAR_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_1_PAUSE_LEN_MAX
) ||
2138 (irmp_pause_time
>= RCCAR_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_0_PAUSE_LEN_MAX
)))
2140 ANALYZE_PUTCHAR ('?');
2141 irmp_param
.protocol
= 0; // switch to RCCAR, see below
2144 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2146 ANALYZE_PUTCHAR ('?');
2148 ANALYZE_PRINTF ("error 3 RC5: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2149 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2150 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2151 irmp_pause_time
= 0;
2155 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_FDC_PROTOCOL == 1
2156 if (irmp_param2
.protocol
== IRMP_FDC_PROTOCOL
&& irmp_pulse_time
>= FDC_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_PULSE_LEN_MAX
)
2158 if (irmp_pause_time
>= FDC_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_1_PAUSE_LEN_MAX
)
2160 ANALYZE_PRINTF (" 1 (FDC)\n");
2161 irmp_store_bit2 (1);
2163 else if (irmp_pause_time
>= FDC_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_0_PAUSE_LEN_MAX
)
2165 ANALYZE_PRINTF (" 0 (FDC)\n");
2166 irmp_store_bit2 (0);
2169 if (! irmp_param
.protocol
)
2171 ANALYZE_PRINTF ("Switching to FDC protocol\n");
2172 memcpy (&irmp_param
, &irmp_param2
, sizeof (IRMP_PARAMETER
));
2173 irmp_param2
.protocol
= 0;
2174 irmp_tmp_address
= irmp_tmp_address2
;
2175 irmp_tmp_command
= irmp_tmp_command2
;
2178 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
2179 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2180 if (irmp_param2
.protocol
== IRMP_RCCAR_PROTOCOL
&& irmp_pulse_time
>= RCCAR_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_PULSE_LEN_MAX
)
2182 if (irmp_pause_time
>= RCCAR_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_1_PAUSE_LEN_MAX
)
2184 ANALYZE_PRINTF (" 1 (RCCAR)\n");
2185 irmp_store_bit2 (1);
2187 else if (irmp_pause_time
>= RCCAR_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_0_PAUSE_LEN_MAX
)
2189 ANALYZE_PRINTF (" 0 (RCCAR)\n");
2190 irmp_store_bit2 (0);
2193 if (! irmp_param
.protocol
)
2195 ANALYZE_PRINTF ("Switching to RCCAR protocol\n");
2196 memcpy (&irmp_param
, &irmp_param2
, sizeof (IRMP_PARAMETER
));
2197 irmp_param2
.protocol
= 0;
2198 irmp_tmp_address
= irmp_tmp_address2
;
2199 irmp_tmp_command
= irmp_tmp_command2
;
2202 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2204 last_pause
= irmp_pause_time
;
2208 #endif // IRMP_SUPPORT_MANCHESTER == 1
2211 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
2212 if (irmp_param
.protocol
== IRMP_SAMSUNG_PROTOCOL
&& irmp_bit
== 16) // Samsung: 16th bit
2214 if (irmp_pulse_time
>= SAMSUNG_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_PULSE_LEN_MAX
&&
2215 irmp_pause_time
>= SAMSUNG_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_START_BIT_PAUSE_LEN_MAX
)
2217 ANALYZE_PRINTF ("SYNC\n");
2222 else if (irmp_pulse_time
>= SAMSUNG_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_PULSE_LEN_MAX
)
2224 irmp_param
.protocol
= IRMP_SAMSUNG32_PROTOCOL
;
2225 irmp_param
.command_offset
= SAMSUNG32_COMMAND_OFFSET
;
2226 irmp_param
.command_end
= SAMSUNG32_COMMAND_OFFSET
+ SAMSUNG32_COMMAND_LEN
;
2227 irmp_param
.complete_len
= SAMSUNG32_COMPLETE_DATA_LEN
;
2229 if (irmp_pause_time
>= SAMSUNG_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_1_PAUSE_LEN_MAX
)
2231 ANALYZE_PUTCHAR ('1');
2238 ANALYZE_PUTCHAR ('0');
2244 ANALYZE_PRINTF ("Switching to SAMSUNG32 protocol\n");
2247 { // timing incorrect!
2248 ANALYZE_PRINTF ("error 3 Samsung: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2249 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2250 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2251 irmp_pause_time
= 0;
2255 #endif // IRMP_SUPPORT_SAMSUNG_PROTOCOL
2257 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
2258 if (irmp_param
.protocol
== IRMP_BANG_OLUFSEN_PROTOCOL
)
2260 if (irmp_pulse_time
>= BANG_OLUFSEN_PULSE_LEN_MIN
&& irmp_pulse_time
<= BANG_OLUFSEN_PULSE_LEN_MAX
)
2262 if (irmp_bit
== 1) // Bang & Olufsen: 3rd bit
2264 if (irmp_pause_time
>= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX
)
2266 ANALYZE_PRINTF ("3rd start bit\n");
2271 { // timing incorrect!
2272 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
);
2273 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2274 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2275 irmp_pause_time
= 0;
2278 else if (irmp_bit
== 19) // Bang & Olufsen: trailer bit
2280 if (irmp_pause_time
>= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX
)
2282 ANALYZE_PRINTF ("trailer bit\n");
2287 { // timing incorrect!
2288 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
);
2289 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2290 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2291 irmp_pause_time
= 0;
2296 if (irmp_pause_time
>= BANG_OLUFSEN_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_1_PAUSE_LEN_MAX
)
2297 { // pulse & pause timings correct for "1"?
2298 ANALYZE_PUTCHAR ('1');
2304 else if (irmp_pause_time
>= BANG_OLUFSEN_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_0_PAUSE_LEN_MAX
)
2305 { // pulse & pause timings correct for "0"?
2306 ANALYZE_PUTCHAR ('0');
2312 else if (irmp_pause_time
>= BANG_OLUFSEN_R_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_R_PAUSE_LEN_MAX
)
2314 ANALYZE_PUTCHAR (last_value
+ '0');
2316 irmp_store_bit (last_value
);
2320 { // timing incorrect!
2321 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
);
2322 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2323 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2324 irmp_pause_time
= 0;
2329 { // timing incorrect!
2330 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
);
2331 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2332 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2333 irmp_pause_time
= 0;
2337 #endif // IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL
2339 if (irmp_pulse_time
>= irmp_param
.pulse_1_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_1_len_max
&&
2340 irmp_pause_time
>= irmp_param
.pause_1_len_min
&& irmp_pause_time
<= irmp_param
.pause_1_len_max
)
2341 { // pulse & pause timings correct for "1"?
2342 ANALYZE_PUTCHAR ('1');
2347 else if (irmp_pulse_time
>= irmp_param
.pulse_0_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_0_len_max
&&
2348 irmp_pause_time
>= irmp_param
.pause_0_len_min
&& irmp_pause_time
<= irmp_param
.pause_0_len_max
)
2349 { // pulse & pause timings correct for "0"?
2350 ANALYZE_PUTCHAR ('0');
2356 { // timing incorrect!
2357 ANALYZE_PRINTF ("error 3: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2358 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2359 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2360 irmp_pause_time
= 0;
2363 irmp_pulse_time
= 1; // set counter to 1, not 0
2367 { // counting the pulse length ...
2368 if (! irmp_input
) // still light?
2370 irmp_pulse_time
++; // increment counter
2374 wait_for_space
= 1; // let's count the time (see above)
2375 irmp_pause_time
= 1; // set pause counter to 1, not 0
2379 if (irmp_start_bit_detected
&& irmp_bit
== irmp_param
.complete_len
&& irmp_param
.stop_bit
== 0) // enough bits received?
2381 if (last_irmp_command
== irmp_tmp_command
&& repetition_counter
< AUTO_FRAME_REPETITION_LEN
)
2383 repetition_frame_number
++;
2387 repetition_frame_number
= 0;
2390 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
2391 // if SIRCS protocol and the code will be repeated within 50 ms, we will ignore 2nd and 3rd repetition frame
2392 if (irmp_param
.protocol
== IRMP_SIRCS_PROTOCOL
&& (repetition_frame_number
== 1 || repetition_frame_number
== 2))
2394 ANALYZE_PRINTF ("code skipped: SIRCS auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2395 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2396 repetition_counter
= 0;
2401 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
2402 // if KASEIKYO protocol and the code will be repeated within 50 ms, we will ignore 2nd repetition frame
2403 if (irmp_param
.protocol
== IRMP_KASEIKYO_PROTOCOL
&& repetition_frame_number
== 1)
2405 ANALYZE_PRINTF ("code skipped: KASEIKYO auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2406 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2407 repetition_counter
= 0;
2412 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
2413 // if SAMSUNG32 protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
2414 if (irmp_param
.protocol
== IRMP_SAMSUNG32_PROTOCOL
&& (repetition_frame_number
& 0x01))
2416 ANALYZE_PRINTF ("code skipped: SAMSUNG32 auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2417 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2418 repetition_counter
= 0;
2423 #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
2424 // if NUBERT protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
2425 if (irmp_param
.protocol
== IRMP_NUBERT_PROTOCOL
&& (repetition_frame_number
& 0x01))
2427 ANALYZE_PRINTF ("code skipped: NUBERT auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2428 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2429 repetition_counter
= 0;
2435 ANALYZE_PRINTF ("code detected, length = %d\n", irmp_bit
);
2436 irmp_ir_detected
= TRUE
;
2438 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
2439 if (irmp_param
.protocol
== IRMP_DENON_PROTOCOL
)
2440 { // check for repetition frame
2441 if ((~irmp_tmp_command
& 0x3FF) == last_irmp_denon_command
) // command bits must be inverted
2443 irmp_tmp_command
= last_irmp_denon_command
; // use command received before!
2445 irmp_protocol
= irmp_param
.protocol
; // store protocol
2446 irmp_address
= irmp_tmp_address
; // store address
2447 irmp_command
= irmp_tmp_command
; // store command
2451 ANALYZE_PRINTF ("waiting for inverted command repetition\n");
2452 irmp_ir_detected
= FALSE
;
2453 last_irmp_denon_command
= irmp_tmp_command
;
2457 #endif // IRMP_SUPPORT_DENON_PROTOCOL
2459 #if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1
2460 if (irmp_param
.protocol
== IRMP_GRUNDIG_PROTOCOL
&& irmp_tmp_command
== 0x01ff)
2461 { // Grundig start frame?
2462 ANALYZE_PRINTF ("Detected GRUNDIG start frame, ignoring it\n");
2463 irmp_ir_detected
= FALSE
;
2466 #endif // IRMP_SUPPORT_GRUNDIG_PROTOCOL
2468 #if IRMP_SUPPORT_NOKIA_PROTOCOL == 1
2469 if (irmp_param
.protocol
== IRMP_NOKIA_PROTOCOL
&& irmp_tmp_address
== 0x00ff && irmp_tmp_command
== 0x00fe)
2470 { // Nokia start frame?
2471 ANALYZE_PRINTF ("Detected NOKIA start frame, ignoring it\n");
2472 irmp_ir_detected
= FALSE
;
2475 #endif // IRMP_SUPPORT_NOKIA_PROTOCOL
2477 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
2478 if (irmp_param
.protocol
== IRMP_NEC_PROTOCOL
&& irmp_bit
== 0) // repetition frame
2480 if (repetition_counter
< NEC_FRAME_REPEAT_PAUSE_LEN_MAX
)
2482 ANALYZE_PRINTF ("Detected NEC repetition frame, repetition_counter = %d\n", repetition_counter
);
2483 irmp_tmp_address
= last_irmp_address
; // address is last address
2484 irmp_tmp_command
= last_irmp_command
; // command is last command
2485 irmp_flags
|= IRMP_FLAG_REPETITION
;
2486 repetition_counter
= 0;
2490 ANALYZE_PRINTF ("Detected NEC repetition frame, ignoring it: timeout occured, repetition_counter = %d > %d\n",
2491 repetition_counter
, NEC_FRAME_REPEAT_PAUSE_LEN_MAX
);
2492 irmp_ir_detected
= FALSE
;
2495 #endif // IRMP_SUPPORT_NEC_PROTOCOL
2497 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
2498 if (irmp_param
.protocol
== IRMP_KASEIKYO_PROTOCOL
)
2501 // ANALYZE_PRINTF ("0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
2502 // xor_check[0], xor_check[1], xor_check[2], xor_check[3], xor_check[4], xor_check[5]);
2504 xor = (xor_check
[0] & 0x0F) ^ ((xor_check
[0] & 0xF0) >> 4) ^ (xor_check
[1] & 0x0F) ^ ((xor_check
[1] & 0xF0) >> 4);
2506 if (xor != (xor_check
[2] & 0x0F))
2508 ANALYZE_PRINTF ("error 4: wrong XOR check for customer id: 0x%1x 0x%1x\n", xor, xor_check
[2] & 0x0F);
2509 irmp_ir_detected
= FALSE
;
2512 xor = xor_check
[2] ^ xor_check
[3] ^ xor_check
[4];
2514 if (xor != xor_check
[5])
2516 ANALYZE_PRINTF ("error 4: wrong XOR check for data bits: 0x%02x 0x%02x\n", xor, xor_check
[5]);
2517 irmp_ir_detected
= FALSE
;
2520 #endif // IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
2522 irmp_protocol
= irmp_param
.protocol
;
2524 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
2525 if (irmp_param
.protocol
== IRMP_FDC_PROTOCOL
)
2527 if (irmp_tmp_command
& 0x000F) // released key?
2529 irmp_tmp_command
= (irmp_tmp_command
>> 4) | 0x80; // yes, set bit 7
2533 irmp_tmp_command
>>= 4; // no, it's a pressed key
2535 irmp_tmp_command
|= (irmp_tmp_address
<< 2) & 0x0F00; // 000000CCCCAAAAAA -> 0000CCCC00000000
2536 irmp_tmp_address
&= 0x003F;
2540 irmp_address
= irmp_tmp_address
; // store address
2541 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
2542 last_irmp_address
= irmp_tmp_address
; // store as last address, too
2545 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
2546 if (irmp_param
.protocol
== IRMP_RC5_PROTOCOL
)
2548 irmp_tmp_command
|= rc5_cmd_bit6
; // store bit 6
2551 irmp_command
= irmp_tmp_command
; // store command
2553 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
2554 irmp_id
= irmp_tmp_id
;
2559 if (irmp_ir_detected
)
2561 if (last_irmp_command
== irmp_command
&&
2562 last_irmp_address
== irmp_address
&&
2563 repetition_counter
< IRMP_KEY_REPETITION_LEN
)
2565 irmp_flags
|= IRMP_FLAG_REPETITION
;
2568 last_irmp_address
= irmp_tmp_address
; // store as last address, too
2569 last_irmp_command
= irmp_tmp_command
; // store as last command, too
2571 repetition_counter
= 0;
2575 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2578 irmp_start_bit_detected
= 0; // and wait for next start bit
2579 irmp_tmp_command
= 0;
2580 irmp_pulse_time
= 0;
2581 irmp_pause_time
= 0;
2583 #if IRMP_SUPPORT_JVC_PROTOCOL == 1
2584 if (irmp_protocol
== IRMP_JVC_PROTOCOL
) // the stop bit of JVC frame is also start bit of next frame
2585 { // set pulse time here!
2586 irmp_pulse_time
= ((uint8_t)(F_INTERRUPTS
* JVC_START_BIT_PULSE_TIME
));
2588 #endif // IRMP_SUPPORT_JVC_PROTOCOL == 1
2592 return (irmp_ir_detected
);
2597 /*---------------------------------------------------------------------------------------------------------------------------------------------------
2598 * main functions - for Unix/Linux + Windows only!
2602 * Compile it under linux with:
2605 * usage: ./irmp [-v|-s|-a|-l|-p] < file
2611 * -l list pulse/pauses
2613 *---------------------------------------------------------------------------------------------------------------------------------------------------
2617 print_timings (void)
2619 printf ("IRMP_TIMEOUT_LEN: %d\n", IRMP_TIMEOUT_LEN
);
2620 printf ("IRMP_KEY_REPETITION_LEN %d\n", IRMP_KEY_REPETITION_LEN
);
2622 printf ("PROTOCOL S S-PULSE S-PAUSE PULSE-0 PAUSE-0 PULSE-1 PAUSE-1\n");
2623 printf ("====================================================================================\n");
2624 printf ("SIRCS 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2625 SIRCS_START_BIT_PULSE_LEN_MIN
, SIRCS_START_BIT_PULSE_LEN_MAX
, SIRCS_START_BIT_PAUSE_LEN_MIN
, SIRCS_START_BIT_PAUSE_LEN_MAX
,
2626 SIRCS_0_PULSE_LEN_MIN
, SIRCS_0_PULSE_LEN_MAX
, SIRCS_PAUSE_LEN_MIN
, SIRCS_PAUSE_LEN_MAX
,
2627 SIRCS_1_PULSE_LEN_MIN
, SIRCS_1_PULSE_LEN_MAX
, SIRCS_PAUSE_LEN_MIN
, SIRCS_PAUSE_LEN_MAX
);
2629 printf ("NEC 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2630 NEC_START_BIT_PULSE_LEN_MIN
, NEC_START_BIT_PULSE_LEN_MAX
, NEC_START_BIT_PAUSE_LEN_MIN
, NEC_START_BIT_PAUSE_LEN_MAX
,
2631 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_0_PAUSE_LEN_MIN
, NEC_0_PAUSE_LEN_MAX
,
2632 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_1_PAUSE_LEN_MIN
, NEC_1_PAUSE_LEN_MAX
);
2634 printf ("NEC (rep) 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2635 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
,
2636 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_0_PAUSE_LEN_MIN
, NEC_0_PAUSE_LEN_MAX
,
2637 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_1_PAUSE_LEN_MIN
, NEC_1_PAUSE_LEN_MAX
);
2639 printf ("SAMSUNG 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2640 SAMSUNG_START_BIT_PULSE_LEN_MIN
, SAMSUNG_START_BIT_PULSE_LEN_MAX
, SAMSUNG_START_BIT_PAUSE_LEN_MIN
, SAMSUNG_START_BIT_PAUSE_LEN_MAX
,
2641 SAMSUNG_PULSE_LEN_MIN
, SAMSUNG_PULSE_LEN_MAX
, SAMSUNG_0_PAUSE_LEN_MIN
, SAMSUNG_0_PAUSE_LEN_MAX
,
2642 SAMSUNG_PULSE_LEN_MIN
, SAMSUNG_PULSE_LEN_MAX
, SAMSUNG_1_PAUSE_LEN_MIN
, SAMSUNG_1_PAUSE_LEN_MAX
);
2644 printf ("MATSUSHITA 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2645 MATSUSHITA_START_BIT_PULSE_LEN_MIN
, MATSUSHITA_START_BIT_PULSE_LEN_MAX
, MATSUSHITA_START_BIT_PAUSE_LEN_MIN
, MATSUSHITA_START_BIT_PAUSE_LEN_MAX
,
2646 MATSUSHITA_PULSE_LEN_MIN
, MATSUSHITA_PULSE_LEN_MAX
, MATSUSHITA_0_PAUSE_LEN_MIN
, MATSUSHITA_0_PAUSE_LEN_MAX
,
2647 MATSUSHITA_PULSE_LEN_MIN
, MATSUSHITA_PULSE_LEN_MAX
, MATSUSHITA_1_PAUSE_LEN_MIN
, MATSUSHITA_1_PAUSE_LEN_MAX
);
2649 printf ("KASEIKYO 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2650 KASEIKYO_START_BIT_PULSE_LEN_MIN
, KASEIKYO_START_BIT_PULSE_LEN_MAX
, KASEIKYO_START_BIT_PAUSE_LEN_MIN
, KASEIKYO_START_BIT_PAUSE_LEN_MAX
,
2651 KASEIKYO_PULSE_LEN_MIN
, KASEIKYO_PULSE_LEN_MAX
, KASEIKYO_0_PAUSE_LEN_MIN
, KASEIKYO_0_PAUSE_LEN_MAX
,
2652 KASEIKYO_PULSE_LEN_MIN
, KASEIKYO_PULSE_LEN_MAX
, KASEIKYO_1_PAUSE_LEN_MIN
, KASEIKYO_1_PAUSE_LEN_MAX
);
2654 printf ("RECS80 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2655 RECS80_START_BIT_PULSE_LEN_MIN
, RECS80_START_BIT_PULSE_LEN_MAX
, RECS80_START_BIT_PAUSE_LEN_MIN
, RECS80_START_BIT_PAUSE_LEN_MAX
,
2656 RECS80_PULSE_LEN_MIN
, RECS80_PULSE_LEN_MAX
, RECS80_0_PAUSE_LEN_MIN
, RECS80_0_PAUSE_LEN_MAX
,
2657 RECS80_PULSE_LEN_MIN
, RECS80_PULSE_LEN_MAX
, RECS80_1_PAUSE_LEN_MIN
, RECS80_1_PAUSE_LEN_MAX
);
2659 printf ("RC5 1 %3d - %3d %3d - %3d %3d - %3d\n",
2660 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
, RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
2661 RC5_BIT_LEN_MIN
, RC5_BIT_LEN_MAX
);
2663 printf ("DENON 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2664 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
,
2665 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
, DENON_0_PAUSE_LEN_MIN
, DENON_0_PAUSE_LEN_MAX
,
2666 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
, DENON_1_PAUSE_LEN_MIN
, DENON_1_PAUSE_LEN_MAX
);
2668 printf ("RC6 1 %3d - %3d %3d - %3d %3d - %3d\n",
2669 RC6_START_BIT_PULSE_LEN_MIN
, RC6_START_BIT_PULSE_LEN_MAX
, RC6_START_BIT_PAUSE_LEN_MIN
, RC6_START_BIT_PAUSE_LEN_MAX
,
2670 RC6_BIT_LEN_MIN
, RC6_BIT_LEN_MAX
);
2672 printf ("RECS80EXT 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2673 RECS80EXT_START_BIT_PULSE_LEN_MIN
, RECS80EXT_START_BIT_PULSE_LEN_MAX
, RECS80EXT_START_BIT_PAUSE_LEN_MIN
, RECS80EXT_START_BIT_PAUSE_LEN_MAX
,
2674 RECS80EXT_PULSE_LEN_MIN
, RECS80EXT_PULSE_LEN_MAX
, RECS80EXT_0_PAUSE_LEN_MIN
, RECS80EXT_0_PAUSE_LEN_MAX
,
2675 RECS80EXT_PULSE_LEN_MIN
, RECS80EXT_PULSE_LEN_MAX
, RECS80EXT_1_PAUSE_LEN_MIN
, RECS80EXT_1_PAUSE_LEN_MAX
);
2677 printf ("NUBERT 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2678 NUBERT_START_BIT_PULSE_LEN_MIN
, NUBERT_START_BIT_PULSE_LEN_MAX
, NUBERT_START_BIT_PAUSE_LEN_MIN
, NUBERT_START_BIT_PAUSE_LEN_MAX
,
2679 NUBERT_0_PULSE_LEN_MIN
, NUBERT_0_PULSE_LEN_MAX
, NUBERT_0_PAUSE_LEN_MIN
, NUBERT_0_PAUSE_LEN_MAX
,
2680 NUBERT_1_PULSE_LEN_MIN
, NUBERT_1_PULSE_LEN_MAX
, NUBERT_1_PAUSE_LEN_MIN
, NUBERT_1_PAUSE_LEN_MAX
);
2682 printf ("BANG_OLUFSEN 1 %3d - %3d %3d - %3d\n",
2683 BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX
,
2684 BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX
);
2686 printf ("BANG_OLUFSEN 2 %3d - %3d %3d - %3d\n",
2687 BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX
,
2688 BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX
);
2690 printf ("BANG_OLUFSEN 3 %3d - %3d %3d - %3d\n",
2691 BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX
,
2692 BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX
);
2694 printf ("BANG_OLUFSEN 4 %3d - %3d %3d - %3d\n",
2695 BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX
,
2696 BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX
);
2698 printf ("BANG_OLUFSEN - %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2699 BANG_OLUFSEN_PULSE_LEN_MIN
, BANG_OLUFSEN_PULSE_LEN_MAX
, BANG_OLUFSEN_0_PAUSE_LEN_MIN
, BANG_OLUFSEN_0_PAUSE_LEN_MAX
,
2700 BANG_OLUFSEN_PULSE_LEN_MIN
, BANG_OLUFSEN_PULSE_LEN_MAX
, BANG_OLUFSEN_1_PAUSE_LEN_MIN
, BANG_OLUFSEN_1_PAUSE_LEN_MAX
);
2702 printf ("GRUNDIG/NOKIA 1 %3d - %3d %3d - %3d %3d - %3d\n",
2703 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
,
2704 GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, GRUNDIG_OR_NOKIA_BIT_LEN_MAX
);
2706 printf ("SIEMENS 1 %3d - %3d %3d - %3d %3d - %3d\n",
2707 SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
, SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
,
2708 SIEMENS_BIT_LEN_MIN
, SIEMENS_BIT_LEN_MAX
);
2710 printf ("FDC 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2711 FDC_START_BIT_PULSE_LEN_MIN
, FDC_START_BIT_PULSE_LEN_MAX
, FDC_START_BIT_PAUSE_LEN_MIN
, FDC_START_BIT_PAUSE_LEN_MAX
,
2712 FDC_PULSE_LEN_MIN
, FDC_PULSE_LEN_MAX
, FDC_0_PAUSE_LEN_MIN
, FDC_0_PAUSE_LEN_MAX
,
2713 FDC_PULSE_LEN_MIN
, FDC_PULSE_LEN_MAX
, FDC_1_PAUSE_LEN_MIN
, FDC_1_PAUSE_LEN_MAX
);
2715 printf ("RCCAR 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2716 RCCAR_START_BIT_PULSE_LEN_MIN
, RCCAR_START_BIT_PULSE_LEN_MAX
, RCCAR_START_BIT_PAUSE_LEN_MIN
, RCCAR_START_BIT_PAUSE_LEN_MAX
,
2717 RCCAR_PULSE_LEN_MIN
, RCCAR_PULSE_LEN_MAX
, RCCAR_0_PAUSE_LEN_MIN
, RCCAR_0_PAUSE_LEN_MAX
,
2718 RCCAR_PULSE_LEN_MIN
, RCCAR_PULSE_LEN_MAX
, RCCAR_1_PAUSE_LEN_MIN
, RCCAR_1_PAUSE_LEN_MAX
);
2722 print_spectrum (char * text
, int * buf
, int is_pulse
)
2735 puts ("-------------------------------------------------------------------------------");
2736 printf ("%s:\n", text
);
2738 for (i
= 0; i
< 256; i
++)
2740 if (buf
[i
] > max_value
)
2746 for (i
= 0; i
< 100; i
++)
2751 value
= (buf
[i
] * 60) / max_value
;
2753 for (j
= 0; j
< value
; j
++)
2757 printf (" %d\n", buf
[i
]);
2768 average
= (float) sum
/ (float) counter
;
2779 printf ("avg: %4.1f=%6.1f us, ", average
, (1000000. * average
) / (float) F_INTERRUPTS
);
2780 printf ("min: %2d=%6.1f us, ", min
, (1000000. * min
) / (float) F_INTERRUPTS
);
2781 printf ("max: %2d=%6.1f us, ", max
, (1000000. * max
) / (float) F_INTERRUPTS
);
2783 tolerance
= (max
- average
);
2785 if (average
- min
> tolerance
)
2787 tolerance
= average
- min
;
2790 tolerance
= tolerance
* 100 / average
;
2791 printf ("tol: %4.1f%%\n", tolerance
);
2801 #define STATE_LEFT_SHIFT 0x01
2802 #define STATE_RIGHT_SHIFT 0x02
2803 #define STATE_LEFT_CTRL 0x04
2804 #define STATE_LEFT_ALT 0x08
2805 #define STATE_RIGHT_ALT 0x10
2807 #define KEY_ESCAPE 0x1B // keycode = 0x006e
2808 #define KEY_MENUE 0x80 // keycode = 0x0070
2809 #define KEY_BACK 0x81 // keycode = 0x0071
2810 #define KEY_FORWARD 0x82 // keycode = 0x0072
2811 #define KEY_ADDRESS 0x83 // keycode = 0x0073
2812 #define KEY_WINDOW 0x84 // keycode = 0x0074
2813 #define KEY_1ST_PAGE 0x85 // keycode = 0x0075
2814 #define KEY_STOP 0x86 // keycode = 0x0076
2815 #define KEY_MAIL 0x87 // keycode = 0x0077
2816 #define KEY_FAVORITES 0x88 // keycode = 0x0078
2817 #define KEY_NEW_PAGE 0x89 // keycode = 0x0079
2818 #define KEY_SETUP 0x8A // keycode = 0x007a
2819 #define KEY_FONT 0x8B // keycode = 0x007b
2820 #define KEY_PRINT 0x8C // keycode = 0x007c
2821 #define KEY_ON_OFF 0x8E // keycode = 0x007c
2823 #define KEY_INSERT 0x90 // keycode = 0x004b
2824 #define KEY_DELETE 0x91 // keycode = 0x004c
2825 #define KEY_LEFT 0x92 // keycode = 0x004f
2826 #define KEY_HOME 0x93 // keycode = 0x0050
2827 #define KEY_END 0x94 // keycode = 0x0051
2828 #define KEY_UP 0x95 // keycode = 0x0053
2829 #define KEY_DOWN 0x96 // keycode = 0x0054
2830 #define KEY_PAGE_UP 0x97 // keycode = 0x0055
2831 #define KEY_PAGE_DOWN 0x98 // keycode = 0x0056
2832 #define KEY_RIGHT 0x99 // keycode = 0x0059
2833 #define KEY_MOUSE_1 0x9E // keycode = 0x0400
2834 #define KEY_MOUSE_2 0x9F // keycode = 0x0800
2837 get_fdc_key (uint16_t cmd
)
2839 static uint8_t key_table
[128] =
2841 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2842 0, '^', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'ß', '´', 0, '\b',
2843 '\t','q', 'w', 'e', 'r', 't', 'z', 'u', 'i', 'o', 'p', 'ü', '+', 0, 0, 'a',
2844 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'ö', 'ä', '#', '\r', 0, '<', 'y', 'x',
2845 'c', 'v', 'b', 'n', 'm', ',', '.', '-', 0, 0, 0, 0, 0, ' ', 0, 0,
2847 0, '°', '!', '"', '§', '$', '%', '&', '/', '(', ')', '=', '?', '`', 0, '\b',
2848 '\t','Q', 'W', 'E', 'R', 'T', 'Z', 'U', 'I', 'O', 'P', 'Ü', '*', 0, 0, 'A',
2849 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'Ö', 'Ä', '\'','\r', 0, '>', 'Y', 'X',
2850 'C', 'V', 'B', 'N', 'M', ';', ':', '_', 0, 0, 0, 0, 0, ' ', 0, 0
2852 static uint8_t state
;
2858 case 0x002C: state
|= STATE_LEFT_SHIFT
; break; // pressed left shift
2859 case 0x00AC: state
&= ~STATE_LEFT_SHIFT
; break; // released left shift
2860 case 0x0039: state
|= STATE_RIGHT_SHIFT
; break; // pressed right shift
2861 case 0x00B9: state
&= ~STATE_RIGHT_SHIFT
; break; // released right shift
2862 case 0x003A: state
|= STATE_LEFT_CTRL
; break; // pressed left ctrl
2863 case 0x00BA: state
&= ~STATE_LEFT_CTRL
; break; // released left ctrl
2864 case 0x003C: state
|= STATE_LEFT_ALT
; break; // pressed left alt
2865 case 0x00BC: state
&= ~STATE_LEFT_ALT
; break; // released left alt
2866 case 0x003E: state
|= STATE_RIGHT_ALT
; break; // pressed left alt
2867 case 0x00BE: state
&= ~STATE_RIGHT_ALT
; break; // released left alt
2869 case 0x006e: key
= KEY_ESCAPE
; break;
2870 case 0x004b: key
= KEY_INSERT
; break;
2871 case 0x004c: key
= KEY_DELETE
; break;
2872 case 0x004f: key
= KEY_LEFT
; break;
2873 case 0x0050: key
= KEY_HOME
; break;
2874 case 0x0051: key
= KEY_END
; break;
2875 case 0x0053: key
= KEY_UP
; break;
2876 case 0x0054: key
= KEY_DOWN
; break;
2877 case 0x0055: key
= KEY_PAGE_UP
; break;
2878 case 0x0056: key
= KEY_PAGE_DOWN
; break;
2879 case 0x0059: key
= KEY_RIGHT
; break;
2880 case 0x0400: key
= KEY_MOUSE_1
; break;
2881 case 0x0800: key
= KEY_MOUSE_2
; break;
2885 if (!(cmd
& 0x80)) // pressed key
2887 if (cmd
>= 0x70 && cmd
<= 0x7F) // function keys
2889 key
= cmd
+ 0x10; // 7x -> 8x
2891 else if (cmd
< 64) // key listed in key_table
2893 if (state
& (STATE_LEFT_ALT
| STATE_RIGHT_ALT
))
2897 case 0x0003: key
= '²'; break;
2898 case 0x0008: key
= '{'; break;
2899 case 0x0009: key
= '['; break;
2900 case 0x000A: key
= ']'; break;
2901 case 0x000B: key
= '}'; break;
2902 case 0x000C: key
= '\\'; break;
2903 case 0x001C: key
= '~'; break;
2904 case 0x002D: key
= '|'; break;
2905 case 0x0034: key
= 'µ'; break;
2908 else if (state
& (STATE_LEFT_CTRL
))
2910 if (key_table
[cmd
] >= 'a' && key_table
[cmd
] <= 'z')
2912 key
= key_table
[cmd
] - 'a' + 1;
2916 key
= key_table
[cmd
];
2921 int idx
= cmd
+ ((state
& (STATE_LEFT_SHIFT
| STATE_RIGHT_SHIFT
)) ? 64 : 0);
2925 key
= key_table
[idx
];
2938 main (int argc
, char ** argv
)
2941 int analyze
= FALSE
;
2948 int start_pulses
[256];
2949 int start_pauses
[256];
2953 int first_pulse
= TRUE
;
2954 int first_pause
= TRUE
;
2956 IRMP_DATA irmp_data
;
2960 if (! strcmp (argv
[1], "-v"))
2964 else if (! strcmp (argv
[1], "-l"))
2968 else if (! strcmp (argv
[1], "-a"))
2972 else if (! strcmp (argv
[1], "-s"))
2976 else if (! strcmp (argv
[1], "-p"))
2983 for (i
= 0; i
< 256; i
++)
2985 start_pulses
[i
] = 0;
2986 start_pauses
[i
] = 0;
2993 while ((ch
= getchar ()) != EOF
)
2995 if (ch
== '_' || ch
== '0')
3003 printf ("pause: %d\n", pause
);
3012 start_pauses
[pause
]++;
3014 first_pause
= FALSE
;
3030 else if (ch
== 0xaf || ch
== '-' || ch
== '1')
3036 printf ("pulse: %d ", pulse
);
3045 start_pulses
[pulse
]++;
3047 first_pulse
= FALSE
;
3063 else if (ch
== '\n')
3067 if (list
&& pause
> 0)
3069 printf ("pause: %d\n", pause
);
3075 for (i
= 0; i
< (int) ((8000.0 * F_INTERRUPTS
) / 10000); i
++) // newline: long pause of 800 msec
3087 while ((ch
= getchar()) != '\n' && ch
!= EOF
)
3094 puts ("-------------------------------------------------------------------");
3097 while ((ch
= getchar()) != '\n' && ch
!= EOF
)
3099 if (ch
!= '\r') // ignore CR in DOS/Windows files
3111 if (! analyze
&& ! list
)
3115 if (irmp_get_data (&irmp_data
))
3119 ANALYZE_ONLY_NORMAL_PUTCHAR (' ');
3121 if (irmp_data
.protocol
== IRMP_FDC_PROTOCOL
&& (key
= get_fdc_key (irmp_data
.command
)) != 0)
3123 if ((key
>= 0x20 && key
< 0x7F) || key
>= 0xA0)
3125 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x, key = '%c'\n",
3126 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
, key
, key
);
3128 else if (key
== '\r' || key
== '\t' || key
== KEY_ESCAPE
|| (key
>= 0x80 && key
<= 0x9F)) // function keys
3130 char * p
= (char *) NULL
;
3134 case '\t' : p
= "TAB"; break;
3135 case '\r' : p
= "CR"; break;
3136 case KEY_ESCAPE
: p
= "ESCAPE"; break;
3137 case KEY_MENUE
: p
= "MENUE"; break;
3138 case KEY_BACK
: p
= "BACK"; break;
3139 case KEY_FORWARD
: p
= "FORWARD"; break;
3140 case KEY_ADDRESS
: p
= "ADDRESS"; break;
3141 case KEY_WINDOW
: p
= "WINDOW"; break;
3142 case KEY_1ST_PAGE
: p
= "1ST_PAGE"; break;
3143 case KEY_STOP
: p
= "STOP"; break;
3144 case KEY_MAIL
: p
= "MAIL"; break;
3145 case KEY_FAVORITES
: p
= "FAVORITES"; break;
3146 case KEY_NEW_PAGE
: p
= "NEW_PAGE"; break;
3147 case KEY_SETUP
: p
= "SETUP"; break;
3148 case KEY_FONT
: p
= "FONT"; break;
3149 case KEY_PRINT
: p
= "PRINT"; break;
3150 case KEY_ON_OFF
: p
= "ON_OFF"; break;
3152 case KEY_INSERT
: p
= "INSERT"; break;
3153 case KEY_DELETE
: p
= "DELETE"; break;
3154 case KEY_LEFT
: p
= "LEFT"; break;
3155 case KEY_HOME
: p
= "HOME"; break;
3156 case KEY_END
: p
= "END"; break;
3157 case KEY_UP
: p
= "UP"; break;
3158 case KEY_DOWN
: p
= "DOWN"; break;
3159 case KEY_PAGE_UP
: p
= "PAGE_UP"; break;
3160 case KEY_PAGE_DOWN
: p
= "PAGE_DOWN"; break;
3161 case KEY_RIGHT
: p
= "RIGHT"; break;
3162 case KEY_MOUSE_1
: p
= "KEY_MOUSE_1"; break;
3163 case KEY_MOUSE_2
: p
= "KEY_MOUSE_2"; break;
3164 default : p
= "<UNKNWON>"; break;
3167 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x, key = %s\n",
3168 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
, key
, p
);
3172 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x\n",
3173 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
, key
);
3178 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x\n",
3179 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
);
3187 print_spectrum ("START PULSES", start_pulses
, TRUE
);
3188 print_spectrum ("START PAUSES", start_pauses
, FALSE
);
3189 print_spectrum ("PULSES", pulses
, TRUE
);
3190 print_spectrum ("PAUSES", pauses
, FALSE
);
3191 puts ("-------------------------------------------------------------------------------");