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.75 2010/07/01 09:00:16 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_60 + 0.5) + 1)
443 #define KASEIKYO_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MIN_TOLERANCE_50 + 0.5) - 1)
444 #define KASEIKYO_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MAX_TOLERANCE_50 + 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 AUTO_FRAME_REPETITION_LEN (uint16_t)(F_INTERRUPTS * AUTO_FRAME_REPETITION_TIME + 0.5) // use uint16_t!
572 #define ANALYZE_PUTCHAR(a) { if (! silent) { putchar (a); } }
573 #define ANALYZE_ONLY_NORMAL_PUTCHAR(a) { if (! silent && !verbose) { putchar (a); } }
574 #define ANALYZE_PRINTF(...) { if (verbose) { printf (__VA_ARGS__); } }
575 #define ANALYZE_NEWLINE() { if (verbose) { putchar ('\n'); } }
577 static int time_counter
;
580 #define ANALYZE_PUTCHAR(a)
581 #define ANALYZE_ONLY_NORMAL_PUTCHAR(a)
582 #define ANALYZE_PRINTF(...)
583 #define ANALYZE_NEWLINE()
586 #if IRMP_LOGGING == 1
588 #include <util/setbaud.h>
592 #define UART0_UBRRH UBRR0H
593 #define UART0_UBRRL UBRR0L
594 #define UART0_UCSRA UCSR0A
595 #define UART0_UCSRB UCSR0B
596 #define UART0_UCSRC UCSR0C
597 #define UART0_UDRE_BIT_VALUE (1<<UDRE0)
598 #define UART0_UCSZ1_BIT_VALUE (1<<UCSZ01)
599 #define UART0_UCSZ0_BIT_VALUE (1<<UCSZ00)
601 #define UART0_URSEL_BIT_VALUE (1<<URSEL0)
603 #define UART0_URSEL_BIT_VALUE (0)
605 #define UART0_TXEN_BIT_VALUE (1<<TXEN0)
606 #define UART0_UDR UDR0
610 #define UART0_UBRRH UBRRH
611 #define UART0_UBRRL UBRRL
612 #define UART0_UCSRA UCSRA
613 #define UART0_UCSRB UCSRB
614 #define UART0_UCSRC UCSRC
615 #define UART0_UDRE_BIT_VALUE (1<<UDRE)
616 #define UART0_UCSZ1_BIT_VALUE (1<<UCSZ1)
617 #define UART0_UCSZ0_BIT_VALUE (1<<UCSZ0)
619 #define UART0_URSEL_BIT_VALUE (1<<URSEL)
621 #define UART0_URSEL_BIT_VALUE (0)
623 #define UART0_TXEN_BIT_VALUE (1<<TXEN)
624 #define UART0_UDR UDR
628 /*---------------------------------------------------------------------------------------------------------------------------------------------------
630 * @details Initializes UART
631 *---------------------------------------------------------------------------------------------------------------------------------------------------
634 irmp_uart_init (void)
636 UART0_UBRRH
= UBRRH_VALUE
; // set baud rate
637 UART0_UBRRL
= UBRRL_VALUE
;
640 UART0_UCSRA
|= (1<<U2X
);
642 UART0_UCSRA
&= ~(1<<U2X
);
645 UART0_UCSRC
= UART0_UCSZ1_BIT_VALUE
| UART0_UCSZ0_BIT_VALUE
| UART0_URSEL_BIT_VALUE
;
646 UART0_UCSRB
|= UART0_TXEN_BIT_VALUE
; // enable UART TX
649 /*---------------------------------------------------------------------------------------------------------------------------------------------------
651 * @details Sends character
652 * @param ch character to be transmitted
653 *---------------------------------------------------------------------------------------------------------------------------------------------------
656 irmp_uart_putc (unsigned char ch
)
658 while (!(UART0_UCSRA
& UART0_UDRE_BIT_VALUE
))
666 /*---------------------------------------------------------------------------------------------------------------------------------------------------
668 *---------------------------------------------------------------------------------------------------------------------------------------------------
671 #define STARTCYCLES 2 // min count of zeros before start of logging
672 #define ENDBITS 1000 // number of sequenced highbits to detect end
673 #define DATALEN 700 // log buffer size
676 irmp_log (uint8_t val
)
678 static uint8_t buf
[DATALEN
]; // logging buffer
679 static uint16_t buf_idx
; // number of written bits
680 static uint8_t startcycles
; // current number of start-zeros
681 static uint16_t cnt
; // counts sequenced highbits - to detect end
683 if (! val
&& (startcycles
< STARTCYCLES
) && !buf_idx
) // prevent that single random zeros init logging
691 if (! val
|| (val
&& buf_idx
!= 0)) // start or continue logging on "0", "1" cannot init logging
693 if (buf_idx
< DATALEN
* 8) // index in range?
697 buf
[(buf_idx
/ 8)] |= (1<<(buf_idx
% 8)); // set bit
701 buf
[(buf_idx
/ 8)] &= ~(1<<(buf_idx
% 8)); // reset bit
708 { // if high received then look at log-stop condition
712 { // if stop condition is true, output on uart
715 for (i
= 0; i
< STARTCYCLES
; i
++)
717 irmp_uart_putc ('0'); // the ignored starting zeros
720 for (i
= 0; i
< (buf_idx
- ENDBITS
+ 20) / 8; i
++) // transform bitset into uart chars
725 for (j
= 0; j
< 8; j
++)
727 irmp_uart_putc ((d
& 1) + '0');
732 irmp_uart_putc ('\n');
745 #define irmp_log(val)
750 uint8_t protocol
; // ir protocol
751 uint8_t pulse_1_len_min
; // minimum length of pulse with bit value 1
752 uint8_t pulse_1_len_max
; // maximum length of pulse with bit value 1
753 uint8_t pause_1_len_min
; // minimum length of pause with bit value 1
754 uint8_t pause_1_len_max
; // maximum length of pause with bit value 1
755 uint8_t pulse_0_len_min
; // minimum length of pulse with bit value 0
756 uint8_t pulse_0_len_max
; // maximum length of pulse with bit value 0
757 uint8_t pause_0_len_min
; // minimum length of pause with bit value 0
758 uint8_t pause_0_len_max
; // maximum length of pause with bit value 0
759 uint8_t address_offset
; // address offset
760 uint8_t address_end
; // end of address
761 uint8_t command_offset
; // command offset
762 uint8_t command_end
; // end of command
763 uint8_t complete_len
; // complete length of frame
764 uint8_t stop_bit
; // flag: frame has stop bit
765 uint8_t lsb_first
; // flag: LSB first
766 uint8_t flags
; // some flags
769 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
771 static PROGMEM IRMP_PARAMETER sircs_param
=
773 IRMP_SIRCS_PROTOCOL
, // protocol: ir protocol
774 SIRCS_1_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
775 SIRCS_1_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
776 SIRCS_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
777 SIRCS_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
778 SIRCS_0_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
779 SIRCS_0_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
780 SIRCS_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
781 SIRCS_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
782 SIRCS_ADDRESS_OFFSET
, // address_offset: address offset
783 SIRCS_ADDRESS_OFFSET
+ SIRCS_ADDRESS_LEN
, // address_end: end of address
784 SIRCS_COMMAND_OFFSET
, // command_offset: command offset
785 SIRCS_COMMAND_OFFSET
+ SIRCS_COMMAND_LEN
, // command_end: end of command
786 SIRCS_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
787 SIRCS_STOP_BIT
, // stop_bit: flag: frame has stop bit
788 SIRCS_LSB
, // lsb_first: flag: LSB first
789 SIRCS_FLAGS
// flags: some flags
794 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
796 static PROGMEM IRMP_PARAMETER nec_param
=
798 IRMP_NEC_PROTOCOL
, // protocol: ir protocol
799 NEC_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
800 NEC_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
801 NEC_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
802 NEC_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
803 NEC_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
804 NEC_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
805 NEC_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
806 NEC_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
807 NEC_ADDRESS_OFFSET
, // address_offset: address offset
808 NEC_ADDRESS_OFFSET
+ NEC_ADDRESS_LEN
, // address_end: end of address
809 NEC_COMMAND_OFFSET
, // command_offset: command offset
810 NEC_COMMAND_OFFSET
+ NEC_COMMAND_LEN
, // command_end: end of command
811 NEC_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
812 NEC_STOP_BIT
, // stop_bit: flag: frame has stop bit
813 NEC_LSB
, // lsb_first: flag: LSB first
814 NEC_FLAGS
// flags: some flags
817 static PROGMEM IRMP_PARAMETER nec_rep_param
=
819 IRMP_NEC_PROTOCOL
, // protocol: ir protocol
820 NEC_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
821 NEC_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
822 NEC_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
823 NEC_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
824 NEC_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
825 NEC_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
826 NEC_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
827 NEC_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
828 0, // address_offset: address offset
829 0, // address_end: end of address
830 0, // command_offset: command offset
831 0, // command_end: end of command
832 0, // complete_len: complete length of frame
833 NEC_STOP_BIT
, // stop_bit: flag: frame has stop bit
834 NEC_LSB
, // lsb_first: flag: LSB first
835 NEC_FLAGS
// flags: some flags
840 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
842 static PROGMEM IRMP_PARAMETER samsung_param
=
844 IRMP_SAMSUNG_PROTOCOL
, // protocol: ir protocol
845 SAMSUNG_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
846 SAMSUNG_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
847 SAMSUNG_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
848 SAMSUNG_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
849 SAMSUNG_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
850 SAMSUNG_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
851 SAMSUNG_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
852 SAMSUNG_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
853 SAMSUNG_ADDRESS_OFFSET
, // address_offset: address offset
854 SAMSUNG_ADDRESS_OFFSET
+ SAMSUNG_ADDRESS_LEN
, // address_end: end of address
855 SAMSUNG_COMMAND_OFFSET
, // command_offset: command offset
856 SAMSUNG_COMMAND_OFFSET
+ SAMSUNG_COMMAND_LEN
, // command_end: end of command
857 SAMSUNG_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
858 SAMSUNG_STOP_BIT
, // stop_bit: flag: frame has stop bit
859 SAMSUNG_LSB
, // lsb_first: flag: LSB first
860 SAMSUNG_FLAGS
// flags: some flags
865 #if IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
867 static PROGMEM IRMP_PARAMETER matsushita_param
=
869 IRMP_MATSUSHITA_PROTOCOL
, // protocol: ir protocol
870 MATSUSHITA_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
871 MATSUSHITA_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
872 MATSUSHITA_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
873 MATSUSHITA_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
874 MATSUSHITA_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
875 MATSUSHITA_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
876 MATSUSHITA_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
877 MATSUSHITA_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
878 MATSUSHITA_ADDRESS_OFFSET
, // address_offset: address offset
879 MATSUSHITA_ADDRESS_OFFSET
+ MATSUSHITA_ADDRESS_LEN
, // address_end: end of address
880 MATSUSHITA_COMMAND_OFFSET
, // command_offset: command offset
881 MATSUSHITA_COMMAND_OFFSET
+ MATSUSHITA_COMMAND_LEN
, // command_end: end of command
882 MATSUSHITA_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
883 MATSUSHITA_STOP_BIT
, // stop_bit: flag: frame has stop bit
884 MATSUSHITA_LSB
, // lsb_first: flag: LSB first
885 MATSUSHITA_FLAGS
// flags: some flags
890 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
892 static PROGMEM IRMP_PARAMETER kaseikyo_param
=
894 IRMP_KASEIKYO_PROTOCOL
, // protocol: ir protocol
895 KASEIKYO_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
896 KASEIKYO_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
897 KASEIKYO_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
898 KASEIKYO_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
899 KASEIKYO_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
900 KASEIKYO_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
901 KASEIKYO_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
902 KASEIKYO_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
903 KASEIKYO_ADDRESS_OFFSET
, // address_offset: address offset
904 KASEIKYO_ADDRESS_OFFSET
+ KASEIKYO_ADDRESS_LEN
, // address_end: end of address
905 KASEIKYO_COMMAND_OFFSET
, // command_offset: command offset
906 KASEIKYO_COMMAND_OFFSET
+ KASEIKYO_COMMAND_LEN
, // command_end: end of command
907 KASEIKYO_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
908 KASEIKYO_STOP_BIT
, // stop_bit: flag: frame has stop bit
909 KASEIKYO_LSB
, // lsb_first: flag: LSB first
910 KASEIKYO_FLAGS
// flags: some flags
915 #if IRMP_SUPPORT_RECS80_PROTOCOL == 1
917 static PROGMEM IRMP_PARAMETER recs80_param
=
919 IRMP_RECS80_PROTOCOL
, // protocol: ir protocol
920 RECS80_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
921 RECS80_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
922 RECS80_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
923 RECS80_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
924 RECS80_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
925 RECS80_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
926 RECS80_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
927 RECS80_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
928 RECS80_ADDRESS_OFFSET
, // address_offset: address offset
929 RECS80_ADDRESS_OFFSET
+ RECS80_ADDRESS_LEN
, // address_end: end of address
930 RECS80_COMMAND_OFFSET
, // command_offset: command offset
931 RECS80_COMMAND_OFFSET
+ RECS80_COMMAND_LEN
, // command_end: end of command
932 RECS80_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
933 RECS80_STOP_BIT
, // stop_bit: flag: frame has stop bit
934 RECS80_LSB
, // lsb_first: flag: LSB first
935 RECS80_FLAGS
// flags: some flags
940 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
942 static PROGMEM IRMP_PARAMETER rc5_param
=
944 IRMP_RC5_PROTOCOL
, // protocol: ir protocol
945 RC5_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
946 RC5_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
947 RC5_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
948 RC5_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
949 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
950 1, // pulse_0_len_max: maximum length of pulse with bit value 0
951 1, // pause_0_len_min: minimum length of pause with bit value 0
952 1, // pause_0_len_max: maximum length of pause with bit value 0
953 RC5_ADDRESS_OFFSET
, // address_offset: address offset
954 RC5_ADDRESS_OFFSET
+ RC5_ADDRESS_LEN
, // address_end: end of address
955 RC5_COMMAND_OFFSET
, // command_offset: command offset
956 RC5_COMMAND_OFFSET
+ RC5_COMMAND_LEN
, // command_end: end of command
957 RC5_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
958 RC5_STOP_BIT
, // stop_bit: flag: frame has stop bit
959 RC5_LSB
, // lsb_first: flag: LSB first
960 RC5_FLAGS
// flags: some flags
965 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
967 static PROGMEM IRMP_PARAMETER denon_param
=
969 IRMP_DENON_PROTOCOL
, // protocol: ir protocol
970 DENON_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
971 DENON_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
972 DENON_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
973 DENON_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
974 DENON_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
975 DENON_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
976 DENON_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
977 DENON_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
978 DENON_ADDRESS_OFFSET
, // address_offset: address offset
979 DENON_ADDRESS_OFFSET
+ DENON_ADDRESS_LEN
, // address_end: end of address
980 DENON_COMMAND_OFFSET
, // command_offset: command offset
981 DENON_COMMAND_OFFSET
+ DENON_COMMAND_LEN
, // command_end: end of command
982 DENON_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
983 DENON_STOP_BIT
, // stop_bit: flag: frame has stop bit
984 DENON_LSB
, // lsb_first: flag: LSB first
985 DENON_FLAGS
// flags: some flags
990 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
992 static PROGMEM IRMP_PARAMETER rc6_param
=
994 IRMP_RC6_PROTOCOL
, // protocol: ir protocol
995 RC6_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
996 RC6_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
997 RC6_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
998 RC6_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
999 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1000 1, // pulse_0_len_max: maximum length of pulse with bit value 0
1001 1, // pause_0_len_min: minimum length of pause with bit value 0
1002 1, // pause_0_len_max: maximum length of pause with bit value 0
1003 RC6_ADDRESS_OFFSET
, // address_offset: address offset
1004 RC6_ADDRESS_OFFSET
+ RC6_ADDRESS_LEN
, // address_end: end of address
1005 RC6_COMMAND_OFFSET
, // command_offset: command offset
1006 RC6_COMMAND_OFFSET
+ RC6_COMMAND_LEN
, // command_end: end of command
1007 RC6_COMPLETE_DATA_LEN_SHORT
, // complete_len: complete length of frame
1008 RC6_STOP_BIT
, // stop_bit: flag: frame has stop bit
1009 RC6_LSB
, // lsb_first: flag: LSB first
1010 RC6_FLAGS
// flags: some flags
1015 #if IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
1017 static PROGMEM IRMP_PARAMETER recs80ext_param
=
1019 IRMP_RECS80EXT_PROTOCOL
, // protocol: ir protocol
1020 RECS80EXT_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1021 RECS80EXT_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1022 RECS80EXT_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1023 RECS80EXT_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1024 RECS80EXT_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1025 RECS80EXT_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1026 RECS80EXT_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1027 RECS80EXT_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1028 RECS80EXT_ADDRESS_OFFSET
, // address_offset: address offset
1029 RECS80EXT_ADDRESS_OFFSET
+ RECS80EXT_ADDRESS_LEN
, // address_end: end of address
1030 RECS80EXT_COMMAND_OFFSET
, // command_offset: command offset
1031 RECS80EXT_COMMAND_OFFSET
+ RECS80EXT_COMMAND_LEN
, // command_end: end of command
1032 RECS80EXT_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1033 RECS80EXT_STOP_BIT
, // stop_bit: flag: frame has stop bit
1034 RECS80EXT_LSB
, // lsb_first: flag: LSB first
1035 RECS80EXT_FLAGS
// flags: some flags
1040 #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
1042 static PROGMEM IRMP_PARAMETER nubert_param
=
1044 IRMP_NUBERT_PROTOCOL
, // protocol: ir protocol
1045 NUBERT_1_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1046 NUBERT_1_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1047 NUBERT_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1048 NUBERT_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1049 NUBERT_0_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1050 NUBERT_0_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1051 NUBERT_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1052 NUBERT_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1053 NUBERT_ADDRESS_OFFSET
, // address_offset: address offset
1054 NUBERT_ADDRESS_OFFSET
+ NUBERT_ADDRESS_LEN
, // address_end: end of address
1055 NUBERT_COMMAND_OFFSET
, // command_offset: command offset
1056 NUBERT_COMMAND_OFFSET
+ NUBERT_COMMAND_LEN
, // command_end: end of command
1057 NUBERT_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1058 NUBERT_STOP_BIT
, // stop_bit: flag: frame has stop bit
1059 NUBERT_LSB
, // lsb_first: flag: LSB first
1060 NUBERT_FLAGS
// flags: some flags
1065 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1067 static PROGMEM IRMP_PARAMETER bang_olufsen_param
=
1069 IRMP_BANG_OLUFSEN_PROTOCOL
, // protocol: ir protocol
1070 BANG_OLUFSEN_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1071 BANG_OLUFSEN_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1072 BANG_OLUFSEN_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1073 BANG_OLUFSEN_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1074 BANG_OLUFSEN_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1075 BANG_OLUFSEN_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1076 BANG_OLUFSEN_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1077 BANG_OLUFSEN_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1078 BANG_OLUFSEN_ADDRESS_OFFSET
, // address_offset: address offset
1079 BANG_OLUFSEN_ADDRESS_OFFSET
+ BANG_OLUFSEN_ADDRESS_LEN
, // address_end: end of address
1080 BANG_OLUFSEN_COMMAND_OFFSET
, // command_offset: command offset
1081 BANG_OLUFSEN_COMMAND_OFFSET
+ BANG_OLUFSEN_COMMAND_LEN
, // command_end: end of command
1082 BANG_OLUFSEN_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1083 BANG_OLUFSEN_STOP_BIT
, // stop_bit: flag: frame has stop bit
1084 BANG_OLUFSEN_LSB
, // lsb_first: flag: LSB first
1085 BANG_OLUFSEN_FLAGS
// flags: some flags
1090 #if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1092 static PROGMEM IRMP_PARAMETER grundig_param
=
1094 IRMP_GRUNDIG_PROTOCOL
, // protocol: ir protocol
1095 GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1096 GRUNDIG_OR_NOKIA_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1097 GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1098 GRUNDIG_OR_NOKIA_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1099 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1100 1, // pulse_0_len_max: maximum length of pulse with bit value 0
1101 1, // pause_0_len_min: minimum length of pause with bit value 0
1102 1, // pause_0_len_max: maximum length of pause with bit value 0
1103 GRUNDIG_ADDRESS_OFFSET
, // address_offset: address offset
1104 GRUNDIG_ADDRESS_OFFSET
+ GRUNDIG_ADDRESS_LEN
, // address_end: end of address
1105 GRUNDIG_COMMAND_OFFSET
, // command_offset: command offset
1106 GRUNDIG_COMMAND_OFFSET
+ GRUNDIG_COMMAND_LEN
+ 1, // command_end: end of command (USE 1 bit MORE to STORE NOKIA DATA!)
1107 NOKIA_COMPLETE_DATA_LEN
, // complete_len: complete length of frame, here: NOKIA instead of GRUNDIG!
1108 GRUNDIG_OR_NOKIA_STOP_BIT
, // stop_bit: flag: frame has stop bit
1109 GRUNDIG_OR_NOKIA_LSB
, // lsb_first: flag: LSB first
1110 GRUNDIG_OR_NOKIA_FLAGS
// flags: some flags
1115 #if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
1117 static PROGMEM IRMP_PARAMETER siemens_param
=
1119 IRMP_SIEMENS_PROTOCOL
, // protocol: ir protocol
1120 SIEMENS_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1121 SIEMENS_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1122 SIEMENS_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1123 SIEMENS_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1124 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1125 1, // pulse_0_len_max: maximum length of pulse with bit value 0
1126 1, // pause_0_len_min: minimum length of pause with bit value 0
1127 1, // pause_0_len_max: maximum length of pause with bit value 0
1128 SIEMENS_ADDRESS_OFFSET
, // address_offset: address offset
1129 SIEMENS_ADDRESS_OFFSET
+ SIEMENS_ADDRESS_LEN
, // address_end: end of address
1130 SIEMENS_COMMAND_OFFSET
, // command_offset: command offset
1131 SIEMENS_COMMAND_OFFSET
+ SIEMENS_COMMAND_LEN
, // command_end: end of command
1132 SIEMENS_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1133 SIEMENS_STOP_BIT
, // stop_bit: flag: frame has stop bit
1134 SIEMENS_LSB
, // lsb_first: flag: LSB first
1135 SIEMENS_FLAGS
// flags: some flags
1140 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
1142 static PROGMEM IRMP_PARAMETER fdc_param
=
1144 IRMP_FDC_PROTOCOL
, // protocol: ir protocol
1145 FDC_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1146 FDC_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1147 FDC_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1148 FDC_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1149 FDC_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1150 FDC_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1151 FDC_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1152 FDC_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1153 FDC_ADDRESS_OFFSET
, // address_offset: address offset
1154 FDC_ADDRESS_OFFSET
+ FDC_ADDRESS_LEN
, // address_end: end of address
1155 FDC_COMMAND_OFFSET
, // command_offset: command offset
1156 FDC_COMMAND_OFFSET
+ FDC_COMMAND_LEN
, // command_end: end of command
1157 FDC_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1158 FDC_STOP_BIT
, // stop_bit: flag: frame has stop bit
1159 FDC_LSB
, // lsb_first: flag: LSB first
1160 FDC_FLAGS
// flags: some flags
1165 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1167 static PROGMEM IRMP_PARAMETER rccar_param
=
1169 IRMP_RCCAR_PROTOCOL
, // protocol: ir protocol
1170 RCCAR_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1171 RCCAR_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1172 RCCAR_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1173 RCCAR_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1174 RCCAR_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1175 RCCAR_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1176 RCCAR_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1177 RCCAR_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1178 RCCAR_ADDRESS_OFFSET
, // address_offset: address offset
1179 RCCAR_ADDRESS_OFFSET
+ RCCAR_ADDRESS_LEN
, // address_end: end of address
1180 RCCAR_COMMAND_OFFSET
, // command_offset: command offset
1181 RCCAR_COMMAND_OFFSET
+ RCCAR_COMMAND_LEN
, // command_end: end of command
1182 RCCAR_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1183 RCCAR_STOP_BIT
, // stop_bit: flag: frame has stop bit
1184 RCCAR_LSB
, // lsb_first: flag: LSB first
1185 RCCAR_FLAGS
// flags: some flags
1190 static uint8_t irmp_bit
; // current bit position
1191 static IRMP_PARAMETER irmp_param
;
1193 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1194 static IRMP_PARAMETER irmp_param2
;
1197 static volatile uint8_t irmp_ir_detected
;
1198 static volatile uint8_t irmp_protocol
;
1199 static volatile uint16_t irmp_address
;
1200 static volatile uint16_t irmp_command
;
1201 static volatile uint16_t irmp_id
; // only used for SAMSUNG protocol
1202 static volatile uint8_t irmp_flags
;
1205 static uint8_t IRMP_PIN
;
1208 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1209 * Initialize IRMP decoder
1210 * @details Configures IRMP input pin
1211 *---------------------------------------------------------------------------------------------------------------------------------------------------
1217 #ifndef PIC_CCS_COMPILER
1218 IRMP_PORT
&= ~(1<<IRMP_BIT
); // deactivate pullup
1219 IRMP_DDR
&= ~(1<<IRMP_BIT
); // set pin to input
1220 #endif // PIC_CCS_COMPILER
1222 #if IRMP_LOGGING == 1
1227 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1229 * @details gets decoded IRMP data
1230 * @param pointer in order to store IRMP data
1231 * @return TRUE: successful, FALSE: failed
1232 *---------------------------------------------------------------------------------------------------------------------------------------------------
1235 irmp_get_data (IRMP_DATA
* irmp_data_p
)
1237 uint8_t rtc
= FALSE
;
1239 if (irmp_ir_detected
)
1241 switch (irmp_protocol
)
1243 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1244 case IRMP_SAMSUNG_PROTOCOL
:
1245 if ((irmp_command
>> 8) == (~irmp_command
& 0x00FF))
1247 irmp_command
&= 0xff;
1248 irmp_command
|= irmp_id
<< 8;
1253 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
1254 case IRMP_NEC_PROTOCOL
:
1255 if ((irmp_command
>> 8) == (~irmp_command
& 0x00FF))
1257 irmp_command
&= 0xff;
1260 else if ((irmp_command
& 0xFF00) == 0xD100)
1262 ANALYZE_PRINTF ("Switching to APPLE protocol\n");
1263 irmp_protocol
= IRMP_APPLE_PROTOCOL
;
1264 irmp_command
&= 0xff;
1269 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1270 case IRMP_RCCAR_PROTOCOL
:
1271 // frame in irmp_data:
1272 // Bit 12 11 10 9 8 7 6 5 4 3 2 1 0
1273 // V D7 D6 D5 D4 D3 D2 D1 D0 A1 A0 C1 C0 // 10 9 8 7 6 5 4 3 2 1 0
1274 irmp_address
= (irmp_command
& 0x000C) >> 2; // addr: 0 0 0 0 0 0 0 0 0 A1 A0
1275 irmp_command
= ((irmp_command
& 0x1000) >> 2) | // V-Bit: V 0 0 0 0 0 0 0 0 0 0
1276 ((irmp_command
& 0x0003) << 8) | // C-Bits: 0 C1 C0 0 0 0 0 0 0 0 0
1277 ((irmp_command
& 0x0FF0) >> 4); // D-Bits: D7 D6 D5 D4 D3 D2 D1 D0
1278 rtc
= TRUE
; // Summe: V C1 C0 D7 D6 D5 D4 D3 D2 D1 D0
1287 irmp_data_p
->protocol
= irmp_protocol
;
1288 irmp_data_p
->address
= irmp_address
;
1289 irmp_data_p
->command
= irmp_command
;
1290 irmp_data_p
->flags
= irmp_flags
;
1296 irmp_ir_detected
= FALSE
;
1302 // these statics must not be volatile, because they are only used by irmp_store_bit(), which is called by irmp_ISR()
1303 static uint16_t irmp_tmp_address
; // ir address
1304 static uint16_t irmp_tmp_command
; // ir command
1306 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1307 static uint16_t irmp_tmp_address2
; // ir address
1308 static uint16_t irmp_tmp_command2
; // ir command
1311 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1312 static uint16_t irmp_tmp_id
; // ir id (only SAMSUNG)
1315 static uint8_t irmp_bit
; // current bit position
1317 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1319 * @details store bit in temp address or temp command
1320 * @param value to store: 0 or 1
1321 *---------------------------------------------------------------------------------------------------------------------------------------------------
1323 // verhindert, dass irmp_store_bit() inline compiliert wird:
1324 // static void irmp_store_bit (uint8_t) __attribute__ ((noinline));
1327 irmp_store_bit (uint8_t value
)
1329 if (irmp_bit
>= irmp_param
.address_offset
&& irmp_bit
< irmp_param
.address_end
)
1331 if (irmp_param
.lsb_first
)
1333 irmp_tmp_address
|= (((uint16_t) (value
)) << (irmp_bit
- irmp_param
.address_offset
)); // CV wants cast
1337 irmp_tmp_address
<<= 1;
1338 irmp_tmp_address
|= value
;
1341 else if (irmp_bit
>= irmp_param
.command_offset
&& irmp_bit
< irmp_param
.command_end
)
1343 if (irmp_param
.lsb_first
)
1345 irmp_tmp_command
|= (((uint16_t) (value
)) << (irmp_bit
- irmp_param
.command_offset
)); // CV wants cast
1349 irmp_tmp_command
<<= 1;
1350 irmp_tmp_command
|= value
;
1353 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1354 else if (irmp_param
.protocol
== IRMP_SAMSUNG_PROTOCOL
&& irmp_bit
>= SAMSUNG_ID_OFFSET
&& irmp_bit
< SAMSUNG_ID_OFFSET
+ SAMSUNG_ID_LEN
)
1356 irmp_tmp_id
|= (((uint16_t) (value
)) << (irmp_bit
- SAMSUNG_ID_OFFSET
)); // store with LSB first
1362 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1364 * @details store bit in temp address or temp command
1365 * @param value to store: 0 or 1
1366 *---------------------------------------------------------------------------------------------------------------------------------------------------
1368 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1370 irmp_store_bit2 (uint8_t value
)
1374 if (irmp_param
.protocol
)
1376 irmp_bit2
= irmp_bit
- 2;
1380 irmp_bit2
= irmp_bit
- 1;
1383 if (irmp_bit2
>= irmp_param2
.address_offset
&& irmp_bit2
< irmp_param2
.address_end
)
1385 irmp_tmp_address2
|= (((uint16_t) (value
)) << (irmp_bit2
- irmp_param2
.address_offset
)); // CV wants cast
1387 else if (irmp_bit2
>= irmp_param2
.command_offset
&& irmp_bit2
< irmp_param2
.command_end
)
1389 irmp_tmp_command2
|= (((uint16_t) (value
)) << (irmp_bit2
- irmp_param2
.command_offset
)); // CV wants cast
1392 #endif // IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1394 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1396 * @details ISR routine, called 10000 times per second
1397 *---------------------------------------------------------------------------------------------------------------------------------------------------
1402 static uint8_t irmp_start_bit_detected
; // flag: start bit detected
1403 static uint8_t wait_for_space
; // flag: wait for data bit space
1404 static uint8_t wait_for_start_space
; // flag: wait for start bit space
1405 static uint8_t irmp_pulse_time
; // count bit time for pulse
1406 static PAUSE_LEN irmp_pause_time
; // count bit time for pause
1407 static uint16_t last_irmp_address
= 0xFFFF; // save last irmp address to recognize key repetition
1408 static uint16_t last_irmp_command
= 0xFFFF; // save last irmp command to recognize key repetition
1409 static uint16_t repetition_counter
; // SIRCS repeats frame 2-5 times with 45 ms pause
1410 static uint8_t repetition_frame_number
;
1411 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
1412 static uint16_t last_irmp_denon_command
; // save last irmp command to recognize DENON frame repetition
1414 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
1415 static uint8_t rc5_cmd_bit6
; // bit 6 of RC5 command is the inverted 2nd start bit
1417 #if IRMP_SUPPORT_MANCHESTER == 1
1418 static PAUSE_LEN last_pause
; // last pause value
1420 #if IRMP_SUPPORT_MANCHESTER == 1 || IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1421 static uint8_t last_value
; // last bit value
1423 uint8_t irmp_input
; // input value
1429 irmp_input
= input(IRMP_PIN
);
1431 irmp_log(irmp_input
); // log ir signal, if IRMP_LOGGING defined
1433 if (! irmp_ir_detected
) // ir code already detected?
1435 if (! irmp_start_bit_detected
) // start bit detected?
1437 if (! irmp_input
) // receiving burst?
1440 if (! irmp_pulse_time
)
1442 ANALYZE_PRINTF("%8d [starting pulse]\n", time_counter
);
1445 irmp_pulse_time
++; // increment counter
1449 if (irmp_pulse_time
) // it's dark....
1450 { // set flags for counting the time of darkness...
1451 irmp_start_bit_detected
= 1;
1452 wait_for_start_space
= 1;
1454 irmp_tmp_command
= 0;
1455 irmp_tmp_address
= 0;
1457 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1458 irmp_tmp_command2
= 0;
1459 irmp_tmp_address2
= 0;
1463 irmp_pause_time
= 1; // 1st pause: set to 1, not to 0!
1464 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
1465 rc5_cmd_bit6
= 0; // fm 2010-03-07: bugfix: reset it after incomplete RC5 frame!
1470 if (repetition_counter
< 0xFFFF) // avoid overflow of counter
1472 repetition_counter
++;
1479 if (wait_for_start_space
) // we have received start bit...
1480 { // ...and are counting the time of darkness
1481 if (irmp_input
) // still dark?
1483 irmp_pause_time
++; // increment counter
1485 if (irmp_pause_time
> IRMP_TIMEOUT_LEN
) // timeout?
1487 ANALYZE_PRINTF ("error 1: pause after start bit pulse %d too long: %d\n", irmp_pulse_time
, irmp_pause_time
);
1488 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
1489 irmp_start_bit_detected
= 0; // reset flags, let's wait for another start bit
1490 irmp_pulse_time
= 0;
1491 irmp_pause_time
= 0;
1495 { // receiving first data pulse!
1496 IRMP_PARAMETER
* irmp_param_p
= (IRMP_PARAMETER
*) 0;
1498 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1499 irmp_param2
.protocol
= 0;
1502 ANALYZE_PRINTF ("start-bit: pulse = %d, pause = %d\n", irmp_pulse_time
, irmp_pause_time
);
1504 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
1505 if (irmp_pulse_time
>= SIRCS_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= SIRCS_START_BIT_PULSE_LEN_MAX
&&
1506 irmp_pause_time
>= SIRCS_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= SIRCS_START_BIT_PAUSE_LEN_MAX
)
1508 ANALYZE_PRINTF ("protocol = SIRCS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1509 SIRCS_START_BIT_PULSE_LEN_MIN
, SIRCS_START_BIT_PULSE_LEN_MAX
,
1510 SIRCS_START_BIT_PAUSE_LEN_MIN
, SIRCS_START_BIT_PAUSE_LEN_MAX
);
1511 irmp_param_p
= (IRMP_PARAMETER
*) (IRMP_PARAMETER
*) &sircs_param
;
1514 #endif // IRMP_SUPPORT_SIRCS_PROTOCOL == 1
1516 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
1517 if (irmp_pulse_time
>= NEC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= NEC_START_BIT_PULSE_LEN_MAX
&&
1518 irmp_pause_time
>= NEC_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= NEC_START_BIT_PAUSE_LEN_MAX
)
1520 ANALYZE_PRINTF ("protocol = NEC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1521 NEC_START_BIT_PULSE_LEN_MIN
, NEC_START_BIT_PULSE_LEN_MAX
,
1522 NEC_START_BIT_PAUSE_LEN_MIN
, NEC_START_BIT_PAUSE_LEN_MAX
);
1523 irmp_param_p
= (IRMP_PARAMETER
*) &nec_param
;
1525 else if (irmp_pulse_time
>= NEC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= NEC_START_BIT_PULSE_LEN_MAX
&&
1526 irmp_pause_time
>= NEC_REPEAT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= NEC_REPEAT_START_BIT_PAUSE_LEN_MAX
)
1528 ANALYZE_PRINTF ("protocol = NEC (repetition frame), start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1529 NEC_START_BIT_PULSE_LEN_MIN
, NEC_START_BIT_PULSE_LEN_MAX
,
1530 NEC_REPEAT_START_BIT_PAUSE_LEN_MIN
, NEC_REPEAT_START_BIT_PAUSE_LEN_MAX
);
1532 irmp_param_p
= (IRMP_PARAMETER
*) &nec_rep_param
;
1535 #endif // IRMP_SUPPORT_NEC_PROTOCOL == 1
1537 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1538 if (irmp_pulse_time
>= SAMSUNG_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_START_BIT_PULSE_LEN_MAX
&&
1539 irmp_pause_time
>= SAMSUNG_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_START_BIT_PAUSE_LEN_MAX
)
1541 ANALYZE_PRINTF ("protocol = SAMSUNG, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1542 SAMSUNG_START_BIT_PULSE_LEN_MIN
, SAMSUNG_START_BIT_PULSE_LEN_MAX
,
1543 SAMSUNG_START_BIT_PAUSE_LEN_MIN
, SAMSUNG_START_BIT_PAUSE_LEN_MAX
);
1544 irmp_param_p
= (IRMP_PARAMETER
*) &samsung_param
;
1547 #endif // IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1549 #if IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
1550 if (irmp_pulse_time
>= MATSUSHITA_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= MATSUSHITA_START_BIT_PULSE_LEN_MAX
&&
1551 irmp_pause_time
>= MATSUSHITA_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= MATSUSHITA_START_BIT_PAUSE_LEN_MAX
)
1552 { // it's MATSUSHITA
1553 ANALYZE_PRINTF ("protocol = MATSUSHITA, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1554 MATSUSHITA_START_BIT_PULSE_LEN_MIN
, MATSUSHITA_START_BIT_PULSE_LEN_MAX
,
1555 MATSUSHITA_START_BIT_PAUSE_LEN_MIN
, MATSUSHITA_START_BIT_PAUSE_LEN_MAX
);
1556 irmp_param_p
= (IRMP_PARAMETER
*) &matsushita_param
;
1559 #endif // IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
1561 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
1562 if (irmp_pulse_time
>= KASEIKYO_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= KASEIKYO_START_BIT_PULSE_LEN_MAX
&&
1563 irmp_pause_time
>= KASEIKYO_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= KASEIKYO_START_BIT_PAUSE_LEN_MAX
)
1565 ANALYZE_PRINTF ("protocol = KASEIKYO, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1566 KASEIKYO_START_BIT_PULSE_LEN_MIN
, KASEIKYO_START_BIT_PULSE_LEN_MAX
,
1567 KASEIKYO_START_BIT_PAUSE_LEN_MIN
, KASEIKYO_START_BIT_PAUSE_LEN_MAX
);
1568 irmp_param_p
= (IRMP_PARAMETER
*) &kaseikyo_param
;
1571 #endif // IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
1573 #if IRMP_SUPPORT_RECS80_PROTOCOL == 1
1574 if (irmp_pulse_time
>= RECS80_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RECS80_START_BIT_PULSE_LEN_MAX
&&
1575 irmp_pause_time
>= RECS80_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RECS80_START_BIT_PAUSE_LEN_MAX
)
1577 ANALYZE_PRINTF ("protocol = RECS80, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1578 RECS80_START_BIT_PULSE_LEN_MIN
, RECS80_START_BIT_PULSE_LEN_MAX
,
1579 RECS80_START_BIT_PAUSE_LEN_MIN
, RECS80_START_BIT_PAUSE_LEN_MAX
);
1580 irmp_param_p
= (IRMP_PARAMETER
*) &recs80_param
;
1583 #endif // IRMP_SUPPORT_RECS80_PROTOCOL == 1
1585 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
1586 if (((irmp_pulse_time
>= RC5_START_BIT_LEN_MIN
&& irmp_pulse_time
<= RC5_START_BIT_LEN_MAX
) ||
1587 (irmp_pulse_time
>= 2 * RC5_START_BIT_LEN_MIN
&& irmp_pulse_time
<= 2 * RC5_START_BIT_LEN_MAX
)) &&
1588 ((irmp_pause_time
>= RC5_START_BIT_LEN_MIN
&& irmp_pause_time
<= RC5_START_BIT_LEN_MAX
) ||
1589 (irmp_pause_time
>= 2 * RC5_START_BIT_LEN_MIN
&& irmp_pause_time
<= 2 * RC5_START_BIT_LEN_MAX
)))
1591 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
1592 if (irmp_pulse_time
>= FDC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_START_BIT_PULSE_LEN_MAX
&&
1593 irmp_pause_time
>= FDC_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_START_BIT_PAUSE_LEN_MAX
)
1595 ANALYZE_PRINTF ("protocol = RC5 or FDC\n");
1596 ANALYZE_PRINTF ("FDC start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1597 FDC_START_BIT_PULSE_LEN_MIN
, FDC_START_BIT_PULSE_LEN_MAX
,
1598 FDC_START_BIT_PAUSE_LEN_MIN
, FDC_START_BIT_PAUSE_LEN_MAX
);
1599 ANALYZE_PRINTF ("RC5 start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1600 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
1601 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
);
1602 memcpy_P (&irmp_param2
, &fdc_param
, sizeof (IRMP_PARAMETER
));
1605 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
1606 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1607 if (irmp_pulse_time
>= RCCAR_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_START_BIT_PULSE_LEN_MAX
&&
1608 irmp_pause_time
>= RCCAR_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_START_BIT_PAUSE_LEN_MAX
)
1610 ANALYZE_PRINTF ("protocol = RC5 or RCCAR\n");
1611 ANALYZE_PRINTF ("RCCAR start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1612 RCCAR_START_BIT_PULSE_LEN_MIN
, RCCAR_START_BIT_PULSE_LEN_MAX
,
1613 RCCAR_START_BIT_PAUSE_LEN_MIN
, RCCAR_START_BIT_PAUSE_LEN_MAX
);
1614 ANALYZE_PRINTF ("RC5 start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1615 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
1616 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
);
1617 memcpy_P (&irmp_param2
, &rccar_param
, sizeof (IRMP_PARAMETER
));
1620 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1622 ANALYZE_PRINTF ("protocol = RC5, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1623 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
1624 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
);
1627 irmp_param_p
= (IRMP_PARAMETER
*) &rc5_param
;
1628 last_pause
= irmp_pause_time
;
1630 if ((irmp_pulse_time
> RC5_START_BIT_LEN_MAX
&& irmp_pulse_time
<= 2 * RC5_START_BIT_LEN_MAX
) ||
1631 (irmp_pause_time
> RC5_START_BIT_LEN_MAX
&& irmp_pause_time
<= 2 * RC5_START_BIT_LEN_MAX
))
1634 rc5_cmd_bit6
= 1<<6;
1642 #endif // IRMP_SUPPORT_RC5_PROTOCOL == 1
1644 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
1645 if ( (irmp_pulse_time
>= DENON_PULSE_LEN_MIN
&& irmp_pulse_time
<= DENON_PULSE_LEN_MAX
) &&
1646 ((irmp_pause_time
>= DENON_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_1_PAUSE_LEN_MAX
) ||
1647 (irmp_pause_time
>= DENON_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_0_PAUSE_LEN_MAX
)))
1649 ANALYZE_PRINTF ("protocol = DENON, start bit timings: pulse: %3d - %3d, pause: %3d - %3d or %3d - %3d\n",
1650 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
,
1651 DENON_1_PAUSE_LEN_MIN
, DENON_1_PAUSE_LEN_MAX
,
1652 DENON_0_PAUSE_LEN_MIN
, DENON_0_PAUSE_LEN_MAX
);
1653 irmp_param_p
= (IRMP_PARAMETER
*) &denon_param
;
1656 #endif // IRMP_SUPPORT_DENON_PROTOCOL == 1
1658 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
1659 if (irmp_pulse_time
>= RC6_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RC6_START_BIT_PULSE_LEN_MAX
&&
1660 irmp_pause_time
>= RC6_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RC6_START_BIT_PAUSE_LEN_MAX
)
1662 ANALYZE_PRINTF ("protocol = RC6, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1663 RC6_START_BIT_PULSE_LEN_MIN
, RC6_START_BIT_PULSE_LEN_MAX
,
1664 RC6_START_BIT_PAUSE_LEN_MIN
, RC6_START_BIT_PAUSE_LEN_MAX
);
1665 irmp_param_p
= (IRMP_PARAMETER
*) &rc6_param
;
1670 #endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
1672 #if IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
1673 if (irmp_pulse_time
>= RECS80EXT_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RECS80EXT_START_BIT_PULSE_LEN_MAX
&&
1674 irmp_pause_time
>= RECS80EXT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RECS80EXT_START_BIT_PAUSE_LEN_MAX
)
1676 ANALYZE_PRINTF ("protocol = RECS80EXT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1677 RECS80EXT_START_BIT_PULSE_LEN_MIN
, RECS80EXT_START_BIT_PULSE_LEN_MAX
,
1678 RECS80EXT_START_BIT_PAUSE_LEN_MIN
, RECS80EXT_START_BIT_PAUSE_LEN_MAX
);
1679 irmp_param_p
= (IRMP_PARAMETER
*) &recs80ext_param
;
1682 #endif // IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
1684 #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
1685 if (irmp_pulse_time
>= NUBERT_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= NUBERT_START_BIT_PULSE_LEN_MAX
&&
1686 irmp_pause_time
>= NUBERT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= NUBERT_START_BIT_PAUSE_LEN_MAX
)
1688 ANALYZE_PRINTF ("protocol = NUBERT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1689 NUBERT_START_BIT_PULSE_LEN_MIN
, NUBERT_START_BIT_PULSE_LEN_MAX
,
1690 NUBERT_START_BIT_PAUSE_LEN_MIN
, NUBERT_START_BIT_PAUSE_LEN_MAX
);
1691 irmp_param_p
= (IRMP_PARAMETER
*) &nubert_param
;
1694 #endif // IRMP_SUPPORT_NUBERT_PROTOCOL == 1
1696 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1697 if (irmp_pulse_time
>= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN
&& irmp_pulse_time
<= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX
&&
1698 irmp_pause_time
>= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX
)
1699 { // it's BANG_OLUFSEN
1700 ANALYZE_PRINTF ("protocol = BANG_OLUFSEN\n");
1701 ANALYZE_PRINTF ("start bit 1 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1702 BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX
,
1703 BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX
);
1704 ANALYZE_PRINTF ("start bit 2 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1705 BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX
,
1706 BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX
);
1707 ANALYZE_PRINTF ("start bit 3 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1708 BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX
,
1709 BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX
);
1710 ANALYZE_PRINTF ("start bit 4 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1711 BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX
,
1712 BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX
);
1713 irmp_param_p
= (IRMP_PARAMETER
*) &bang_olufsen_param
;
1717 #endif // IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1719 #if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1720 if (irmp_pulse_time
>= GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN
&& irmp_pulse_time
<= GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX
&&
1721 irmp_pause_time
>= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN
&& irmp_pause_time
<= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX
)
1723 ANALYZE_PRINTF ("protocol = GRUNDIG, pre bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1724 GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN
, GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX
,
1725 GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN
, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX
);
1726 irmp_param_p
= (IRMP_PARAMETER
*) &grundig_param
;
1727 last_pause
= irmp_pause_time
;
1731 #endif // IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1733 #if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
1734 if (((irmp_pulse_time
>= SIEMENS_START_BIT_LEN_MIN
&& irmp_pulse_time
<= SIEMENS_START_BIT_LEN_MAX
) ||
1735 (irmp_pulse_time
>= 2 * SIEMENS_START_BIT_LEN_MIN
&& irmp_pulse_time
<= 2 * SIEMENS_START_BIT_LEN_MAX
)) &&
1736 ((irmp_pause_time
>= SIEMENS_START_BIT_LEN_MIN
&& irmp_pause_time
<= SIEMENS_START_BIT_LEN_MAX
) ||
1737 (irmp_pause_time
>= 2 * SIEMENS_START_BIT_LEN_MIN
&& irmp_pause_time
<= 2 * SIEMENS_START_BIT_LEN_MAX
)))
1739 ANALYZE_PRINTF ("protocol = SIEMENS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1740 SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
,
1741 SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
);
1742 irmp_param_p
= (IRMP_PARAMETER
*) &siemens_param
;
1743 last_pause
= irmp_pause_time
;
1747 #endif // IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
1748 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
1749 if (irmp_pulse_time
>= FDC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_START_BIT_PULSE_LEN_MAX
&&
1750 irmp_pause_time
>= FDC_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_START_BIT_PAUSE_LEN_MAX
)
1752 ANALYZE_PRINTF ("protocol = FDC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1753 FDC_START_BIT_PULSE_LEN_MIN
, FDC_START_BIT_PULSE_LEN_MAX
,
1754 FDC_START_BIT_PAUSE_LEN_MIN
, FDC_START_BIT_PAUSE_LEN_MAX
);
1755 irmp_param_p
= (IRMP_PARAMETER
*) &fdc_param
;
1758 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
1759 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1760 if (irmp_pulse_time
>= RCCAR_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_START_BIT_PULSE_LEN_MAX
&&
1761 irmp_pause_time
>= RCCAR_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_START_BIT_PAUSE_LEN_MAX
)
1763 ANALYZE_PRINTF ("protocol = RCCAR, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1764 RCCAR_START_BIT_PULSE_LEN_MIN
, RCCAR_START_BIT_PULSE_LEN_MAX
,
1765 RCCAR_START_BIT_PAUSE_LEN_MIN
, RCCAR_START_BIT_PAUSE_LEN_MAX
);
1766 irmp_param_p
= (IRMP_PARAMETER
*) &rccar_param
;
1769 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1771 ANALYZE_PRINTF ("protocol = UNKNOWN\n");
1772 irmp_start_bit_detected
= 0; // wait for another start bit...
1775 if (irmp_start_bit_detected
)
1777 memcpy_P (&irmp_param
, irmp_param_p
, sizeof (IRMP_PARAMETER
));
1780 if (! (irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
))
1782 ANALYZE_PRINTF ("pulse_1: %3d - %3d\n", irmp_param
.pulse_1_len_min
, irmp_param
.pulse_1_len_max
);
1783 ANALYZE_PRINTF ("pause_1: %3d - %3d\n", irmp_param
.pause_1_len_min
, irmp_param
.pause_1_len_max
);
1787 ANALYZE_PRINTF ("pulse: %3d - %3d or %3d - %3d\n", irmp_param
.pulse_1_len_min
, irmp_param
.pulse_1_len_max
,
1788 2 * irmp_param
.pulse_1_len_min
, 2 * irmp_param
.pulse_1_len_max
);
1789 ANALYZE_PRINTF ("pause: %3d - %3d or %3d - %3d\n", irmp_param
.pause_1_len_min
, irmp_param
.pause_1_len_max
,
1790 2 * irmp_param
.pause_1_len_min
, 2 * irmp_param
.pause_1_len_max
);
1793 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1794 if (irmp_param2
.protocol
)
1796 ANALYZE_PRINTF ("pulse_0: %3d - %3d\n", irmp_param2
.pulse_0_len_min
, irmp_param2
.pulse_0_len_max
);
1797 ANALYZE_PRINTF ("pause_0: %3d - %3d\n", irmp_param2
.pause_0_len_min
, irmp_param2
.pause_0_len_max
);
1798 ANALYZE_PRINTF ("pulse_1: %3d - %3d\n", irmp_param2
.pulse_1_len_min
, irmp_param2
.pulse_1_len_max
);
1799 ANALYZE_PRINTF ("pause_1: %3d - %3d\n", irmp_param2
.pause_1_len_min
, irmp_param2
.pause_1_len_max
);
1804 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
1805 if (irmp_param
.protocol
== IRMP_RC6_PROTOCOL
)
1807 ANALYZE_PRINTF ("pulse_toggle: %3d - %3d\n", RC6_TOGGLE_BIT_LEN_MIN
, RC6_TOGGLE_BIT_LEN_MAX
);
1811 if (! (irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
))
1813 ANALYZE_PRINTF ("pulse_0: %3d - %3d\n", irmp_param
.pulse_0_len_min
, irmp_param
.pulse_0_len_max
);
1814 ANALYZE_PRINTF ("pause_0: %3d - %3d\n", irmp_param
.pause_0_len_min
, irmp_param
.pause_0_len_max
);
1817 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1818 if (irmp_param
.protocol
== IRMP_BANG_OLUFSEN_PROTOCOL
)
1820 ANALYZE_PRINTF ("pulse_r: %3d - %3d\n", irmp_param
.pulse_0_len_min
, irmp_param
.pulse_0_len_max
);
1821 ANALYZE_PRINTF ("pause_r: %3d - %3d\n", BANG_OLUFSEN_R_PAUSE_LEN_MIN
, BANG_OLUFSEN_R_PAUSE_LEN_MAX
);
1825 ANALYZE_PRINTF ("command_offset: %2d\n", irmp_param
.command_offset
);
1826 ANALYZE_PRINTF ("command_len: %3d\n", irmp_param
.command_end
- irmp_param
.command_offset
);
1827 ANALYZE_PRINTF ("complete_len: %3d\n", irmp_param
.complete_len
);
1828 ANALYZE_PRINTF ("stop_bit: %3d\n", irmp_param
.stop_bit
);
1834 #if IRMP_SUPPORT_MANCHESTER == 1
1835 if ((irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
) && irmp_param
.protocol
!= IRMP_RC6_PROTOCOL
) // Manchester, but not RC6
1837 if (irmp_pause_time
> irmp_param
.pulse_1_len_max
&& irmp_pause_time
<= 2 * irmp_param
.pulse_1_len_max
)
1839 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1840 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '0' : '1');
1842 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 0 : 1);
1844 else if (! last_value
) // && irmp_pause_time >= irmp_param.pause_1_len_min && irmp_pause_time <= irmp_param.pause_1_len_max)
1846 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1848 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '1' : '0');
1850 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0);
1854 #endif // IRMP_SUPPORT_MANCHESTER == 1
1856 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
1857 if (irmp_param
.protocol
== IRMP_DENON_PROTOCOL
)
1859 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1861 if (irmp_pause_time
>= DENON_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_1_PAUSE_LEN_MAX
)
1862 { // pause timings correct for "1"?
1863 ANALYZE_PUTCHAR ('1'); // yes, store 1
1867 else // if (irmp_pause_time >= DENON_0_PAUSE_LEN_MIN && irmp_pause_time <= DENON_0_PAUSE_LEN_MAX)
1868 { // pause timings correct for "0"?
1869 ANALYZE_PUTCHAR ('0'); // yes, store 0
1875 #endif // IRMP_SUPPORT_DENON_PROTOCOL == 1
1877 ; // else do nothing
1880 irmp_pulse_time
= 1; // set counter to 1, not 0
1881 irmp_pause_time
= 0;
1882 wait_for_start_space
= 0;
1885 else if (wait_for_space
) // the data section....
1886 { // counting the time of darkness....
1887 uint8_t got_light
= FALSE
;
1889 if (irmp_input
) // still dark?
1891 if (irmp_bit
== irmp_param
.complete_len
&& irmp_param
.stop_bit
== 1)
1893 if (irmp_pulse_time
>= irmp_param
.pulse_0_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_0_len_max
)
1896 if (! (irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
))
1898 ANALYZE_PRINTF ("stop bit detected\n");
1901 irmp_param
.stop_bit
= 0;
1905 ANALYZE_PRINTF ("stop bit timing wrong\n");
1907 irmp_start_bit_detected
= 0; // wait for another start bit...
1908 irmp_pulse_time
= 0;
1909 irmp_pause_time
= 0;
1914 irmp_pause_time
++; // increment counter
1916 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
1917 if (irmp_param
.protocol
== IRMP_SIRCS_PROTOCOL
&& // Sony has a variable number of bits:
1918 irmp_pause_time
> SIRCS_PAUSE_LEN_MAX
&& // minimum is 12
1919 irmp_bit
>= 12 - 1) // pause too long?
1920 { // yes, break and close this frame
1921 irmp_param
.complete_len
= irmp_bit
+ 1; // set new complete length
1922 got_light
= TRUE
; // this is a lie, but helps (generates stop bit)
1923 irmp_param
.command_end
= irmp_param
.command_offset
+ irmp_bit
+ 1; // correct command length
1924 irmp_pause_time
= SIRCS_PAUSE_LEN_MAX
- 1; // correct pause length
1928 #if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1929 if (irmp_param
.protocol
== IRMP_GRUNDIG_PROTOCOL
&& !irmp_param
.stop_bit
)
1931 if (irmp_pause_time
> 2 * irmp_param
.pause_1_len_max
&& irmp_bit
>= GRUNDIG_COMPLETE_DATA_LEN
- 2)
1932 { // special manchester decoder
1933 irmp_param
.complete_len
= GRUNDIG_COMPLETE_DATA_LEN
; // correct complete len
1934 got_light
= TRUE
; // this is a lie, but generates a stop bit ;-)
1935 irmp_param
.stop_bit
= TRUE
; // set flag
1937 else if (irmp_bit
>= GRUNDIG_COMPLETE_DATA_LEN
)
1939 ANALYZE_PRINTF ("Switching to NOKIA protocol\n");
1940 irmp_param
.protocol
= IRMP_NOKIA_PROTOCOL
; // change protocol
1941 irmp_param
.address_offset
= NOKIA_ADDRESS_OFFSET
;
1942 irmp_param
.address_end
= NOKIA_ADDRESS_OFFSET
+ NOKIA_ADDRESS_LEN
;
1943 irmp_param
.command_offset
= NOKIA_COMMAND_OFFSET
;
1944 irmp_param
.command_end
= NOKIA_COMMAND_OFFSET
+ NOKIA_COMMAND_LEN
;
1946 if (irmp_tmp_command
& 0x300)
1948 irmp_tmp_address
= (irmp_tmp_command
>> 8);
1949 irmp_tmp_command
&= 0xFF;
1955 #if IRMP_SUPPORT_MANCHESTER == 1
1956 if ((irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
) &&
1957 irmp_pause_time
> 2 * irmp_param
.pause_1_len_max
&& irmp_bit
>= irmp_param
.complete_len
- 2 && !irmp_param
.stop_bit
)
1958 { // special manchester decoder
1959 got_light
= TRUE
; // this is a lie, but generates a stop bit ;-)
1960 irmp_param
.stop_bit
= TRUE
; // set flag
1963 #endif // IRMP_SUPPORT_MANCHESTER == 1
1964 if (irmp_pause_time
> IRMP_TIMEOUT_LEN
) // timeout?
1966 if (irmp_bit
== irmp_param
.complete_len
- 1 && irmp_param
.stop_bit
== 0)
1972 ANALYZE_PRINTF ("error 2: pause %d after data bit %d too long\n", irmp_pause_time
, irmp_bit
);
1973 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
1975 irmp_start_bit_detected
= 0; // wait for another start bit...
1976 irmp_pulse_time
= 0;
1977 irmp_pause_time
= 0;
1989 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1991 #if IRMP_SUPPORT_MANCHESTER == 1
1992 if ((irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
)) // Manchester
1994 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
1995 if (irmp_param
.protocol
== IRMP_RC6_PROTOCOL
&& irmp_bit
>= 3 && irmp_bit
<= 5) // special bits of RC6
1997 if (irmp_pulse_time
> RC6_TOGGLE_BIT_LEN_MAX
&& irmp_pause_time
> RC6_TOGGLE_BIT_LEN_MAX
)
1999 ANALYZE_PUTCHAR ('1');
2003 ANALYZE_PUTCHAR ('0');
2009 #endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
2010 if (irmp_pulse_time
> irmp_param
.pulse_1_len_max
&& irmp_pulse_time
<= 2 * irmp_param
.pulse_1_len_max
)
2012 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '0' : '1');
2013 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 0 : 1 );
2014 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '1' : '0');
2015 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0 );
2016 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
2017 if (! irmp_param2
.protocol
)
2022 last_value
= (irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0;
2024 else if (irmp_pulse_time
>= irmp_param
.pulse_1_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_1_len_max
)
2026 uint8_t manchester_value
;
2028 if (last_pause
> irmp_param
.pause_1_len_max
&& last_pause
<= 2 * irmp_param
.pause_1_len_max
)
2030 manchester_value
= last_value
? 0 : 1;
2031 last_value
= manchester_value
;
2035 manchester_value
= last_value
;
2039 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
2040 if (irmp_param
.protocol
== IRMP_RC6_PROTOCOL
&& irmp_bit
== 1 && manchester_value
== 0) // RC6 mode != 0 ???
2042 irmp_param
.complete_len
= RC6_COMPLETE_DATA_LEN_LONG
;
2044 #endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
2047 ANALYZE_PUTCHAR (manchester_value
+ '0');
2048 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
2049 if (! irmp_param2
.protocol
)
2054 irmp_store_bit (manchester_value
);
2058 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_FDC_PROTOCOL == 1
2059 if (irmp_param2
.protocol
== IRMP_FDC_PROTOCOL
&&
2060 irmp_pulse_time
>= FDC_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_PULSE_LEN_MAX
&&
2061 ((irmp_pause_time
>= FDC_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_1_PAUSE_LEN_MAX
) ||
2062 (irmp_pause_time
>= FDC_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_0_PAUSE_LEN_MAX
)))
2064 ANALYZE_PUTCHAR ('?');
2065 irmp_param
.protocol
= 0; // switch to FDC, see below
2068 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
2069 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2070 if (irmp_param2
.protocol
== IRMP_RCCAR_PROTOCOL
&&
2071 irmp_pulse_time
>= RCCAR_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_PULSE_LEN_MAX
&&
2072 ((irmp_pause_time
>= RCCAR_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_1_PAUSE_LEN_MAX
) ||
2073 (irmp_pause_time
>= RCCAR_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_0_PAUSE_LEN_MAX
)))
2075 ANALYZE_PUTCHAR ('?');
2076 irmp_param
.protocol
= 0; // switch to RCCAR, see below
2079 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2081 ANALYZE_PUTCHAR ('?');
2083 ANALYZE_PRINTF ("error 3 RC5: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2084 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2085 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2086 irmp_pause_time
= 0;
2090 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_FDC_PROTOCOL == 1
2091 if (irmp_param2
.protocol
== IRMP_FDC_PROTOCOL
&& irmp_pulse_time
>= FDC_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_PULSE_LEN_MAX
)
2093 if (irmp_pause_time
>= FDC_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_1_PAUSE_LEN_MAX
)
2095 ANALYZE_PRINTF (" 1 (FDC)\n");
2096 irmp_store_bit2 (1);
2098 else if (irmp_pause_time
>= FDC_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_0_PAUSE_LEN_MAX
)
2100 ANALYZE_PRINTF (" 0 (FDC)\n");
2101 irmp_store_bit2 (0);
2104 if (! irmp_param
.protocol
)
2106 ANALYZE_PRINTF ("Switching to FDC protocol\n");
2107 memcpy (&irmp_param
, &irmp_param2
, sizeof (IRMP_PARAMETER
));
2108 irmp_param2
.protocol
= 0;
2109 irmp_tmp_address
= irmp_tmp_address2
;
2110 irmp_tmp_command
= irmp_tmp_command2
;
2113 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
2114 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2115 if (irmp_param2
.protocol
== IRMP_RCCAR_PROTOCOL
&& irmp_pulse_time
>= RCCAR_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_PULSE_LEN_MAX
)
2117 if (irmp_pause_time
>= RCCAR_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_1_PAUSE_LEN_MAX
)
2119 ANALYZE_PRINTF (" 1 (RCCAR)\n");
2120 irmp_store_bit2 (1);
2122 else if (irmp_pause_time
>= RCCAR_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_0_PAUSE_LEN_MAX
)
2124 ANALYZE_PRINTF (" 0 (RCCAR)\n");
2125 irmp_store_bit2 (0);
2128 if (! irmp_param
.protocol
)
2130 ANALYZE_PRINTF ("Switching to RCCAR protocol\n");
2131 memcpy (&irmp_param
, &irmp_param2
, sizeof (IRMP_PARAMETER
));
2132 irmp_param2
.protocol
= 0;
2133 irmp_tmp_address
= irmp_tmp_address2
;
2134 irmp_tmp_command
= irmp_tmp_command2
;
2137 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2139 last_pause
= irmp_pause_time
;
2143 #endif // IRMP_SUPPORT_MANCHESTER == 1
2146 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
2147 if (irmp_param
.protocol
== IRMP_SAMSUNG_PROTOCOL
&& irmp_bit
== 16) // Samsung: 16th bit
2149 if (irmp_pulse_time
>= SAMSUNG_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_PULSE_LEN_MAX
&&
2150 irmp_pause_time
>= SAMSUNG_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_START_BIT_PAUSE_LEN_MAX
)
2152 ANALYZE_PRINTF ("SYNC\n");
2157 else if (irmp_pulse_time
>= SAMSUNG_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_PULSE_LEN_MAX
)
2159 irmp_param
.protocol
= IRMP_SAMSUNG32_PROTOCOL
;
2160 irmp_param
.command_offset
= SAMSUNG32_COMMAND_OFFSET
;
2161 irmp_param
.command_end
= SAMSUNG32_COMMAND_OFFSET
+ SAMSUNG32_COMMAND_LEN
;
2162 irmp_param
.complete_len
= SAMSUNG32_COMPLETE_DATA_LEN
;
2164 if (irmp_pause_time
>= SAMSUNG_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_1_PAUSE_LEN_MAX
)
2166 ANALYZE_PUTCHAR ('1');
2173 ANALYZE_PUTCHAR ('0');
2179 ANALYZE_PRINTF ("Switching to SAMSUNG32 protocol\n");
2182 { // timing incorrect!
2183 ANALYZE_PRINTF ("error 3 Samsung: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2184 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2185 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2186 irmp_pause_time
= 0;
2190 #endif // IRMP_SUPPORT_SAMSUNG_PROTOCOL
2192 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
2193 if (irmp_param
.protocol
== IRMP_BANG_OLUFSEN_PROTOCOL
)
2195 if (irmp_pulse_time
>= BANG_OLUFSEN_PULSE_LEN_MIN
&& irmp_pulse_time
<= BANG_OLUFSEN_PULSE_LEN_MAX
)
2197 if (irmp_bit
== 1) // Bang & Olufsen: 3rd bit
2199 if (irmp_pause_time
>= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX
)
2201 ANALYZE_PRINTF ("3rd start bit\n");
2206 { // timing incorrect!
2207 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
);
2208 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2209 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2210 irmp_pause_time
= 0;
2213 else if (irmp_bit
== 19) // Bang & Olufsen: trailer bit
2215 if (irmp_pause_time
>= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX
)
2217 ANALYZE_PRINTF ("trailer bit\n");
2222 { // timing incorrect!
2223 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
);
2224 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2225 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2226 irmp_pause_time
= 0;
2231 if (irmp_pause_time
>= BANG_OLUFSEN_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_1_PAUSE_LEN_MAX
)
2232 { // pulse & pause timings correct for "1"?
2233 ANALYZE_PUTCHAR ('1');
2239 else if (irmp_pause_time
>= BANG_OLUFSEN_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_0_PAUSE_LEN_MAX
)
2240 { // pulse & pause timings correct for "0"?
2241 ANALYZE_PUTCHAR ('0');
2247 else if (irmp_pause_time
>= BANG_OLUFSEN_R_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_R_PAUSE_LEN_MAX
)
2249 ANALYZE_PUTCHAR (last_value
+ '0');
2251 irmp_store_bit (last_value
);
2255 { // timing incorrect!
2256 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
);
2257 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2258 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2259 irmp_pause_time
= 0;
2264 { // timing incorrect!
2265 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
);
2266 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2267 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2268 irmp_pause_time
= 0;
2272 #endif // IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL
2274 if (irmp_pulse_time
>= irmp_param
.pulse_1_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_1_len_max
&&
2275 irmp_pause_time
>= irmp_param
.pause_1_len_min
&& irmp_pause_time
<= irmp_param
.pause_1_len_max
)
2276 { // pulse & pause timings correct for "1"?
2277 ANALYZE_PUTCHAR ('1');
2282 else if (irmp_pulse_time
>= irmp_param
.pulse_0_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_0_len_max
&&
2283 irmp_pause_time
>= irmp_param
.pause_0_len_min
&& irmp_pause_time
<= irmp_param
.pause_0_len_max
)
2284 { // pulse & pause timings correct for "0"?
2285 ANALYZE_PUTCHAR ('0');
2291 { // timing incorrect!
2292 ANALYZE_PRINTF ("error 3: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2293 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2294 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2295 irmp_pause_time
= 0;
2298 irmp_pulse_time
= 1; // set counter to 1, not 0
2302 { // counting the pulse length ...
2303 if (! irmp_input
) // still light?
2305 irmp_pulse_time
++; // increment counter
2309 wait_for_space
= 1; // let's count the time (see above)
2310 irmp_pause_time
= 1; // set pause counter to 1, not 0
2314 if (irmp_start_bit_detected
&& irmp_bit
== irmp_param
.complete_len
&& irmp_param
.stop_bit
== 0) // enough bits received?
2316 if (last_irmp_command
== irmp_tmp_command
&& repetition_counter
< AUTO_FRAME_REPETITION_LEN
)
2318 repetition_frame_number
++;
2322 repetition_frame_number
= 0;
2325 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
2326 // if SIRCS protocol and the code will be repeated within 50 ms, we will ignore 2nd and 3rd repetition frame
2327 if (irmp_param
.protocol
== IRMP_SIRCS_PROTOCOL
&& (repetition_frame_number
== 1 || repetition_frame_number
== 2))
2329 ANALYZE_PRINTF ("code skipped: SIRCS auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2330 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2331 repetition_counter
= 0;
2336 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
2337 // if SAMSUNG32 protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
2338 if (irmp_param
.protocol
== IRMP_SAMSUNG32_PROTOCOL
&& (repetition_frame_number
& 0x01))
2340 ANALYZE_PRINTF ("code skipped: SAMSUNG32 auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2341 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2342 repetition_counter
= 0;
2347 #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
2348 // if NUBERT protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
2349 if (irmp_param
.protocol
== IRMP_NUBERT_PROTOCOL
&& (repetition_frame_number
& 0x01))
2351 ANALYZE_PRINTF ("code skipped: NUBERT auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2352 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2353 repetition_counter
= 0;
2359 ANALYZE_PRINTF ("code detected, length = %d\n", irmp_bit
);
2360 irmp_ir_detected
= TRUE
;
2362 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
2363 if (irmp_param
.protocol
== IRMP_DENON_PROTOCOL
)
2364 { // check for repetition frame
2365 if ((~irmp_tmp_command
& 0x3FF) == last_irmp_denon_command
) // command bits must be inverted
2367 irmp_tmp_command
= last_irmp_denon_command
; // use command received before!
2369 irmp_protocol
= irmp_param
.protocol
; // store protocol
2370 irmp_address
= irmp_tmp_address
; // store address
2371 irmp_command
= irmp_tmp_command
; // store command
2375 ANALYZE_PRINTF ("waiting for inverted command repetition\n");
2376 irmp_ir_detected
= FALSE
;
2377 last_irmp_denon_command
= irmp_tmp_command
;
2381 #endif // IRMP_SUPPORT_DENON_PROTOCOL
2383 #if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1
2384 if (irmp_param
.protocol
== IRMP_GRUNDIG_PROTOCOL
&& irmp_tmp_command
== 0x01ff)
2385 { // Grundig start frame?
2386 ANALYZE_PRINTF ("Detected GRUNDIG start frame, ignoring it\n");
2387 irmp_ir_detected
= FALSE
;
2390 #endif // IRMP_SUPPORT_GRUNDIG_PROTOCOL
2392 #if IRMP_SUPPORT_NOKIA_PROTOCOL == 1
2393 if (irmp_param
.protocol
== IRMP_NOKIA_PROTOCOL
&& irmp_tmp_address
== 0x00ff && irmp_tmp_command
== 0x00fe)
2394 { // Nokia start frame?
2395 ANALYZE_PRINTF ("Detected NOKIA start frame, ignoring it\n");
2396 irmp_ir_detected
= FALSE
;
2399 #endif // IRMP_SUPPORT_NOKIA_PROTOCOL
2401 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
2402 if (irmp_param
.protocol
== IRMP_NEC_PROTOCOL
&& irmp_bit
== 0) // repetition frame
2404 if (repetition_counter
< NEC_FRAME_REPEAT_PAUSE_LEN_MAX
)
2406 ANALYZE_PRINTF ("Detected NEC repetition frame, repetition_counter = %d\n", repetition_counter
);
2407 irmp_tmp_address
= last_irmp_address
; // address is last address
2408 irmp_tmp_command
= last_irmp_command
; // command is last command
2409 irmp_flags
|= IRMP_FLAG_REPETITION
;
2410 repetition_counter
= 0;
2414 ANALYZE_PRINTF ("Detected NEC repetition frame, ignoring it: timeout occured, repetition_counter = %d > %d\n",
2415 repetition_counter
, NEC_FRAME_REPEAT_PAUSE_LEN_MAX
);
2416 irmp_ir_detected
= FALSE
;
2419 #endif // IRMP_SUPPORT_NEC_PROTOCOL
2420 irmp_protocol
= irmp_param
.protocol
;
2422 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
2423 if (irmp_param
.protocol
== IRMP_FDC_PROTOCOL
)
2425 if (irmp_tmp_command
& 0x000F) // released key?
2427 irmp_tmp_command
= (irmp_tmp_command
>> 4) | 0x80; // yes, set bit 7
2431 irmp_tmp_command
>>= 4; // no, it's a pressed key
2433 irmp_tmp_command
|= (irmp_tmp_address
<< 2) & 0x0F00; // 000000CCCCAAAAAA -> 0000CCCC00000000
2434 irmp_tmp_address
&= 0x003F;
2438 irmp_address
= irmp_tmp_address
; // store address
2439 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
2440 last_irmp_address
= irmp_tmp_address
; // store as last address, too
2443 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
2444 if (irmp_param
.protocol
== IRMP_RC5_PROTOCOL
)
2446 irmp_tmp_command
|= rc5_cmd_bit6
; // store bit 6
2449 irmp_command
= irmp_tmp_command
; // store command
2451 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
2452 irmp_id
= irmp_tmp_id
;
2457 if (irmp_ir_detected
)
2459 if (last_irmp_command
== irmp_command
&&
2460 last_irmp_address
== irmp_address
&&
2461 repetition_counter
< IRMP_KEY_REPETITION_LEN
)
2463 irmp_flags
|= IRMP_FLAG_REPETITION
;
2466 last_irmp_address
= irmp_tmp_address
; // store as last address, too
2467 last_irmp_command
= irmp_tmp_command
; // store as last command, too
2469 repetition_counter
= 0;
2473 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2476 irmp_start_bit_detected
= 0; // and wait for next start bit
2477 irmp_tmp_command
= 0;
2478 irmp_pulse_time
= 0;
2479 irmp_pause_time
= 0;
2483 return (irmp_ir_detected
);
2488 /*---------------------------------------------------------------------------------------------------------------------------------------------------
2489 * main functions - for Unix/Linux + Windows only!
2493 * Compile it under linux with:
2496 * usage: ./irmp [-v|-s|-a|-l|-p] < file
2502 * -l list pulse/pauses
2504 *---------------------------------------------------------------------------------------------------------------------------------------------------
2508 print_timings (void)
2510 printf ("IRMP_TIMEOUT_LEN: %d\n", IRMP_TIMEOUT_LEN
);
2511 printf ("IRMP_KEY_REPETITION_LEN %d\n", IRMP_KEY_REPETITION_LEN
);
2513 printf ("PROTOCOL S S-PULSE S-PAUSE PULSE-0 PAUSE-0 PULSE-1 PAUSE-1\n");
2514 printf ("====================================================================================\n");
2515 printf ("SIRCS 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2516 SIRCS_START_BIT_PULSE_LEN_MIN
, SIRCS_START_BIT_PULSE_LEN_MAX
, SIRCS_START_BIT_PAUSE_LEN_MIN
, SIRCS_START_BIT_PAUSE_LEN_MAX
,
2517 SIRCS_0_PULSE_LEN_MIN
, SIRCS_0_PULSE_LEN_MAX
, SIRCS_PAUSE_LEN_MIN
, SIRCS_PAUSE_LEN_MAX
,
2518 SIRCS_1_PULSE_LEN_MIN
, SIRCS_1_PULSE_LEN_MAX
, SIRCS_PAUSE_LEN_MIN
, SIRCS_PAUSE_LEN_MAX
);
2520 printf ("NEC 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2521 NEC_START_BIT_PULSE_LEN_MIN
, NEC_START_BIT_PULSE_LEN_MAX
, NEC_START_BIT_PAUSE_LEN_MIN
, NEC_START_BIT_PAUSE_LEN_MAX
,
2522 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_0_PAUSE_LEN_MIN
, NEC_0_PAUSE_LEN_MAX
,
2523 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_1_PAUSE_LEN_MIN
, NEC_1_PAUSE_LEN_MAX
);
2525 printf ("NEC (rep) 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2526 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
,
2527 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_0_PAUSE_LEN_MIN
, NEC_0_PAUSE_LEN_MAX
,
2528 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_1_PAUSE_LEN_MIN
, NEC_1_PAUSE_LEN_MAX
);
2530 printf ("SAMSUNG 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2531 SAMSUNG_START_BIT_PULSE_LEN_MIN
, SAMSUNG_START_BIT_PULSE_LEN_MAX
, SAMSUNG_START_BIT_PAUSE_LEN_MIN
, SAMSUNG_START_BIT_PAUSE_LEN_MAX
,
2532 SAMSUNG_PULSE_LEN_MIN
, SAMSUNG_PULSE_LEN_MAX
, SAMSUNG_0_PAUSE_LEN_MIN
, SAMSUNG_0_PAUSE_LEN_MAX
,
2533 SAMSUNG_PULSE_LEN_MIN
, SAMSUNG_PULSE_LEN_MAX
, SAMSUNG_1_PAUSE_LEN_MIN
, SAMSUNG_1_PAUSE_LEN_MAX
);
2535 printf ("MATSUSHITA 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2536 MATSUSHITA_START_BIT_PULSE_LEN_MIN
, MATSUSHITA_START_BIT_PULSE_LEN_MAX
, MATSUSHITA_START_BIT_PAUSE_LEN_MIN
, MATSUSHITA_START_BIT_PAUSE_LEN_MAX
,
2537 MATSUSHITA_PULSE_LEN_MIN
, MATSUSHITA_PULSE_LEN_MAX
, MATSUSHITA_0_PAUSE_LEN_MIN
, MATSUSHITA_0_PAUSE_LEN_MAX
,
2538 MATSUSHITA_PULSE_LEN_MIN
, MATSUSHITA_PULSE_LEN_MAX
, MATSUSHITA_1_PAUSE_LEN_MIN
, MATSUSHITA_1_PAUSE_LEN_MAX
);
2540 printf ("KASEIKYO 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2541 KASEIKYO_START_BIT_PULSE_LEN_MIN
, KASEIKYO_START_BIT_PULSE_LEN_MAX
, KASEIKYO_START_BIT_PAUSE_LEN_MIN
, KASEIKYO_START_BIT_PAUSE_LEN_MAX
,
2542 KASEIKYO_PULSE_LEN_MIN
, KASEIKYO_PULSE_LEN_MAX
, KASEIKYO_0_PAUSE_LEN_MIN
, KASEIKYO_0_PAUSE_LEN_MAX
,
2543 KASEIKYO_PULSE_LEN_MIN
, KASEIKYO_PULSE_LEN_MAX
, KASEIKYO_1_PAUSE_LEN_MIN
, KASEIKYO_1_PAUSE_LEN_MAX
);
2545 printf ("RECS80 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2546 RECS80_START_BIT_PULSE_LEN_MIN
, RECS80_START_BIT_PULSE_LEN_MAX
, RECS80_START_BIT_PAUSE_LEN_MIN
, RECS80_START_BIT_PAUSE_LEN_MAX
,
2547 RECS80_PULSE_LEN_MIN
, RECS80_PULSE_LEN_MAX
, RECS80_0_PAUSE_LEN_MIN
, RECS80_0_PAUSE_LEN_MAX
,
2548 RECS80_PULSE_LEN_MIN
, RECS80_PULSE_LEN_MAX
, RECS80_1_PAUSE_LEN_MIN
, RECS80_1_PAUSE_LEN_MAX
);
2550 printf ("RC5 1 %3d - %3d %3d - %3d %3d - %3d\n",
2551 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
, RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
2552 RC5_BIT_LEN_MIN
, RC5_BIT_LEN_MAX
);
2554 printf ("DENON 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2555 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
,
2556 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
, DENON_0_PAUSE_LEN_MIN
, DENON_0_PAUSE_LEN_MAX
,
2557 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
, DENON_1_PAUSE_LEN_MIN
, DENON_1_PAUSE_LEN_MAX
);
2559 printf ("RC6 1 %3d - %3d %3d - %3d %3d - %3d\n",
2560 RC6_START_BIT_PULSE_LEN_MIN
, RC6_START_BIT_PULSE_LEN_MAX
, RC6_START_BIT_PAUSE_LEN_MIN
, RC6_START_BIT_PAUSE_LEN_MAX
,
2561 RC6_BIT_LEN_MIN
, RC6_BIT_LEN_MAX
);
2563 printf ("RECS80EXT 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2564 RECS80EXT_START_BIT_PULSE_LEN_MIN
, RECS80EXT_START_BIT_PULSE_LEN_MAX
, RECS80EXT_START_BIT_PAUSE_LEN_MIN
, RECS80EXT_START_BIT_PAUSE_LEN_MAX
,
2565 RECS80EXT_PULSE_LEN_MIN
, RECS80EXT_PULSE_LEN_MAX
, RECS80EXT_0_PAUSE_LEN_MIN
, RECS80EXT_0_PAUSE_LEN_MAX
,
2566 RECS80EXT_PULSE_LEN_MIN
, RECS80EXT_PULSE_LEN_MAX
, RECS80EXT_1_PAUSE_LEN_MIN
, RECS80EXT_1_PAUSE_LEN_MAX
);
2568 printf ("NUBERT 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2569 NUBERT_START_BIT_PULSE_LEN_MIN
, NUBERT_START_BIT_PULSE_LEN_MAX
, NUBERT_START_BIT_PAUSE_LEN_MIN
, NUBERT_START_BIT_PAUSE_LEN_MAX
,
2570 NUBERT_0_PULSE_LEN_MIN
, NUBERT_0_PULSE_LEN_MAX
, NUBERT_0_PAUSE_LEN_MIN
, NUBERT_0_PAUSE_LEN_MAX
,
2571 NUBERT_1_PULSE_LEN_MIN
, NUBERT_1_PULSE_LEN_MAX
, NUBERT_1_PAUSE_LEN_MIN
, NUBERT_1_PAUSE_LEN_MAX
);
2573 printf ("BANG_OLUFSEN 1 %3d - %3d %3d - %3d\n",
2574 BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX
,
2575 BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX
);
2577 printf ("BANG_OLUFSEN 2 %3d - %3d %3d - %3d\n",
2578 BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX
,
2579 BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX
);
2581 printf ("BANG_OLUFSEN 3 %3d - %3d %3d - %3d\n",
2582 BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX
,
2583 BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX
);
2585 printf ("BANG_OLUFSEN 4 %3d - %3d %3d - %3d\n",
2586 BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX
,
2587 BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX
);
2589 printf ("BANG_OLUFSEN - %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2590 BANG_OLUFSEN_PULSE_LEN_MIN
, BANG_OLUFSEN_PULSE_LEN_MAX
, BANG_OLUFSEN_0_PAUSE_LEN_MIN
, BANG_OLUFSEN_0_PAUSE_LEN_MAX
,
2591 BANG_OLUFSEN_PULSE_LEN_MIN
, BANG_OLUFSEN_PULSE_LEN_MAX
, BANG_OLUFSEN_1_PAUSE_LEN_MIN
, BANG_OLUFSEN_1_PAUSE_LEN_MAX
);
2593 printf ("GRUNDIG/NOKIA 1 %3d - %3d %3d - %3d %3d - %3d\n",
2594 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
,
2595 GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, GRUNDIG_OR_NOKIA_BIT_LEN_MAX
);
2597 printf ("SIEMENS 1 %3d - %3d %3d - %3d %3d - %3d\n",
2598 SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
, SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
,
2599 SIEMENS_BIT_LEN_MIN
, SIEMENS_BIT_LEN_MAX
);
2601 printf ("FDC 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2602 FDC_START_BIT_PULSE_LEN_MIN
, FDC_START_BIT_PULSE_LEN_MAX
, FDC_START_BIT_PAUSE_LEN_MIN
, FDC_START_BIT_PAUSE_LEN_MAX
,
2603 FDC_PULSE_LEN_MIN
, FDC_PULSE_LEN_MAX
, FDC_0_PAUSE_LEN_MIN
, FDC_0_PAUSE_LEN_MAX
,
2604 FDC_PULSE_LEN_MIN
, FDC_PULSE_LEN_MAX
, FDC_1_PAUSE_LEN_MIN
, FDC_1_PAUSE_LEN_MAX
);
2606 printf ("RCCAR 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2607 RCCAR_START_BIT_PULSE_LEN_MIN
, RCCAR_START_BIT_PULSE_LEN_MAX
, RCCAR_START_BIT_PAUSE_LEN_MIN
, RCCAR_START_BIT_PAUSE_LEN_MAX
,
2608 RCCAR_PULSE_LEN_MIN
, RCCAR_PULSE_LEN_MAX
, RCCAR_0_PAUSE_LEN_MIN
, RCCAR_0_PAUSE_LEN_MAX
,
2609 RCCAR_PULSE_LEN_MIN
, RCCAR_PULSE_LEN_MAX
, RCCAR_1_PAUSE_LEN_MIN
, RCCAR_1_PAUSE_LEN_MAX
);
2613 print_spectrum (char * text
, int * buf
, int is_pulse
)
2626 puts ("-------------------------------------------------------------------------------");
2627 printf ("%s:\n", text
);
2629 for (i
= 0; i
< 256; i
++)
2631 if (buf
[i
] > max_value
)
2637 for (i
= 0; i
< 100; i
++)
2642 value
= (buf
[i
] * 60) / max_value
;
2644 for (j
= 0; j
< value
; j
++)
2648 printf (" %d\n", buf
[i
]);
2659 average
= (float) sum
/ (float) counter
;
2670 printf ("avg: %4.1f=%6.1f us, ", average
, (1000000. * average
) / (float) F_INTERRUPTS
);
2671 printf ("min: %2d=%6.1f us, ", min
, (1000000. * min
) / (float) F_INTERRUPTS
);
2672 printf ("max: %2d=%6.1f us, ", max
, (1000000. * max
) / (float) F_INTERRUPTS
);
2674 tolerance
= (max
- average
);
2676 if (average
- min
> tolerance
)
2678 tolerance
= average
- min
;
2681 tolerance
= tolerance
* 100 / average
;
2682 printf ("tol: %4.1f%%\n", tolerance
);
2692 #define STATE_LEFT_SHIFT 0x01
2693 #define STATE_RIGHT_SHIFT 0x02
2694 #define STATE_LEFT_CTRL 0x04
2695 #define STATE_LEFT_ALT 0x08
2696 #define STATE_RIGHT_ALT 0x10
2698 #define KEY_ESCAPE 0x1B // keycode = 0x006e
2699 #define KEY_MENUE 0x80 // keycode = 0x0070
2700 #define KEY_BACK 0x81 // keycode = 0x0071
2701 #define KEY_FORWARD 0x82 // keycode = 0x0072
2702 #define KEY_ADDRESS 0x83 // keycode = 0x0073
2703 #define KEY_WINDOW 0x84 // keycode = 0x0074
2704 #define KEY_1ST_PAGE 0x85 // keycode = 0x0075
2705 #define KEY_STOP 0x86 // keycode = 0x0076
2706 #define KEY_MAIL 0x87 // keycode = 0x0077
2707 #define KEY_FAVORITES 0x88 // keycode = 0x0078
2708 #define KEY_NEW_PAGE 0x89 // keycode = 0x0079
2709 #define KEY_SETUP 0x8A // keycode = 0x007a
2710 #define KEY_FONT 0x8B // keycode = 0x007b
2711 #define KEY_PRINT 0x8C // keycode = 0x007c
2712 #define KEY_ON_OFF 0x8E // keycode = 0x007c
2714 #define KEY_INSERT 0x90 // keycode = 0x004b
2715 #define KEY_DELETE 0x91 // keycode = 0x004c
2716 #define KEY_LEFT 0x92 // keycode = 0x004f
2717 #define KEY_HOME 0x93 // keycode = 0x0050
2718 #define KEY_END 0x94 // keycode = 0x0051
2719 #define KEY_UP 0x95 // keycode = 0x0053
2720 #define KEY_DOWN 0x96 // keycode = 0x0054
2721 #define KEY_PAGE_UP 0x97 // keycode = 0x0055
2722 #define KEY_PAGE_DOWN 0x98 // keycode = 0x0056
2723 #define KEY_RIGHT 0x99 // keycode = 0x0059
2724 #define KEY_MOUSE_1 0x9E // keycode = 0x0400
2725 #define KEY_MOUSE_2 0x9F // keycode = 0x0800
2728 get_fdc_key (uint16_t cmd
)
2730 static uint8_t key_table
[128] =
2732 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2733 0, '^', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'ß', '´', 0, '\b',
2734 '\t','q', 'w', 'e', 'r', 't', 'z', 'u', 'i', 'o', 'p', 'ü', '+', 0, 0, 'a',
2735 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'ö', 'ä', '#', '\r', 0, '<', 'y', 'x',
2736 'c', 'v', 'b', 'n', 'm', ',', '.', '-', 0, 0, 0, 0, 0, ' ', 0, 0,
2738 0, '°', '!', '"', '§', '$', '%', '&', '/', '(', ')', '=', '?', '`', 0, '\b',
2739 '\t','Q', 'W', 'E', 'R', 'T', 'Z', 'U', 'I', 'O', 'P', 'Ü', '*', 0, 0, 'A',
2740 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'Ö', 'Ä', '\'','\r', 0, '>', 'Y', 'X',
2741 'C', 'V', 'B', 'N', 'M', ';', ':', '_', 0, 0, 0, 0, 0, ' ', 0, 0
2743 static uint8_t state
;
2749 case 0x002C: state
|= STATE_LEFT_SHIFT
; break; // pressed left shift
2750 case 0x00AC: state
&= ~STATE_LEFT_SHIFT
; break; // released left shift
2751 case 0x0039: state
|= STATE_RIGHT_SHIFT
; break; // pressed right shift
2752 case 0x00B9: state
&= ~STATE_RIGHT_SHIFT
; break; // released right shift
2753 case 0x003A: state
|= STATE_LEFT_CTRL
; break; // pressed left ctrl
2754 case 0x00BA: state
&= ~STATE_LEFT_CTRL
; break; // released left ctrl
2755 case 0x003C: state
|= STATE_LEFT_ALT
; break; // pressed left alt
2756 case 0x00BC: state
&= ~STATE_LEFT_ALT
; break; // released left alt
2757 case 0x003E: state
|= STATE_RIGHT_ALT
; break; // pressed left alt
2758 case 0x00BE: state
&= ~STATE_RIGHT_ALT
; break; // released left alt
2760 case 0x006e: key
= KEY_ESCAPE
; break;
2761 case 0x004b: key
= KEY_INSERT
; break;
2762 case 0x004c: key
= KEY_DELETE
; break;
2763 case 0x004f: key
= KEY_LEFT
; break;
2764 case 0x0050: key
= KEY_HOME
; break;
2765 case 0x0051: key
= KEY_END
; break;
2766 case 0x0053: key
= KEY_UP
; break;
2767 case 0x0054: key
= KEY_DOWN
; break;
2768 case 0x0055: key
= KEY_PAGE_UP
; break;
2769 case 0x0056: key
= KEY_PAGE_DOWN
; break;
2770 case 0x0059: key
= KEY_RIGHT
; break;
2771 case 0x0400: key
= KEY_MOUSE_1
; break;
2772 case 0x0800: key
= KEY_MOUSE_2
; break;
2776 if (!(cmd
& 0x80)) // pressed key
2778 if (cmd
>= 0x70 && cmd
<= 0x7F) // function keys
2780 key
= cmd
+ 0x10; // 7x -> 8x
2782 else if (cmd
< 64) // key listed in key_table
2784 if (state
& (STATE_LEFT_ALT
| STATE_RIGHT_ALT
))
2788 case 0x0003: key
= '²'; break;
2789 case 0x0008: key
= '{'; break;
2790 case 0x0009: key
= '['; break;
2791 case 0x000A: key
= ']'; break;
2792 case 0x000B: key
= '}'; break;
2793 case 0x000C: key
= '\\'; break;
2794 case 0x001C: key
= '~'; break;
2795 case 0x002D: key
= '|'; break;
2796 case 0x0034: key
= 'µ'; break;
2799 else if (state
& (STATE_LEFT_CTRL
))
2801 if (key_table
[cmd
] >= 'a' && key_table
[cmd
] <= 'z')
2803 key
= key_table
[cmd
] - 'a' + 1;
2807 key
= key_table
[cmd
];
2812 int idx
= cmd
+ ((state
& (STATE_LEFT_SHIFT
| STATE_RIGHT_SHIFT
)) ? 64 : 0);
2816 key
= key_table
[idx
];
2829 main (int argc
, char ** argv
)
2832 int analyze
= FALSE
;
2839 int start_pulses
[256];
2840 int start_pauses
[256];
2844 int first_pulse
= TRUE
;
2845 int first_pause
= TRUE
;
2847 IRMP_DATA irmp_data
;
2851 if (! strcmp (argv
[1], "-v"))
2855 else if (! strcmp (argv
[1], "-l"))
2859 else if (! strcmp (argv
[1], "-a"))
2863 else if (! strcmp (argv
[1], "-s"))
2867 else if (! strcmp (argv
[1], "-p"))
2874 for (i
= 0; i
< 256; i
++)
2876 start_pulses
[i
] = 0;
2877 start_pauses
[i
] = 0;
2884 while ((ch
= getchar ()) != EOF
)
2886 if (ch
== '_' || ch
== '0')
2894 printf ("pause: %d\n", pause
);
2903 start_pauses
[pause
]++;
2905 first_pause
= FALSE
;
2921 else if (ch
== 0xaf || ch
== '-' || ch
== '1')
2927 printf ("pulse: %d ", pulse
);
2936 start_pulses
[pulse
]++;
2938 first_pulse
= FALSE
;
2954 else if (ch
== '\n')
2958 if (list
&& pause
> 0)
2960 printf ("pause: %d\n", pause
);
2966 for (i
= 0; i
< (int) ((8000.0 * F_INTERRUPTS
) / 10000); i
++) // newline: long pause of 800 msec
2978 while ((ch
= getchar()) != '\n' && ch
!= EOF
)
2985 puts ("-------------------------------------------------------------------");
2988 while ((ch
= getchar()) != '\n' && ch
!= EOF
)
2990 if (ch
!= '\r') // ignore CR in DOS/Windows files
3002 if (! analyze
&& ! list
)
3006 if (irmp_get_data (&irmp_data
))
3010 ANALYZE_ONLY_NORMAL_PUTCHAR (' ');
3012 if (irmp_data
.protocol
== IRMP_FDC_PROTOCOL
&& (key
= get_fdc_key (irmp_data
.command
)) != 0)
3014 if ((key
>= 0x20 && key
< 0x7F) || key
>= 0xA0)
3016 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x, key = '%c'\n",
3017 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
, key
, key
);
3019 else if (key
== '\r' || key
== '\t' || key
== KEY_ESCAPE
|| (key
>= 0x80 && key
<= 0x9F)) // function keys
3021 char * p
= (char *) NULL
;
3025 case '\t' : p
= "TAB"; break;
3026 case '\r' : p
= "CR"; break;
3027 case KEY_ESCAPE
: p
= "ESCAPE"; break;
3028 case KEY_MENUE
: p
= "MENUE"; break;
3029 case KEY_BACK
: p
= "BACK"; break;
3030 case KEY_FORWARD
: p
= "FORWARD"; break;
3031 case KEY_ADDRESS
: p
= "ADDRESS"; break;
3032 case KEY_WINDOW
: p
= "WINDOW"; break;
3033 case KEY_1ST_PAGE
: p
= "1ST_PAGE"; break;
3034 case KEY_STOP
: p
= "STOP"; break;
3035 case KEY_MAIL
: p
= "MAIL"; break;
3036 case KEY_FAVORITES
: p
= "FAVORITES"; break;
3037 case KEY_NEW_PAGE
: p
= "NEW_PAGE"; break;
3038 case KEY_SETUP
: p
= "SETUP"; break;
3039 case KEY_FONT
: p
= "FONT"; break;
3040 case KEY_PRINT
: p
= "PRINT"; break;
3041 case KEY_ON_OFF
: p
= "ON_OFF"; break;
3043 case KEY_INSERT
: p
= "INSERT"; break;
3044 case KEY_DELETE
: p
= "DELETE"; break;
3045 case KEY_LEFT
: p
= "LEFT"; break;
3046 case KEY_HOME
: p
= "HOME"; break;
3047 case KEY_END
: p
= "END"; break;
3048 case KEY_UP
: p
= "UP"; break;
3049 case KEY_DOWN
: p
= "DOWN"; break;
3050 case KEY_PAGE_UP
: p
= "PAGE_UP"; break;
3051 case KEY_PAGE_DOWN
: p
= "PAGE_DOWN"; break;
3052 case KEY_RIGHT
: p
= "RIGHT"; break;
3053 case KEY_MOUSE_1
: p
= "KEY_MOUSE_1"; break;
3054 case KEY_MOUSE_2
: p
= "KEY_MOUSE_2"; break;
3055 default : p
= "<UNKNWON>"; break;
3058 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x, key = %s\n",
3059 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
, key
, p
);
3063 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x\n",
3064 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
, key
);
3069 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x\n",
3070 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
);
3078 print_spectrum ("START PULSES", start_pulses
, TRUE
);
3079 print_spectrum ("START PAUSES", start_pauses
, FALSE
);
3080 print_spectrum ("PULSES", pulses
, TRUE
);
3081 print_spectrum ("PAUSES", pauses
, FALSE
);
3082 puts ("-------------------------------------------------------------------------------");