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.64 2010/06/25 09:04:43 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)
408 #define SAMSUNG_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
409 #define SAMSUNG_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
410 #define SAMSUNG_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
411 #define SAMSUNG_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
412 #define SAMSUNG_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
413 #define SAMSUNG_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
414 #define SAMSUNG_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
415 #define SAMSUNG_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
416 #define SAMSUNG_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * SAMSUNG_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
417 #define SAMSUNG_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * SAMSUNG_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
419 #define MATSUSHITA_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
420 #define MATSUSHITA_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
421 #define MATSUSHITA_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
422 #define MATSUSHITA_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
423 #define MATSUSHITA_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
424 #define MATSUSHITA_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_PULSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
425 #define MATSUSHITA_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_1_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
426 #define MATSUSHITA_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_1_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
427 #define MATSUSHITA_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * MATSUSHITA_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
428 #define MATSUSHITA_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * MATSUSHITA_0_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)
430 #define KASEIKYO_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
431 #define KASEIKYO_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
432 #define KASEIKYO_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
433 #define KASEIKYO_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
434 #define KASEIKYO_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_PULSE_TIME * MIN_TOLERANCE_50 + 0.5) - 1)
435 #define KASEIKYO_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_PULSE_TIME * MAX_TOLERANCE_60 + 0.5) + 1)
436 #define KASEIKYO_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MIN_TOLERANCE_50 + 0.5) - 1)
437 #define KASEIKYO_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_1_PAUSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
438 #define KASEIKYO_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * KASEIKYO_0_PAUSE_TIME * MIN_TOLERANCE_50 + 0.5) - 1)
439 #define KASEIKYO_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * KASEIKYO_0_PAUSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
441 #define RECS80_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PULSE_TIME * MIN_TOLERANCE_00 + 0.5) - 1)
442 #define RECS80_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
443 #define RECS80_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
444 #define RECS80_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
445 #define RECS80_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
446 #define RECS80_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
447 #define RECS80_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
448 #define RECS80_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
449 #define RECS80_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
450 #define RECS80_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
452 #define RC5_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
453 #define RC5_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
454 #define RC5_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
455 #define RC5_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
457 #define DENON_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
458 #define DENON_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
459 #define DENON_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
460 #define DENON_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
461 #define DENON_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
462 #define DENON_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
464 #define RC6_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
465 #define RC6_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
466 #define RC6_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
467 #define RC6_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
468 #define RC6_TOGGLE_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_TOGGLE_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
469 #define RC6_TOGGLE_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_TOGGLE_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
470 #define RC6_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
471 #define RC6_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
473 #define RECS80EXT_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PULSE_TIME * MIN_TOLERANCE_00 + 0.5) - 1)
474 #define RECS80EXT_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PULSE_TIME * MAX_TOLERANCE_00 + 0.5) + 1)
475 #define RECS80EXT_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)
476 #define RECS80EXT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)
477 #define RECS80EXT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
478 #define RECS80EXT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
479 #define RECS80EXT_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
480 #define RECS80EXT_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
481 #define RECS80EXT_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RECS80EXT_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
482 #define RECS80EXT_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RECS80EXT_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
484 #define NUBERT_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
485 #define NUBERT_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
486 #define NUBERT_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
487 #define NUBERT_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_START_BIT_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
488 #define NUBERT_1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_1_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
489 #define NUBERT_1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_1_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
490 #define NUBERT_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
491 #define NUBERT_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
492 #define NUBERT_0_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_0_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
493 #define NUBERT_0_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_0_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
494 #define NUBERT_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
495 #define NUBERT_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
497 #define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
498 #define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
499 #define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
500 #define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
501 #define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
502 #define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
503 #define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
504 #define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
505 #define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
506 #define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
507 #define BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
508 #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
509 #define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
510 #define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
511 #define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
512 #define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
513 #define BANG_OLUFSEN_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
514 #define BANG_OLUFSEN_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
515 #define BANG_OLUFSEN_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
516 #define BANG_OLUFSEN_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
517 #define BANG_OLUFSEN_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
518 #define BANG_OLUFSEN_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
519 #define BANG_OLUFSEN_R_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
520 #define BANG_OLUFSEN_R_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
521 #define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
522 #define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
524 #define GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
525 #define GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
526 #define GRUNDIG_OR_NOKIA_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
527 #define GRUNDIG_OR_NOKIA_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
528 #define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) + 1)
529 #define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
531 #define SIEMENS_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) - 1)
532 #define SIEMENS_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) + 1)
533 #define SIEMENS_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) - 1)
534 #define SIEMENS_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) + 1)
536 #define FDC_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
537 #define FDC_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
538 #define FDC_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
539 #define FDC_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
540 #define FDC_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)
541 #define FDC_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MAX_TOLERANCE_50 + 0.5) + 1)
542 #define FDC_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
543 #define FDC_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
545 #define FDC_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1) // could be negative: 255
547 #define FDC_0_PAUSE_LEN_MIN (1) // simply use 1
549 #define FDC_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
551 #define RCCAR_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
552 #define RCCAR_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
553 #define RCCAR_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)
554 #define RCCAR_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)
555 #define RCCAR_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)
556 #define RCCAR_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)
557 #define RCCAR_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
558 #define RCCAR_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
559 #define RCCAR_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)
560 #define RCCAR_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)
562 #define AUTO_FRAME_REPETITION_LEN (uint16_t)(F_INTERRUPTS * AUTO_FRAME_REPETITION_TIME + 0.5) // use uint16_t!
565 #define ANALYZE_PUTCHAR(a) { if (! silent) { putchar (a); } }
566 #define ANALYZE_ONLY_NORMAL_PUTCHAR(a) { if (! silent && !verbose) { putchar (a); } }
567 #define ANALYZE_PRINTF(...) { if (verbose) { printf (__VA_ARGS__); } }
568 #define ANALYZE_NEWLINE() { if (verbose) { putchar ('\n'); } }
570 static int time_counter
;
573 #define ANALYZE_PUTCHAR(a)
574 #define ANALYZE_ONLY_NORMAL_PUTCHAR(a)
575 #define ANALYZE_PRINTF(...)
576 #define ANALYZE_NEWLINE()
579 #if IRMP_LOGGING == 1
581 #include <util/setbaud.h>
585 #define UART0_UBRRH UBRR0H
586 #define UART0_UBRRL UBRR0L
587 #define UART0_UCSRA UCSR0A
588 #define UART0_UCSRB UCSR0B
589 #define UART0_UCSRC UCSR0C
590 #define UART0_UDRE_BIT_VALUE (1<<UDRE0)
591 #define UART0_UCSZ1_BIT_VALUE (1<<UCSZ01)
592 #define UART0_UCSZ0_BIT_VALUE (1<<UCSZ00)
594 #define UART0_URSEL_BIT_VALUE (1<<URSEL0)
596 #define UART0_URSEL_BIT_VALUE (0)
598 #define UART0_TXEN_BIT_VALUE (1<<TXEN0)
599 #define UART0_UDR UDR0
603 #define UART0_UBRRH UBRRH
604 #define UART0_UBRRL UBRRL
605 #define UART0_UCSRA UCSRA
606 #define UART0_UCSRB UCSRB
607 #define UART0_UCSRC UCSRC
608 #define UART0_UDRE_BIT_VALUE (1<<UDRE)
609 #define UART0_UCSZ1_BIT_VALUE (1<<UCSZ1)
610 #define UART0_UCSZ0_BIT_VALUE (1<<UCSZ0)
612 #define UART0_URSEL_BIT_VALUE (1<<URSEL)
614 #define UART0_URSEL_BIT_VALUE (0)
616 #define UART0_TXEN_BIT_VALUE (1<<TXEN)
617 #define UART0_UDR UDR
621 /*---------------------------------------------------------------------------------------------------------------------------------------------------
623 * @details Initializes UART
624 *---------------------------------------------------------------------------------------------------------------------------------------------------
627 irmp_uart_init (void)
629 UART0_UBRRH
= UBRRH_VALUE
; // set baud rate
630 UART0_UBRRL
= UBRRL_VALUE
;
633 UART0_UCSRA
= (1<<U2X
);
638 UART0_UCSRC
= UART0_UCSZ1_BIT_VALUE
| UART0_UCSZ0_BIT_VALUE
| UART0_URSEL_BIT_VALUE
;
639 UART0_UCSRB
|= UART0_TXEN_BIT_VALUE
; // enable UART TX
642 /*---------------------------------------------------------------------------------------------------------------------------------------------------
644 * @details Sends character
645 * @param ch character to be transmitted
646 *---------------------------------------------------------------------------------------------------------------------------------------------------
649 irmp_uart_putc (unsigned char ch
)
651 while (!(UART0_UCSRA
& UART0_UDRE_BIT_VALUE
))
659 /*---------------------------------------------------------------------------------------------------------------------------------------------------
661 *---------------------------------------------------------------------------------------------------------------------------------------------------
664 #define STARTCYCLES 2 // min count of zeros before start of logging
665 #define ENDBITS 1000 // number of sequenced highbits to detect end
666 #define DATALEN 700 // log buffer size
669 irmp_log (uint8_t val
)
671 static uint8_t buf
[DATALEN
]; // logging buffer
672 static uint16_t buf_idx
; // number of written bits
673 static uint8_t startcycles
; // current number of start-zeros
674 static uint16_t cnt
; // counts sequenced highbits - to detect end
676 if (! val
&& (startcycles
< STARTCYCLES
) && !buf_idx
) // prevent that single random zeros init logging
684 if (! val
|| (val
&& buf_idx
!= 0)) // start or continue logging on "0", "1" cannot init logging
686 if (buf_idx
< DATALEN
* 8) // index in range?
690 buf
[(buf_idx
/ 8)] |= (1<<(buf_idx
% 8)); // set bit
694 buf
[(buf_idx
/ 8)] &= ~(1<<(buf_idx
% 8)); // reset bit
701 { // if high received then look at log-stop condition
705 { // if stop condition is true, output on uart
708 for (i
= 0; i
< STARTCYCLES
; i
++)
710 irmp_uart_putc ('0'); // the ignored starting zeros
713 for (i
= 0; i
< (buf_idx
- ENDBITS
+ 20) / 8; i
++) // transform bitset into uart chars
718 for (j
= 0; j
< 8; j
++)
720 irmp_uart_putc ((d
& 1) + '0');
725 irmp_uart_putc ('\n');
738 #define irmp_log(val)
743 uint8_t protocol
; // ir protocol
744 uint8_t pulse_1_len_min
; // minimum length of pulse with bit value 1
745 uint8_t pulse_1_len_max
; // maximum length of pulse with bit value 1
746 uint8_t pause_1_len_min
; // minimum length of pause with bit value 1
747 uint8_t pause_1_len_max
; // maximum length of pause with bit value 1
748 uint8_t pulse_0_len_min
; // minimum length of pulse with bit value 0
749 uint8_t pulse_0_len_max
; // maximum length of pulse with bit value 0
750 uint8_t pause_0_len_min
; // minimum length of pause with bit value 0
751 uint8_t pause_0_len_max
; // maximum length of pause with bit value 0
752 uint8_t address_offset
; // address offset
753 uint8_t address_end
; // end of address
754 uint8_t command_offset
; // command offset
755 uint8_t command_end
; // end of command
756 uint8_t complete_len
; // complete length of frame
757 uint8_t stop_bit
; // flag: frame has stop bit
758 uint8_t lsb_first
; // flag: LSB first
759 uint8_t flags
; // some flags
762 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
764 static PROGMEM IRMP_PARAMETER sircs_param
=
766 IRMP_SIRCS_PROTOCOL
, // protocol: ir protocol
767 SIRCS_1_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
768 SIRCS_1_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
769 SIRCS_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
770 SIRCS_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
771 SIRCS_0_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
772 SIRCS_0_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
773 SIRCS_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
774 SIRCS_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
775 SIRCS_ADDRESS_OFFSET
, // address_offset: address offset
776 SIRCS_ADDRESS_OFFSET
+ SIRCS_ADDRESS_LEN
, // address_end: end of address
777 SIRCS_COMMAND_OFFSET
, // command_offset: command offset
778 SIRCS_COMMAND_OFFSET
+ SIRCS_COMMAND_LEN
, // command_end: end of command
779 SIRCS_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
780 SIRCS_STOP_BIT
, // stop_bit: flag: frame has stop bit
781 SIRCS_LSB
, // lsb_first: flag: LSB first
782 SIRCS_FLAGS
// flags: some flags
787 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
789 static PROGMEM IRMP_PARAMETER nec_param
=
791 IRMP_NEC_PROTOCOL
, // protocol: ir protocol
792 NEC_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
793 NEC_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
794 NEC_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
795 NEC_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
796 NEC_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
797 NEC_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
798 NEC_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
799 NEC_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
800 NEC_ADDRESS_OFFSET
, // address_offset: address offset
801 NEC_ADDRESS_OFFSET
+ NEC_ADDRESS_LEN
, // address_end: end of address
802 NEC_COMMAND_OFFSET
, // command_offset: command offset
803 NEC_COMMAND_OFFSET
+ NEC_COMMAND_LEN
, // command_end: end of command
804 NEC_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
805 NEC_STOP_BIT
, // stop_bit: flag: frame has stop bit
806 NEC_LSB
, // lsb_first: flag: LSB first
807 NEC_FLAGS
// flags: some flags
810 static PROGMEM IRMP_PARAMETER nec_rep_param
=
812 IRMP_NEC_PROTOCOL
, // protocol: ir protocol
813 NEC_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
814 NEC_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
815 NEC_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
816 NEC_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
817 NEC_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
818 NEC_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
819 NEC_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
820 NEC_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
821 0, // address_offset: address offset
822 0, // address_end: end of address
823 0, // command_offset: command offset
824 0, // command_end: end of command
825 0, // complete_len: complete length of frame
826 NEC_STOP_BIT
, // stop_bit: flag: frame has stop bit
827 NEC_LSB
, // lsb_first: flag: LSB first
828 NEC_FLAGS
// flags: some flags
833 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
835 static PROGMEM IRMP_PARAMETER samsung_param
=
837 IRMP_SAMSUNG_PROTOCOL
, // protocol: ir protocol
838 SAMSUNG_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
839 SAMSUNG_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
840 SAMSUNG_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
841 SAMSUNG_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
842 SAMSUNG_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
843 SAMSUNG_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
844 SAMSUNG_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
845 SAMSUNG_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
846 SAMSUNG_ADDRESS_OFFSET
, // address_offset: address offset
847 SAMSUNG_ADDRESS_OFFSET
+ SAMSUNG_ADDRESS_LEN
, // address_end: end of address
848 SAMSUNG_COMMAND_OFFSET
, // command_offset: command offset
849 SAMSUNG_COMMAND_OFFSET
+ SAMSUNG_COMMAND_LEN
, // command_end: end of command
850 SAMSUNG_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
851 SAMSUNG_STOP_BIT
, // stop_bit: flag: frame has stop bit
852 SAMSUNG_LSB
, // lsb_first: flag: LSB first
853 SAMSUNG_FLAGS
// flags: some flags
858 #if IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
860 static PROGMEM IRMP_PARAMETER matsushita_param
=
862 IRMP_MATSUSHITA_PROTOCOL
, // protocol: ir protocol
863 MATSUSHITA_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
864 MATSUSHITA_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
865 MATSUSHITA_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
866 MATSUSHITA_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
867 MATSUSHITA_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
868 MATSUSHITA_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
869 MATSUSHITA_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
870 MATSUSHITA_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
871 MATSUSHITA_ADDRESS_OFFSET
, // address_offset: address offset
872 MATSUSHITA_ADDRESS_OFFSET
+ MATSUSHITA_ADDRESS_LEN
, // address_end: end of address
873 MATSUSHITA_COMMAND_OFFSET
, // command_offset: command offset
874 MATSUSHITA_COMMAND_OFFSET
+ MATSUSHITA_COMMAND_LEN
, // command_end: end of command
875 MATSUSHITA_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
876 MATSUSHITA_STOP_BIT
, // stop_bit: flag: frame has stop bit
877 MATSUSHITA_LSB
, // lsb_first: flag: LSB first
878 MATSUSHITA_FLAGS
// flags: some flags
883 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
885 static PROGMEM IRMP_PARAMETER kaseikyo_param
=
887 IRMP_KASEIKYO_PROTOCOL
, // protocol: ir protocol
888 KASEIKYO_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
889 KASEIKYO_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
890 KASEIKYO_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
891 KASEIKYO_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
892 KASEIKYO_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
893 KASEIKYO_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
894 KASEIKYO_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
895 KASEIKYO_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
896 KASEIKYO_ADDRESS_OFFSET
, // address_offset: address offset
897 KASEIKYO_ADDRESS_OFFSET
+ KASEIKYO_ADDRESS_LEN
, // address_end: end of address
898 KASEIKYO_COMMAND_OFFSET
, // command_offset: command offset
899 KASEIKYO_COMMAND_OFFSET
+ KASEIKYO_COMMAND_LEN
, // command_end: end of command
900 KASEIKYO_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
901 KASEIKYO_STOP_BIT
, // stop_bit: flag: frame has stop bit
902 KASEIKYO_LSB
, // lsb_first: flag: LSB first
903 KASEIKYO_FLAGS
// flags: some flags
908 #if IRMP_SUPPORT_RECS80_PROTOCOL == 1
910 static PROGMEM IRMP_PARAMETER recs80_param
=
912 IRMP_RECS80_PROTOCOL
, // protocol: ir protocol
913 RECS80_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
914 RECS80_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
915 RECS80_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
916 RECS80_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
917 RECS80_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
918 RECS80_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
919 RECS80_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
920 RECS80_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
921 RECS80_ADDRESS_OFFSET
, // address_offset: address offset
922 RECS80_ADDRESS_OFFSET
+ RECS80_ADDRESS_LEN
, // address_end: end of address
923 RECS80_COMMAND_OFFSET
, // command_offset: command offset
924 RECS80_COMMAND_OFFSET
+ RECS80_COMMAND_LEN
, // command_end: end of command
925 RECS80_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
926 RECS80_STOP_BIT
, // stop_bit: flag: frame has stop bit
927 RECS80_LSB
, // lsb_first: flag: LSB first
928 RECS80_FLAGS
// flags: some flags
933 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
935 static PROGMEM IRMP_PARAMETER rc5_param
=
937 IRMP_RC5_PROTOCOL
, // protocol: ir protocol
938 RC5_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
939 RC5_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
940 RC5_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
941 RC5_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
942 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
943 1, // pulse_0_len_max: maximum length of pulse with bit value 0
944 1, // pause_0_len_min: minimum length of pause with bit value 0
945 1, // pause_0_len_max: maximum length of pause with bit value 0
946 RC5_ADDRESS_OFFSET
, // address_offset: address offset
947 RC5_ADDRESS_OFFSET
+ RC5_ADDRESS_LEN
, // address_end: end of address
948 RC5_COMMAND_OFFSET
, // command_offset: command offset
949 RC5_COMMAND_OFFSET
+ RC5_COMMAND_LEN
, // command_end: end of command
950 RC5_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
951 RC5_STOP_BIT
, // stop_bit: flag: frame has stop bit
952 RC5_LSB
, // lsb_first: flag: LSB first
953 RC5_FLAGS
// flags: some flags
958 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
960 static PROGMEM IRMP_PARAMETER denon_param
=
962 IRMP_DENON_PROTOCOL
, // protocol: ir protocol
963 DENON_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
964 DENON_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
965 DENON_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
966 DENON_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
967 DENON_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
968 DENON_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
969 DENON_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
970 DENON_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
971 DENON_ADDRESS_OFFSET
, // address_offset: address offset
972 DENON_ADDRESS_OFFSET
+ DENON_ADDRESS_LEN
, // address_end: end of address
973 DENON_COMMAND_OFFSET
, // command_offset: command offset
974 DENON_COMMAND_OFFSET
+ DENON_COMMAND_LEN
, // command_end: end of command
975 DENON_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
976 DENON_STOP_BIT
, // stop_bit: flag: frame has stop bit
977 DENON_LSB
, // lsb_first: flag: LSB first
978 DENON_FLAGS
// flags: some flags
983 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
985 static PROGMEM IRMP_PARAMETER rc6_param
=
987 IRMP_RC6_PROTOCOL
, // protocol: ir protocol
988 RC6_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
989 RC6_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
990 RC6_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
991 RC6_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
992 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
993 1, // pulse_0_len_max: maximum length of pulse with bit value 0
994 1, // pause_0_len_min: minimum length of pause with bit value 0
995 1, // pause_0_len_max: maximum length of pause with bit value 0
996 RC6_ADDRESS_OFFSET
, // address_offset: address offset
997 RC6_ADDRESS_OFFSET
+ RC6_ADDRESS_LEN
, // address_end: end of address
998 RC6_COMMAND_OFFSET
, // command_offset: command offset
999 RC6_COMMAND_OFFSET
+ RC6_COMMAND_LEN
, // command_end: end of command
1000 RC6_COMPLETE_DATA_LEN_SHORT
, // complete_len: complete length of frame
1001 RC6_STOP_BIT
, // stop_bit: flag: frame has stop bit
1002 RC6_LSB
, // lsb_first: flag: LSB first
1003 RC6_FLAGS
// flags: some flags
1008 #if IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
1010 static PROGMEM IRMP_PARAMETER recs80ext_param
=
1012 IRMP_RECS80EXT_PROTOCOL
, // protocol: ir protocol
1013 RECS80EXT_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1014 RECS80EXT_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1015 RECS80EXT_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1016 RECS80EXT_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1017 RECS80EXT_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1018 RECS80EXT_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1019 RECS80EXT_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1020 RECS80EXT_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1021 RECS80EXT_ADDRESS_OFFSET
, // address_offset: address offset
1022 RECS80EXT_ADDRESS_OFFSET
+ RECS80EXT_ADDRESS_LEN
, // address_end: end of address
1023 RECS80EXT_COMMAND_OFFSET
, // command_offset: command offset
1024 RECS80EXT_COMMAND_OFFSET
+ RECS80EXT_COMMAND_LEN
, // command_end: end of command
1025 RECS80EXT_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1026 RECS80EXT_STOP_BIT
, // stop_bit: flag: frame has stop bit
1027 RECS80EXT_LSB
, // lsb_first: flag: LSB first
1028 RECS80EXT_FLAGS
// flags: some flags
1033 #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
1035 static PROGMEM IRMP_PARAMETER nubert_param
=
1037 IRMP_NUBERT_PROTOCOL
, // protocol: ir protocol
1038 NUBERT_1_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1039 NUBERT_1_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1040 NUBERT_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1041 NUBERT_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1042 NUBERT_0_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1043 NUBERT_0_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1044 NUBERT_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1045 NUBERT_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1046 NUBERT_ADDRESS_OFFSET
, // address_offset: address offset
1047 NUBERT_ADDRESS_OFFSET
+ NUBERT_ADDRESS_LEN
, // address_end: end of address
1048 NUBERT_COMMAND_OFFSET
, // command_offset: command offset
1049 NUBERT_COMMAND_OFFSET
+ NUBERT_COMMAND_LEN
, // command_end: end of command
1050 NUBERT_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1051 NUBERT_STOP_BIT
, // stop_bit: flag: frame has stop bit
1052 NUBERT_LSB
, // lsb_first: flag: LSB first
1053 NUBERT_FLAGS
// flags: some flags
1058 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1060 static PROGMEM IRMP_PARAMETER bang_olufsen_param
=
1062 IRMP_BANG_OLUFSEN_PROTOCOL
, // protocol: ir protocol
1063 BANG_OLUFSEN_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1064 BANG_OLUFSEN_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1065 BANG_OLUFSEN_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1066 BANG_OLUFSEN_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1067 BANG_OLUFSEN_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1068 BANG_OLUFSEN_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1069 BANG_OLUFSEN_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1070 BANG_OLUFSEN_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1071 BANG_OLUFSEN_ADDRESS_OFFSET
, // address_offset: address offset
1072 BANG_OLUFSEN_ADDRESS_OFFSET
+ BANG_OLUFSEN_ADDRESS_LEN
, // address_end: end of address
1073 BANG_OLUFSEN_COMMAND_OFFSET
, // command_offset: command offset
1074 BANG_OLUFSEN_COMMAND_OFFSET
+ BANG_OLUFSEN_COMMAND_LEN
, // command_end: end of command
1075 BANG_OLUFSEN_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1076 BANG_OLUFSEN_STOP_BIT
, // stop_bit: flag: frame has stop bit
1077 BANG_OLUFSEN_LSB
, // lsb_first: flag: LSB first
1078 BANG_OLUFSEN_FLAGS
// flags: some flags
1083 #if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1085 static PROGMEM IRMP_PARAMETER grundig_param
=
1087 IRMP_GRUNDIG_PROTOCOL
, // protocol: ir protocol
1088 GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1089 GRUNDIG_OR_NOKIA_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1090 GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1091 GRUNDIG_OR_NOKIA_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1092 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1093 1, // pulse_0_len_max: maximum length of pulse with bit value 0
1094 1, // pause_0_len_min: minimum length of pause with bit value 0
1095 1, // pause_0_len_max: maximum length of pause with bit value 0
1096 GRUNDIG_ADDRESS_OFFSET
, // address_offset: address offset
1097 GRUNDIG_ADDRESS_OFFSET
+ GRUNDIG_ADDRESS_LEN
, // address_end: end of address
1098 GRUNDIG_COMMAND_OFFSET
, // command_offset: command offset
1099 GRUNDIG_COMMAND_OFFSET
+ GRUNDIG_COMMAND_LEN
+ 1, // command_end: end of command (USE 1 bit MORE to STORE NOKIA DATA!)
1100 NOKIA_COMPLETE_DATA_LEN
, // complete_len: complete length of frame, here: NOKIA instead of GRUNDIG!
1101 GRUNDIG_OR_NOKIA_STOP_BIT
, // stop_bit: flag: frame has stop bit
1102 GRUNDIG_OR_NOKIA_LSB
, // lsb_first: flag: LSB first
1103 GRUNDIG_OR_NOKIA_FLAGS
// flags: some flags
1108 #if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
1110 static PROGMEM IRMP_PARAMETER siemens_param
=
1112 IRMP_SIEMENS_PROTOCOL
, // protocol: ir protocol
1113 SIEMENS_BIT_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1114 SIEMENS_BIT_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1115 SIEMENS_BIT_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1116 SIEMENS_BIT_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1117 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0
1118 1, // pulse_0_len_max: maximum length of pulse with bit value 0
1119 1, // pause_0_len_min: minimum length of pause with bit value 0
1120 1, // pause_0_len_max: maximum length of pause with bit value 0
1121 SIEMENS_ADDRESS_OFFSET
, // address_offset: address offset
1122 SIEMENS_ADDRESS_OFFSET
+ SIEMENS_ADDRESS_LEN
, // address_end: end of address
1123 SIEMENS_COMMAND_OFFSET
, // command_offset: command offset
1124 SIEMENS_COMMAND_OFFSET
+ SIEMENS_COMMAND_LEN
, // command_end: end of command
1125 SIEMENS_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1126 SIEMENS_STOP_BIT
, // stop_bit: flag: frame has stop bit
1127 SIEMENS_LSB
, // lsb_first: flag: LSB first
1128 SIEMENS_FLAGS
// flags: some flags
1133 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
1135 static PROGMEM IRMP_PARAMETER fdc_param
=
1137 IRMP_FDC_PROTOCOL
, // protocol: ir protocol
1138 FDC_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1139 FDC_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1140 FDC_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1141 FDC_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1142 FDC_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1143 FDC_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1144 FDC_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1145 FDC_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1146 FDC_ADDRESS_OFFSET
, // address_offset: address offset
1147 FDC_ADDRESS_OFFSET
+ FDC_ADDRESS_LEN
, // address_end: end of address
1148 FDC_COMMAND_OFFSET
, // command_offset: command offset
1149 FDC_COMMAND_OFFSET
+ FDC_COMMAND_LEN
, // command_end: end of command
1150 FDC_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1151 FDC_STOP_BIT
, // stop_bit: flag: frame has stop bit
1152 FDC_LSB
, // lsb_first: flag: LSB first
1153 FDC_FLAGS
// flags: some flags
1158 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1160 static PROGMEM IRMP_PARAMETER rccar_param
=
1162 IRMP_RCCAR_PROTOCOL
, // protocol: ir protocol
1163 RCCAR_PULSE_LEN_MIN
, // pulse_1_len_min: minimum length of pulse with bit value 1
1164 RCCAR_PULSE_LEN_MAX
, // pulse_1_len_max: maximum length of pulse with bit value 1
1165 RCCAR_1_PAUSE_LEN_MIN
, // pause_1_len_min: minimum length of pause with bit value 1
1166 RCCAR_1_PAUSE_LEN_MAX
, // pause_1_len_max: maximum length of pause with bit value 1
1167 RCCAR_PULSE_LEN_MIN
, // pulse_0_len_min: minimum length of pulse with bit value 0
1168 RCCAR_PULSE_LEN_MAX
, // pulse_0_len_max: maximum length of pulse with bit value 0
1169 RCCAR_0_PAUSE_LEN_MIN
, // pause_0_len_min: minimum length of pause with bit value 0
1170 RCCAR_0_PAUSE_LEN_MAX
, // pause_0_len_max: maximum length of pause with bit value 0
1171 RCCAR_ADDRESS_OFFSET
, // address_offset: address offset
1172 RCCAR_ADDRESS_OFFSET
+ RCCAR_ADDRESS_LEN
, // address_end: end of address
1173 RCCAR_COMMAND_OFFSET
, // command_offset: command offset
1174 RCCAR_COMMAND_OFFSET
+ RCCAR_COMMAND_LEN
, // command_end: end of command
1175 RCCAR_COMPLETE_DATA_LEN
, // complete_len: complete length of frame
1176 RCCAR_STOP_BIT
, // stop_bit: flag: frame has stop bit
1177 RCCAR_LSB
, // lsb_first: flag: LSB first
1178 RCCAR_FLAGS
// flags: some flags
1183 static uint8_t irmp_bit
; // current bit position
1184 static IRMP_PARAMETER irmp_param
;
1186 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1187 static IRMP_PARAMETER irmp_param2
;
1190 static volatile uint8_t irmp_ir_detected
;
1191 static volatile uint8_t irmp_protocol
;
1192 static volatile uint16_t irmp_address
;
1193 static volatile uint16_t irmp_command
;
1194 static volatile uint16_t irmp_id
; // only used for SAMSUNG protocol
1195 static volatile uint8_t irmp_flags
;
1198 static uint8_t IRMP_PIN
;
1201 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1202 * Initialize IRMP decoder
1203 * @details Configures IRMP input pin
1204 *---------------------------------------------------------------------------------------------------------------------------------------------------
1210 #ifndef PIC_CCS_COMPILER
1211 IRMP_PORT
&= ~(1<<IRMP_BIT
); // deactivate pullup
1212 IRMP_DDR
&= ~(1<<IRMP_BIT
); // set pin to input
1213 #endif // PIC_CCS_COMPILER
1215 #if IRMP_LOGGING == 1
1220 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1222 * @details gets decoded IRMP data
1223 * @param pointer in order to store IRMP data
1224 * @return TRUE: successful, FALSE: failed
1225 *---------------------------------------------------------------------------------------------------------------------------------------------------
1228 irmp_get_data (IRMP_DATA
* irmp_data_p
)
1230 uint8_t rtc
= FALSE
;
1232 if (irmp_ir_detected
)
1234 switch (irmp_protocol
)
1236 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1237 case IRMP_SAMSUNG_PROTOCOL
:
1238 if ((irmp_command
>> 8) == (~irmp_command
& 0x00FF))
1240 irmp_command
&= 0xff;
1241 irmp_command
|= irmp_id
<< 8;
1246 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
1247 case IRMP_NEC_PROTOCOL
:
1248 if ((irmp_command
>> 8) == (~irmp_command
& 0x00FF))
1250 irmp_command
&= 0xff;
1253 else if ((irmp_command
& 0xFF00) == 0xD100)
1255 ANALYZE_PRINTF ("Switching to APPLE protocol\n");
1256 irmp_protocol
= IRMP_APPLE_PROTOCOL
;
1257 irmp_command
&= 0xff;
1262 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1263 case IRMP_RCCAR_PROTOCOL
:
1264 // frame in irmp_data:
1265 // Bit 12 11 10 9 8 7 6 5 4 3 2 1 0
1266 // V D7 D6 D5 D4 D3 D2 D1 D0 A1 A0 C1 C0 // 10 9 8 7 6 5 4 3 2 1 0
1267 irmp_address
= (irmp_command
& 0x000C) >> 2; // addr: 0 0 0 0 0 0 0 0 0 A1 A0
1268 irmp_command
= ((irmp_command
& 0x1000) >> 2) | // V-Bit: V 0 0 0 0 0 0 0 0 0 0
1269 ((irmp_command
& 0x0003) << 8) | // C-Bits: 0 C1 C0 0 0 0 0 0 0 0 0
1270 ((irmp_command
& 0x0FF0) >> 4); // D-Bits: D7 D6 D5 D4 D3 D2 D1 D0
1271 rtc
= TRUE
; // Summe: V C1 C0 D7 D6 D5 D4 D3 D2 D1 D0
1280 irmp_data_p
->protocol
= irmp_protocol
;
1281 irmp_data_p
->address
= irmp_address
;
1282 irmp_data_p
->command
= irmp_command
;
1283 irmp_data_p
->flags
= irmp_flags
;
1289 irmp_ir_detected
= FALSE
;
1295 // these statics must not be volatile, because they are only used by irmp_store_bit(), which is called by irmp_ISR()
1296 static uint16_t irmp_tmp_address
; // ir address
1297 static uint16_t irmp_tmp_command
; // ir command
1299 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1300 static uint16_t irmp_tmp_address2
; // ir address
1301 static uint16_t irmp_tmp_command2
; // ir command
1304 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1305 static uint16_t irmp_tmp_id
; // ir id (only SAMSUNG)
1308 static uint8_t irmp_bit
; // current bit position
1310 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1312 * @details store bit in temp address or temp command
1313 * @param value to store: 0 or 1
1314 *---------------------------------------------------------------------------------------------------------------------------------------------------
1316 // verhindert, dass irmp_store_bit() inline compiliert wird:
1317 // static void irmp_store_bit (uint8_t) __attribute__ ((noinline));
1320 irmp_store_bit (uint8_t value
)
1322 if (irmp_bit
>= irmp_param
.address_offset
&& irmp_bit
< irmp_param
.address_end
)
1324 if (irmp_param
.lsb_first
)
1326 irmp_tmp_address
|= (((uint16_t) (value
)) << (irmp_bit
- irmp_param
.address_offset
)); // CV wants cast
1330 irmp_tmp_address
<<= 1;
1331 irmp_tmp_address
|= value
;
1334 else if (irmp_bit
>= irmp_param
.command_offset
&& irmp_bit
< irmp_param
.command_end
)
1336 if (irmp_param
.lsb_first
)
1338 irmp_tmp_command
|= (((uint16_t) (value
)) << (irmp_bit
- irmp_param
.command_offset
)); // CV wants cast
1342 irmp_tmp_command
<<= 1;
1343 irmp_tmp_command
|= value
;
1346 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1347 else if (irmp_param
.protocol
== IRMP_SAMSUNG_PROTOCOL
&& irmp_bit
>= SAMSUNG_ID_OFFSET
&& irmp_bit
< SAMSUNG_ID_OFFSET
+ SAMSUNG_ID_LEN
)
1349 irmp_tmp_id
|= (((uint16_t) (value
)) << (irmp_bit
- SAMSUNG_ID_OFFSET
)); // store with LSB first
1355 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1357 * @details store bit in temp address or temp command
1358 * @param value to store: 0 or 1
1359 *---------------------------------------------------------------------------------------------------------------------------------------------------
1361 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1363 irmp_store_bit2 (uint8_t value
)
1367 if (irmp_param
.protocol
)
1369 irmp_bit2
= irmp_bit
- 2;
1373 irmp_bit2
= irmp_bit
- 1;
1376 if (irmp_bit2
>= irmp_param2
.address_offset
&& irmp_bit2
< irmp_param2
.address_end
)
1378 irmp_tmp_address2
|= (((uint16_t) (value
)) << (irmp_bit2
- irmp_param2
.address_offset
)); // CV wants cast
1380 else if (irmp_bit2
>= irmp_param2
.command_offset
&& irmp_bit2
< irmp_param2
.command_end
)
1382 irmp_tmp_command2
|= (((uint16_t) (value
)) << (irmp_bit2
- irmp_param2
.command_offset
)); // CV wants cast
1385 #endif // IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1387 /*---------------------------------------------------------------------------------------------------------------------------------------------------
1389 * @details ISR routine, called 10000 times per second
1390 *---------------------------------------------------------------------------------------------------------------------------------------------------
1395 static uint8_t irmp_start_bit_detected
; // flag: start bit detected
1396 static uint8_t wait_for_space
; // flag: wait for data bit space
1397 static uint8_t wait_for_start_space
; // flag: wait for start bit space
1398 static uint8_t irmp_pulse_time
; // count bit time for pulse
1399 static PAUSE_LEN irmp_pause_time
; // count bit time for pause
1400 static uint16_t last_irmp_address
= 0xFFFF; // save last irmp address to recognize key repetition
1401 static uint16_t last_irmp_command
= 0xFFFF; // save last irmp command to recognize key repetition
1402 static uint16_t repetition_counter
; // SIRCS repeats frame 2-5 times with 45 ms pause
1403 static uint8_t repetition_frame_number
;
1404 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
1405 static uint16_t last_irmp_denon_command
; // save last irmp command to recognize DENON frame repetition
1407 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
1408 static uint8_t rc5_cmd_bit6
; // bit 6 of RC5 command is the inverted 2nd start bit
1410 #if IRMP_SUPPORT_MANCHESTER == 1
1411 static PAUSE_LEN last_pause
; // last pause value
1413 #if IRMP_SUPPORT_MANCHESTER == 1 || IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1414 static uint8_t last_value
; // last bit value
1416 uint8_t irmp_input
; // input value
1422 irmp_input
= input(IRMP_PIN
);
1424 irmp_log(irmp_input
); // log ir signal, if IRMP_LOGGING defined
1426 if (! irmp_ir_detected
) // ir code already detected?
1428 if (! irmp_start_bit_detected
) // start bit detected?
1430 if (! irmp_input
) // receiving burst?
1433 if (! irmp_pulse_time
)
1435 ANALYZE_PRINTF("%8d [starting pulse]\n", time_counter
);
1438 irmp_pulse_time
++; // increment counter
1442 if (irmp_pulse_time
) // it's dark....
1443 { // set flags for counting the time of darkness...
1444 irmp_start_bit_detected
= 1;
1445 wait_for_start_space
= 1;
1447 irmp_tmp_command
= 0;
1448 irmp_tmp_address
= 0;
1450 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1451 irmp_tmp_command2
= 0;
1452 irmp_tmp_address2
= 0;
1456 irmp_pause_time
= 1; // 1st pause: set to 1, not to 0!
1457 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
1458 rc5_cmd_bit6
= 0; // fm 2010-03-07: bugfix: reset it after incomplete RC5 frame!
1463 repetition_counter
++;
1469 if (wait_for_start_space
) // we have received start bit...
1470 { // ...and are counting the time of darkness
1471 if (irmp_input
) // still dark?
1473 irmp_pause_time
++; // increment counter
1475 if (irmp_pause_time
> IRMP_TIMEOUT_LEN
) // timeout?
1477 ANALYZE_PRINTF ("error 1: pause after start bit pulse %d too long: %d\n", irmp_pulse_time
, irmp_pause_time
);
1478 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
1479 irmp_start_bit_detected
= 0; // reset flags, let's wait for another start bit
1480 irmp_pulse_time
= 0;
1481 irmp_pause_time
= 0;
1485 { // receiving first data pulse!
1486 IRMP_PARAMETER
* irmp_param_p
= (IRMP_PARAMETER
*) 0;
1488 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1489 irmp_param2
.protocol
= 0;
1492 ANALYZE_PRINTF ("start-bit: pulse = %d, pause = %d\n", irmp_pulse_time
, irmp_pause_time
);
1494 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
1495 if (irmp_pulse_time
>= SIRCS_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= SIRCS_START_BIT_PULSE_LEN_MAX
&&
1496 irmp_pause_time
>= SIRCS_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= SIRCS_START_BIT_PAUSE_LEN_MAX
)
1498 ANALYZE_PRINTF ("protocol = SIRCS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1499 SIRCS_START_BIT_PULSE_LEN_MIN
, SIRCS_START_BIT_PULSE_LEN_MAX
,
1500 SIRCS_START_BIT_PAUSE_LEN_MIN
, SIRCS_START_BIT_PAUSE_LEN_MAX
);
1501 irmp_param_p
= (IRMP_PARAMETER
*) (IRMP_PARAMETER
*) &sircs_param
;
1504 #endif // IRMP_SUPPORT_SIRCS_PROTOCOL == 1
1506 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
1507 if (irmp_pulse_time
>= NEC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= NEC_START_BIT_PULSE_LEN_MAX
&&
1508 irmp_pause_time
>= NEC_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= NEC_START_BIT_PAUSE_LEN_MAX
)
1510 ANALYZE_PRINTF ("protocol = NEC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1511 NEC_START_BIT_PULSE_LEN_MIN
, NEC_START_BIT_PULSE_LEN_MAX
,
1512 NEC_START_BIT_PAUSE_LEN_MIN
, NEC_START_BIT_PAUSE_LEN_MAX
);
1513 irmp_param_p
= (IRMP_PARAMETER
*) &nec_param
;
1515 else if (irmp_pulse_time
>= NEC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= NEC_START_BIT_PULSE_LEN_MAX
&&
1516 irmp_pause_time
>= NEC_REPEAT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= NEC_REPEAT_START_BIT_PAUSE_LEN_MAX
)
1518 ANALYZE_PRINTF ("protocol = NEC (repetition frame), start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1519 NEC_START_BIT_PULSE_LEN_MIN
, NEC_START_BIT_PULSE_LEN_MAX
,
1520 NEC_REPEAT_START_BIT_PAUSE_LEN_MIN
, NEC_REPEAT_START_BIT_PAUSE_LEN_MAX
);
1522 irmp_param_p
= (IRMP_PARAMETER
*) &nec_rep_param
;
1525 #endif // IRMP_SUPPORT_NEC_PROTOCOL == 1
1527 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1528 if (irmp_pulse_time
>= SAMSUNG_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_START_BIT_PULSE_LEN_MAX
&&
1529 irmp_pause_time
>= SAMSUNG_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_START_BIT_PAUSE_LEN_MAX
)
1531 ANALYZE_PRINTF ("protocol = SAMSUNG, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1532 SAMSUNG_START_BIT_PULSE_LEN_MIN
, SAMSUNG_START_BIT_PULSE_LEN_MAX
,
1533 SAMSUNG_START_BIT_PAUSE_LEN_MIN
, SAMSUNG_START_BIT_PAUSE_LEN_MAX
);
1534 irmp_param_p
= (IRMP_PARAMETER
*) &samsung_param
;
1537 #endif // IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
1539 #if IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
1540 if (irmp_pulse_time
>= MATSUSHITA_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= MATSUSHITA_START_BIT_PULSE_LEN_MAX
&&
1541 irmp_pause_time
>= MATSUSHITA_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= MATSUSHITA_START_BIT_PAUSE_LEN_MAX
)
1542 { // it's MATSUSHITA
1543 ANALYZE_PRINTF ("protocol = MATSUSHITA, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1544 MATSUSHITA_START_BIT_PULSE_LEN_MIN
, MATSUSHITA_START_BIT_PULSE_LEN_MAX
,
1545 MATSUSHITA_START_BIT_PAUSE_LEN_MIN
, MATSUSHITA_START_BIT_PAUSE_LEN_MAX
);
1546 irmp_param_p
= (IRMP_PARAMETER
*) &matsushita_param
;
1549 #endif // IRMP_SUPPORT_MATSUSHITA_PROTOCOL == 1
1551 #if IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
1552 if (irmp_pulse_time
>= KASEIKYO_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= KASEIKYO_START_BIT_PULSE_LEN_MAX
&&
1553 irmp_pause_time
>= KASEIKYO_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= KASEIKYO_START_BIT_PAUSE_LEN_MAX
)
1555 ANALYZE_PRINTF ("protocol = KASEIKYO, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1556 KASEIKYO_START_BIT_PULSE_LEN_MIN
, KASEIKYO_START_BIT_PULSE_LEN_MAX
,
1557 KASEIKYO_START_BIT_PAUSE_LEN_MIN
, KASEIKYO_START_BIT_PAUSE_LEN_MAX
);
1558 irmp_param_p
= (IRMP_PARAMETER
*) &kaseikyo_param
;
1561 #endif // IRMP_SUPPORT_KASEIKYO_PROTOCOL == 1
1563 #if IRMP_SUPPORT_RECS80_PROTOCOL == 1
1564 if (irmp_pulse_time
>= RECS80_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RECS80_START_BIT_PULSE_LEN_MAX
&&
1565 irmp_pause_time
>= RECS80_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RECS80_START_BIT_PAUSE_LEN_MAX
)
1567 ANALYZE_PRINTF ("protocol = RECS80, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1568 RECS80_START_BIT_PULSE_LEN_MIN
, RECS80_START_BIT_PULSE_LEN_MAX
,
1569 RECS80_START_BIT_PAUSE_LEN_MIN
, RECS80_START_BIT_PAUSE_LEN_MAX
);
1570 irmp_param_p
= (IRMP_PARAMETER
*) &recs80_param
;
1573 #endif // IRMP_SUPPORT_RECS80_PROTOCOL == 1
1575 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
1576 if (((irmp_pulse_time
>= RC5_START_BIT_LEN_MIN
&& irmp_pulse_time
<= RC5_START_BIT_LEN_MAX
) ||
1577 (irmp_pulse_time
>= 2 * RC5_START_BIT_LEN_MIN
&& irmp_pulse_time
<= 2 * RC5_START_BIT_LEN_MAX
)) &&
1578 ((irmp_pause_time
>= RC5_START_BIT_LEN_MIN
&& irmp_pause_time
<= RC5_START_BIT_LEN_MAX
) ||
1579 (irmp_pause_time
>= 2 * RC5_START_BIT_LEN_MIN
&& irmp_pause_time
<= 2 * RC5_START_BIT_LEN_MAX
)))
1581 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
1582 if (irmp_pulse_time
>= FDC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_START_BIT_PULSE_LEN_MAX
&&
1583 irmp_pause_time
>= FDC_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_START_BIT_PAUSE_LEN_MAX
)
1585 ANALYZE_PRINTF ("protocol = RC5 or FDC\n");
1586 ANALYZE_PRINTF ("FDC start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1587 FDC_START_BIT_PULSE_LEN_MIN
, FDC_START_BIT_PULSE_LEN_MAX
,
1588 FDC_START_BIT_PAUSE_LEN_MIN
, FDC_START_BIT_PAUSE_LEN_MAX
);
1589 ANALYZE_PRINTF ("RC5 start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1590 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
1591 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
);
1592 memcpy_P (&irmp_param2
, &fdc_param
, sizeof (IRMP_PARAMETER
));
1595 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
1596 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1597 if (irmp_pulse_time
>= RCCAR_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_START_BIT_PULSE_LEN_MAX
&&
1598 irmp_pause_time
>= RCCAR_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_START_BIT_PAUSE_LEN_MAX
)
1600 ANALYZE_PRINTF ("protocol = RC5 or RCCAR\n");
1601 ANALYZE_PRINTF ("RCCAR start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1602 RCCAR_START_BIT_PULSE_LEN_MIN
, RCCAR_START_BIT_PULSE_LEN_MAX
,
1603 RCCAR_START_BIT_PAUSE_LEN_MIN
, RCCAR_START_BIT_PAUSE_LEN_MAX
);
1604 ANALYZE_PRINTF ("RC5 start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1605 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
1606 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
);
1607 memcpy_P (&irmp_param2
, &rccar_param
, sizeof (IRMP_PARAMETER
));
1610 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1612 ANALYZE_PRINTF ("protocol = RC5, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1613 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
1614 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
);
1617 irmp_param_p
= (IRMP_PARAMETER
*) &rc5_param
;
1618 last_pause
= irmp_pause_time
;
1620 if ((irmp_pulse_time
> RC5_START_BIT_LEN_MAX
&& irmp_pulse_time
<= 2 * RC5_START_BIT_LEN_MAX
) ||
1621 (irmp_pause_time
> RC5_START_BIT_LEN_MAX
&& irmp_pause_time
<= 2 * RC5_START_BIT_LEN_MAX
))
1624 rc5_cmd_bit6
= 1<<6;
1632 #endif // IRMP_SUPPORT_RC5_PROTOCOL == 1
1634 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
1635 if ( (irmp_pulse_time
>= DENON_PULSE_LEN_MIN
&& irmp_pulse_time
<= DENON_PULSE_LEN_MAX
) &&
1636 ((irmp_pause_time
>= DENON_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_1_PAUSE_LEN_MAX
) ||
1637 (irmp_pause_time
>= DENON_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_0_PAUSE_LEN_MAX
)))
1639 ANALYZE_PRINTF ("protocol = DENON, start bit timings: pulse: %3d - %3d, pause: %3d - %3d or %3d - %3d\n",
1640 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
,
1641 DENON_1_PAUSE_LEN_MIN
, DENON_1_PAUSE_LEN_MAX
,
1642 DENON_0_PAUSE_LEN_MIN
, DENON_0_PAUSE_LEN_MAX
);
1643 irmp_param_p
= (IRMP_PARAMETER
*) &denon_param
;
1646 #endif // IRMP_SUPPORT_DENON_PROTOCOL == 1
1648 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
1649 if (irmp_pulse_time
>= RC6_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RC6_START_BIT_PULSE_LEN_MAX
&&
1650 irmp_pause_time
>= RC6_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RC6_START_BIT_PAUSE_LEN_MAX
)
1652 ANALYZE_PRINTF ("protocol = RC6, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1653 RC6_START_BIT_PULSE_LEN_MIN
, RC6_START_BIT_PULSE_LEN_MAX
,
1654 RC6_START_BIT_PAUSE_LEN_MIN
, RC6_START_BIT_PAUSE_LEN_MAX
);
1655 irmp_param_p
= (IRMP_PARAMETER
*) &rc6_param
;
1660 #endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
1662 #if IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
1663 if (irmp_pulse_time
>= RECS80EXT_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RECS80EXT_START_BIT_PULSE_LEN_MAX
&&
1664 irmp_pause_time
>= RECS80EXT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RECS80EXT_START_BIT_PAUSE_LEN_MAX
)
1666 ANALYZE_PRINTF ("protocol = RECS80EXT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1667 RECS80EXT_START_BIT_PULSE_LEN_MIN
, RECS80EXT_START_BIT_PULSE_LEN_MAX
,
1668 RECS80EXT_START_BIT_PAUSE_LEN_MIN
, RECS80EXT_START_BIT_PAUSE_LEN_MAX
);
1669 irmp_param_p
= (IRMP_PARAMETER
*) &recs80ext_param
;
1672 #endif // IRMP_SUPPORT_RECS80EXT_PROTOCOL == 1
1674 #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
1675 if (irmp_pulse_time
>= NUBERT_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= NUBERT_START_BIT_PULSE_LEN_MAX
&&
1676 irmp_pause_time
>= NUBERT_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= NUBERT_START_BIT_PAUSE_LEN_MAX
)
1678 ANALYZE_PRINTF ("protocol = NUBERT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1679 NUBERT_START_BIT_PULSE_LEN_MIN
, NUBERT_START_BIT_PULSE_LEN_MAX
,
1680 NUBERT_START_BIT_PAUSE_LEN_MIN
, NUBERT_START_BIT_PAUSE_LEN_MAX
);
1681 irmp_param_p
= (IRMP_PARAMETER
*) &nubert_param
;
1684 #endif // IRMP_SUPPORT_NUBERT_PROTOCOL == 1
1686 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1687 if (irmp_pulse_time
>= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN
&& irmp_pulse_time
<= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX
&&
1688 irmp_pause_time
>= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX
)
1689 { // it's BANG_OLUFSEN
1690 ANALYZE_PRINTF ("protocol = BANG_OLUFSEN\n");
1691 ANALYZE_PRINTF ("start bit 1 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1692 BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX
,
1693 BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX
);
1694 ANALYZE_PRINTF ("start bit 2 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1695 BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX
,
1696 BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX
);
1697 ANALYZE_PRINTF ("start bit 3 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1698 BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX
,
1699 BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX
);
1700 ANALYZE_PRINTF ("start bit 4 timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1701 BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX
,
1702 BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX
);
1703 irmp_param_p
= (IRMP_PARAMETER
*) &bang_olufsen_param
;
1707 #endif // IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1709 #if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1710 if (irmp_pulse_time
>= GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN
&& irmp_pulse_time
<= GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX
&&
1711 irmp_pause_time
>= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN
&& irmp_pause_time
<= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX
)
1713 ANALYZE_PRINTF ("protocol = GRUNDIG, pre bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1714 GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN
, GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX
,
1715 GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN
, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX
);
1716 irmp_param_p
= (IRMP_PARAMETER
*) &grundig_param
;
1717 last_pause
= irmp_pause_time
;
1721 #endif // IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1723 #if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
1724 if (((irmp_pulse_time
>= SIEMENS_START_BIT_LEN_MIN
&& irmp_pulse_time
<= SIEMENS_START_BIT_LEN_MAX
) ||
1725 (irmp_pulse_time
>= 2 * SIEMENS_START_BIT_LEN_MIN
&& irmp_pulse_time
<= 2 * SIEMENS_START_BIT_LEN_MAX
)) &&
1726 ((irmp_pause_time
>= SIEMENS_START_BIT_LEN_MIN
&& irmp_pause_time
<= SIEMENS_START_BIT_LEN_MAX
) ||
1727 (irmp_pause_time
>= 2 * SIEMENS_START_BIT_LEN_MIN
&& irmp_pause_time
<= 2 * SIEMENS_START_BIT_LEN_MAX
)))
1729 ANALYZE_PRINTF ("protocol = SIEMENS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1730 SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
,
1731 SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
);
1732 irmp_param_p
= (IRMP_PARAMETER
*) &siemens_param
;
1733 last_pause
= irmp_pause_time
;
1737 #endif // IRMP_SUPPORT_SIEMENS_PROTOCOL == 1
1738 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
1739 if (irmp_pulse_time
>= FDC_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_START_BIT_PULSE_LEN_MAX
&&
1740 irmp_pause_time
>= FDC_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_START_BIT_PAUSE_LEN_MAX
)
1742 ANALYZE_PRINTF ("protocol = FDC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1743 FDC_START_BIT_PULSE_LEN_MIN
, FDC_START_BIT_PULSE_LEN_MAX
,
1744 FDC_START_BIT_PAUSE_LEN_MIN
, FDC_START_BIT_PAUSE_LEN_MAX
);
1745 irmp_param_p
= (IRMP_PARAMETER
*) &fdc_param
;
1748 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
1749 #if IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1750 if (irmp_pulse_time
>= RCCAR_START_BIT_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_START_BIT_PULSE_LEN_MAX
&&
1751 irmp_pause_time
>= RCCAR_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_START_BIT_PAUSE_LEN_MAX
)
1753 ANALYZE_PRINTF ("protocol = RCCAR, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",
1754 RCCAR_START_BIT_PULSE_LEN_MIN
, RCCAR_START_BIT_PULSE_LEN_MAX
,
1755 RCCAR_START_BIT_PAUSE_LEN_MIN
, RCCAR_START_BIT_PAUSE_LEN_MAX
);
1756 irmp_param_p
= (IRMP_PARAMETER
*) &rccar_param
;
1759 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
1761 ANALYZE_PRINTF ("protocol = UNKNOWN\n");
1762 irmp_start_bit_detected
= 0; // wait for another start bit...
1765 if (irmp_start_bit_detected
)
1767 memcpy_P (&irmp_param
, irmp_param_p
, sizeof (IRMP_PARAMETER
));
1770 if (! (irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
))
1772 ANALYZE_PRINTF ("pulse_1: %3d - %3d\n", irmp_param
.pulse_1_len_min
, irmp_param
.pulse_1_len_max
);
1773 ANALYZE_PRINTF ("pause_1: %3d - %3d\n", irmp_param
.pause_1_len_min
, irmp_param
.pause_1_len_max
);
1777 ANALYZE_PRINTF ("pulse: %3d - %3d or %3d - %3d\n", irmp_param
.pulse_1_len_min
, irmp_param
.pulse_1_len_max
,
1778 2 * irmp_param
.pulse_1_len_min
, 2 * irmp_param
.pulse_1_len_max
);
1779 ANALYZE_PRINTF ("pause: %3d - %3d or %3d - %3d\n", irmp_param
.pause_1_len_min
, irmp_param
.pause_1_len_max
,
1780 2 * irmp_param
.pause_1_len_min
, 2 * irmp_param
.pause_1_len_max
);
1783 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
1784 if (irmp_param2
.protocol
)
1786 ANALYZE_PRINTF ("pulse_0: %3d - %3d\n", irmp_param2
.pulse_0_len_min
, irmp_param2
.pulse_0_len_max
);
1787 ANALYZE_PRINTF ("pause_0: %3d - %3d\n", irmp_param2
.pause_0_len_min
, irmp_param2
.pause_0_len_max
);
1788 ANALYZE_PRINTF ("pulse_1: %3d - %3d\n", irmp_param2
.pulse_1_len_min
, irmp_param2
.pulse_1_len_max
);
1789 ANALYZE_PRINTF ("pause_1: %3d - %3d\n", irmp_param2
.pause_1_len_min
, irmp_param2
.pause_1_len_max
);
1794 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
1795 if (irmp_param
.protocol
== IRMP_RC6_PROTOCOL
)
1797 ANALYZE_PRINTF ("pulse_toggle: %3d - %3d\n", RC6_TOGGLE_BIT_LEN_MIN
, RC6_TOGGLE_BIT_LEN_MAX
);
1801 if (! (irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
))
1803 ANALYZE_PRINTF ("pulse_0: %3d - %3d\n", irmp_param
.pulse_0_len_min
, irmp_param
.pulse_0_len_max
);
1804 ANALYZE_PRINTF ("pause_0: %3d - %3d\n", irmp_param
.pause_0_len_min
, irmp_param
.pause_0_len_max
);
1807 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
1808 if (irmp_param
.protocol
== IRMP_BANG_OLUFSEN_PROTOCOL
)
1810 ANALYZE_PRINTF ("pulse_r: %3d - %3d\n", irmp_param
.pulse_0_len_min
, irmp_param
.pulse_0_len_max
);
1811 ANALYZE_PRINTF ("pause_r: %3d - %3d\n", BANG_OLUFSEN_R_PAUSE_LEN_MIN
, BANG_OLUFSEN_R_PAUSE_LEN_MAX
);
1815 ANALYZE_PRINTF ("command_offset: %2d\n", irmp_param
.command_offset
);
1816 ANALYZE_PRINTF ("command_len: %3d\n", irmp_param
.command_end
- irmp_param
.command_offset
);
1817 ANALYZE_PRINTF ("complete_len: %3d\n", irmp_param
.complete_len
);
1818 ANALYZE_PRINTF ("stop_bit: %3d\n", irmp_param
.stop_bit
);
1824 #if IRMP_SUPPORT_MANCHESTER == 1
1825 if ((irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
) && irmp_param
.protocol
!= IRMP_RC6_PROTOCOL
) // Manchester, but not RC6
1827 if (irmp_pause_time
> irmp_param
.pulse_1_len_max
&& irmp_pause_time
<= 2 * irmp_param
.pulse_1_len_max
)
1829 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1830 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '0' : '1');
1832 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 0 : 1);
1834 else if (! last_value
) // && irmp_pause_time >= irmp_param.pause_1_len_min && irmp_pause_time <= irmp_param.pause_1_len_max)
1836 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1838 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '1' : '0');
1840 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0);
1844 #endif // IRMP_SUPPORT_MANCHESTER == 1
1846 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
1847 if (irmp_param
.protocol
== IRMP_DENON_PROTOCOL
)
1849 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1851 if (irmp_pause_time
>= DENON_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= DENON_1_PAUSE_LEN_MAX
)
1852 { // pause timings correct for "1"?
1853 ANALYZE_PUTCHAR ('1'); // yes, store 1
1857 else // if (irmp_pause_time >= DENON_0_PAUSE_LEN_MIN && irmp_pause_time <= DENON_0_PAUSE_LEN_MAX)
1858 { // pause timings correct for "0"?
1859 ANALYZE_PUTCHAR ('0'); // yes, store 0
1865 #endif // IRMP_SUPPORT_DENON_PROTOCOL == 1
1867 ; // else do nothing
1870 irmp_pulse_time
= 1; // set counter to 1, not 0
1871 irmp_pause_time
= 0;
1872 wait_for_start_space
= 0;
1875 else if (wait_for_space
) // the data section....
1876 { // counting the time of darkness....
1877 uint8_t got_light
= FALSE
;
1879 if (irmp_input
) // still dark?
1881 if (irmp_bit
== irmp_param
.complete_len
&& irmp_param
.stop_bit
== 1)
1883 if (irmp_pulse_time
>= irmp_param
.pulse_0_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_0_len_max
)
1886 if (! (irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
))
1888 ANALYZE_PRINTF ("stop bit detected\n");
1891 irmp_param
.stop_bit
= 0;
1895 ANALYZE_PRINTF ("stop bit timing wrong\n");
1897 irmp_start_bit_detected
= 0; // wait for another start bit...
1898 irmp_pulse_time
= 0;
1899 irmp_pause_time
= 0;
1904 irmp_pause_time
++; // increment counter
1906 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
1907 if (irmp_param
.protocol
== IRMP_SIRCS_PROTOCOL
&& // Sony has a variable number of bits:
1908 irmp_pause_time
> SIRCS_PAUSE_LEN_MAX
&& // minimum is 12
1909 irmp_bit
>= 12 - 1) // pause too long?
1910 { // yes, break and close this frame
1911 irmp_param
.complete_len
= irmp_bit
+ 1; // set new complete length
1912 got_light
= TRUE
; // this is a lie, but helps (generates stop bit)
1913 irmp_param
.command_end
= irmp_param
.command_offset
+ irmp_bit
+ 1; // correct command length
1914 irmp_pause_time
= SIRCS_PAUSE_LEN_MAX
- 1; // correct pause length
1918 #if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1
1919 if (irmp_param
.protocol
== IRMP_GRUNDIG_PROTOCOL
&& !irmp_param
.stop_bit
)
1921 if (irmp_pause_time
> 2 * irmp_param
.pause_1_len_max
&& irmp_bit
>= GRUNDIG_COMPLETE_DATA_LEN
- 2)
1922 { // special manchester decoder
1923 irmp_param
.complete_len
= GRUNDIG_COMPLETE_DATA_LEN
; // correct complete len
1924 got_light
= TRUE
; // this is a lie, but generates a stop bit ;-)
1925 irmp_param
.stop_bit
= TRUE
; // set flag
1927 else if (irmp_bit
>= GRUNDIG_COMPLETE_DATA_LEN
)
1929 ANALYZE_PRINTF ("Switching to NOKIA protocol\n");
1930 irmp_param
.protocol
= IRMP_NOKIA_PROTOCOL
; // change protocol
1931 irmp_param
.address_offset
= NOKIA_ADDRESS_OFFSET
;
1932 irmp_param
.address_end
= NOKIA_ADDRESS_OFFSET
+ NOKIA_ADDRESS_LEN
;
1933 irmp_param
.command_offset
= NOKIA_COMMAND_OFFSET
;
1934 irmp_param
.command_end
= NOKIA_COMMAND_OFFSET
+ NOKIA_COMMAND_LEN
;
1936 if (irmp_tmp_command
& 0x300)
1938 irmp_tmp_address
= (irmp_tmp_command
>> 8);
1939 irmp_tmp_command
&= 0xFF;
1945 #if IRMP_SUPPORT_MANCHESTER == 1
1946 if ((irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
) &&
1947 irmp_pause_time
> 2 * irmp_param
.pause_1_len_max
&& irmp_bit
>= irmp_param
.complete_len
- 2 && !irmp_param
.stop_bit
)
1948 { // special manchester decoder
1949 got_light
= TRUE
; // this is a lie, but generates a stop bit ;-)
1950 irmp_param
.stop_bit
= TRUE
; // set flag
1953 #endif // IRMP_SUPPORT_MANCHESTER == 1
1954 if (irmp_pause_time
> IRMP_TIMEOUT_LEN
) // timeout?
1956 if (irmp_bit
== irmp_param
.complete_len
- 1 && irmp_param
.stop_bit
== 0)
1962 ANALYZE_PRINTF ("error 2: pause %d after data bit %d too long\n", irmp_pause_time
, irmp_bit
);
1963 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
1965 irmp_start_bit_detected
= 0; // wait for another start bit...
1966 irmp_pulse_time
= 0;
1967 irmp_pause_time
= 0;
1979 ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter
, irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
1981 #if IRMP_SUPPORT_MANCHESTER == 1
1982 if ((irmp_param
.flags
& IRMP_PARAM_FLAG_IS_MANCHESTER
)) // Manchester
1984 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
1985 if (irmp_param
.protocol
== IRMP_RC6_PROTOCOL
&& irmp_bit
>= 3 && irmp_bit
<= 5) // special bits of RC6
1987 if (irmp_pulse_time
> RC6_TOGGLE_BIT_LEN_MAX
&& irmp_pause_time
> RC6_TOGGLE_BIT_LEN_MAX
)
1989 ANALYZE_PUTCHAR ('1');
1993 ANALYZE_PUTCHAR ('0');
1999 #endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
2000 if (irmp_pulse_time
> irmp_param
.pulse_1_len_max
&& irmp_pulse_time
<= 2 * irmp_param
.pulse_1_len_max
)
2002 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '0' : '1');
2003 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 0 : 1 );
2004 ANALYZE_PUTCHAR ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? '1' : '0');
2005 irmp_store_bit ((irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0 );
2006 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
2007 if (! irmp_param2
.protocol
)
2012 last_value
= (irmp_param
.flags
& IRMP_PARAM_FLAG_1ST_PULSE_IS_1
) ? 1 : 0;
2014 else if (irmp_pulse_time
>= irmp_param
.pulse_1_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_1_len_max
)
2016 uint8_t manchester_value
;
2018 if (last_pause
> irmp_param
.pause_1_len_max
&& last_pause
<= 2 * irmp_param
.pause_1_len_max
)
2020 manchester_value
= last_value
? 0 : 1;
2021 last_value
= manchester_value
;
2025 manchester_value
= last_value
;
2029 #if IRMP_SUPPORT_RC6_PROTOCOL == 1
2030 if (irmp_param
.protocol
== IRMP_RC6_PROTOCOL
&& irmp_bit
== 1 && manchester_value
== 0) // RC6 mode != 0 ???
2032 irmp_param
.complete_len
= RC6_COMPLETE_DATA_LEN_LONG
;
2034 #endif // IRMP_SUPPORT_RC6_PROTOCOL == 1
2037 ANALYZE_PUTCHAR (manchester_value
+ '0');
2038 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && (IRMP_SUPPORT_FDC_PROTOCOL == 1 || IRMP_SUPPORT_RCCAR_PROTOCOL == 1)
2039 if (! irmp_param2
.protocol
)
2044 irmp_store_bit (manchester_value
);
2048 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_FDC_PROTOCOL == 1
2049 if (irmp_param2
.protocol
== IRMP_FDC_PROTOCOL
&&
2050 irmp_pulse_time
>= FDC_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_PULSE_LEN_MAX
&&
2051 ((irmp_pause_time
>= FDC_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_1_PAUSE_LEN_MAX
) ||
2052 (irmp_pause_time
>= FDC_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_0_PAUSE_LEN_MAX
)))
2054 ANALYZE_PUTCHAR ('?');
2055 irmp_param
.protocol
= 0; // switch to FDC, see below
2058 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
2059 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2060 if (irmp_param2
.protocol
== IRMP_RCCAR_PROTOCOL
&&
2061 irmp_pulse_time
>= RCCAR_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_PULSE_LEN_MAX
&&
2062 ((irmp_pause_time
>= RCCAR_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_1_PAUSE_LEN_MAX
) ||
2063 (irmp_pause_time
>= RCCAR_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_0_PAUSE_LEN_MAX
)))
2065 ANALYZE_PUTCHAR ('?');
2066 irmp_param
.protocol
= 0; // switch to RCCAR, see below
2069 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2071 ANALYZE_PUTCHAR ('?');
2073 ANALYZE_PRINTF ("error 3 RC5: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2074 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2075 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2076 irmp_pause_time
= 0;
2080 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_FDC_PROTOCOL == 1
2081 if (irmp_param2
.protocol
== IRMP_FDC_PROTOCOL
&& irmp_pulse_time
>= FDC_PULSE_LEN_MIN
&& irmp_pulse_time
<= FDC_PULSE_LEN_MAX
)
2083 if (irmp_pause_time
>= FDC_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_1_PAUSE_LEN_MAX
)
2085 ANALYZE_PRINTF (" 1 (FDC)\n");
2086 irmp_store_bit2 (1);
2088 else if (irmp_pause_time
>= FDC_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= FDC_0_PAUSE_LEN_MAX
)
2090 ANALYZE_PRINTF (" 0 (FDC)\n");
2091 irmp_store_bit2 (0);
2094 if (! irmp_param
.protocol
)
2096 ANALYZE_PRINTF ("Switching to FDC protocol\n");
2097 memcpy (&irmp_param
, &irmp_param2
, sizeof (IRMP_PARAMETER
));
2098 irmp_param2
.protocol
= 0;
2099 irmp_tmp_address
= irmp_tmp_address2
;
2100 irmp_tmp_command
= irmp_tmp_command2
;
2103 #endif // IRMP_SUPPORT_FDC_PROTOCOL == 1
2104 #if IRMP_SUPPORT_RC5_PROTOCOL == 1 && IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2105 if (irmp_param2
.protocol
== IRMP_RCCAR_PROTOCOL
&& irmp_pulse_time
>= RCCAR_PULSE_LEN_MIN
&& irmp_pulse_time
<= RCCAR_PULSE_LEN_MAX
)
2107 if (irmp_pause_time
>= RCCAR_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_1_PAUSE_LEN_MAX
)
2109 ANALYZE_PRINTF (" 1 (RCCAR)\n");
2110 irmp_store_bit2 (1);
2112 else if (irmp_pause_time
>= RCCAR_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= RCCAR_0_PAUSE_LEN_MAX
)
2114 ANALYZE_PRINTF (" 0 (RCCAR)\n");
2115 irmp_store_bit2 (0);
2118 if (! irmp_param
.protocol
)
2120 ANALYZE_PRINTF ("Switching to RCCAR protocol\n");
2121 memcpy (&irmp_param
, &irmp_param2
, sizeof (IRMP_PARAMETER
));
2122 irmp_param2
.protocol
= 0;
2123 irmp_tmp_address
= irmp_tmp_address2
;
2124 irmp_tmp_command
= irmp_tmp_command2
;
2127 #endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1
2129 last_pause
= irmp_pause_time
;
2133 #endif // IRMP_SUPPORT_MANCHESTER == 1
2136 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
2137 if (irmp_param
.protocol
== IRMP_SAMSUNG_PROTOCOL
&& irmp_bit
== 16) // Samsung: 16th bit
2139 if (irmp_pulse_time
>= SAMSUNG_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_PULSE_LEN_MAX
&&
2140 irmp_pause_time
>= SAMSUNG_START_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_START_BIT_PAUSE_LEN_MAX
)
2142 ANALYZE_PRINTF ("SYNC\n");
2147 else if (irmp_pulse_time
>= SAMSUNG_PULSE_LEN_MIN
&& irmp_pulse_time
<= SAMSUNG_PULSE_LEN_MAX
)
2149 irmp_param
.protocol
= IRMP_SAMSUNG32_PROTOCOL
;
2150 irmp_param
.command_offset
= SAMSUNG32_COMMAND_OFFSET
;
2151 irmp_param
.command_end
= SAMSUNG32_COMMAND_OFFSET
+ SAMSUNG32_COMMAND_LEN
;
2152 irmp_param
.complete_len
= SAMSUNG32_COMPLETE_DATA_LEN
;
2154 if (irmp_pause_time
>= SAMSUNG_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= SAMSUNG_1_PAUSE_LEN_MAX
)
2156 ANALYZE_PUTCHAR ('1');
2163 ANALYZE_PUTCHAR ('0');
2169 ANALYZE_PRINTF ("Switching to SAMSUNG32 protocol\n");
2172 { // timing incorrect!
2173 ANALYZE_PRINTF ("error 3 Samsung: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2174 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2175 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2176 irmp_pause_time
= 0;
2180 #endif // IRMP_SUPPORT_SAMSUNG_PROTOCOL
2182 #if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1
2183 if (irmp_param
.protocol
== IRMP_BANG_OLUFSEN_PROTOCOL
)
2185 if (irmp_pulse_time
>= BANG_OLUFSEN_PULSE_LEN_MIN
&& irmp_pulse_time
<= BANG_OLUFSEN_PULSE_LEN_MAX
)
2187 if (irmp_bit
== 1) // Bang & Olufsen: 3rd bit
2189 if (irmp_pause_time
>= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX
)
2191 ANALYZE_PRINTF ("3rd start bit\n");
2196 { // timing incorrect!
2197 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
);
2198 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2199 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2200 irmp_pause_time
= 0;
2203 else if (irmp_bit
== 19) // Bang & Olufsen: trailer bit
2205 if (irmp_pause_time
>= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX
)
2207 ANALYZE_PRINTF ("trailer bit\n");
2212 { // timing incorrect!
2213 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
);
2214 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2215 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2216 irmp_pause_time
= 0;
2221 if (irmp_pause_time
>= BANG_OLUFSEN_1_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_1_PAUSE_LEN_MAX
)
2222 { // pulse & pause timings correct for "1"?
2223 ANALYZE_PUTCHAR ('1');
2229 else if (irmp_pause_time
>= BANG_OLUFSEN_0_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_0_PAUSE_LEN_MAX
)
2230 { // pulse & pause timings correct for "0"?
2231 ANALYZE_PUTCHAR ('0');
2237 else if (irmp_pause_time
>= BANG_OLUFSEN_R_PAUSE_LEN_MIN
&& irmp_pause_time
<= BANG_OLUFSEN_R_PAUSE_LEN_MAX
)
2239 ANALYZE_PUTCHAR (last_value
+ '0');
2241 irmp_store_bit (last_value
);
2245 { // timing incorrect!
2246 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
);
2247 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2248 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2249 irmp_pause_time
= 0;
2254 { // timing incorrect!
2255 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
);
2256 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2257 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2258 irmp_pause_time
= 0;
2262 #endif // IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL
2264 if (irmp_pulse_time
>= irmp_param
.pulse_1_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_1_len_max
&&
2265 irmp_pause_time
>= irmp_param
.pause_1_len_min
&& irmp_pause_time
<= irmp_param
.pause_1_len_max
)
2266 { // pulse & pause timings correct for "1"?
2267 ANALYZE_PUTCHAR ('1');
2272 else if (irmp_pulse_time
>= irmp_param
.pulse_0_len_min
&& irmp_pulse_time
<= irmp_param
.pulse_0_len_max
&&
2273 irmp_pause_time
>= irmp_param
.pause_0_len_min
&& irmp_pause_time
<= irmp_param
.pause_0_len_max
)
2274 { // pulse & pause timings correct for "0"?
2275 ANALYZE_PUTCHAR ('0');
2281 { // timing incorrect!
2282 ANALYZE_PRINTF ("error 3: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit
, irmp_pulse_time
, irmp_pause_time
);
2283 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2284 irmp_start_bit_detected
= 0; // reset flags and wait for next start bit
2285 irmp_pause_time
= 0;
2288 irmp_pulse_time
= 1; // set counter to 1, not 0
2292 { // counting the pulse length ...
2293 if (! irmp_input
) // still light?
2295 irmp_pulse_time
++; // increment counter
2299 wait_for_space
= 1; // let's count the time (see above)
2300 irmp_pause_time
= 1; // set pause counter to 1, not 0
2304 if (irmp_start_bit_detected
&& irmp_bit
== irmp_param
.complete_len
&& irmp_param
.stop_bit
== 0) // enough bits received?
2306 if (last_irmp_command
== irmp_tmp_command
&& repetition_counter
< AUTO_FRAME_REPETITION_LEN
)
2308 repetition_frame_number
++;
2312 repetition_frame_number
= 0;
2315 #if IRMP_SUPPORT_SIRCS_PROTOCOL == 1
2316 // if SIRCS protocol and the code will be repeated within 50 ms, we will ignore 2nd and 3rd repetition frame
2317 if (irmp_param
.protocol
== IRMP_SIRCS_PROTOCOL
&& (repetition_frame_number
== 1 || repetition_frame_number
== 2))
2319 ANALYZE_PRINTF ("code skipped: SIRCS auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2320 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2321 repetition_counter
= 0;
2326 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
2327 // if SAMSUNG32 protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
2328 if (irmp_param
.protocol
== IRMP_SAMSUNG32_PROTOCOL
&& (repetition_frame_number
& 0x01))
2330 ANALYZE_PRINTF ("code skipped: SAMSUNG32 auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2331 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2332 repetition_counter
= 0;
2337 #if IRMP_SUPPORT_NUBERT_PROTOCOL == 1
2338 // if NUBERT protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame
2339 if (irmp_param
.protocol
== IRMP_NUBERT_PROTOCOL
&& (repetition_frame_number
& 0x01))
2341 ANALYZE_PRINTF ("code skipped: NUBERT auto repetition frame #%d, counter = %d, auto repetition len = %d\n",
2342 repetition_frame_number
+ 1, repetition_counter
, AUTO_FRAME_REPETITION_LEN
);
2343 repetition_counter
= 0;
2349 ANALYZE_PRINTF ("code detected, length = %d\n", irmp_bit
);
2350 irmp_ir_detected
= TRUE
;
2352 #if IRMP_SUPPORT_DENON_PROTOCOL == 1
2353 if (irmp_param
.protocol
== IRMP_DENON_PROTOCOL
)
2354 { // check for repetition frame
2355 if ((~irmp_tmp_command
& 0x3FF) == last_irmp_denon_command
) // command bits must be inverted
2357 irmp_tmp_command
= last_irmp_denon_command
; // use command received before!
2359 irmp_protocol
= irmp_param
.protocol
; // store protocol
2360 irmp_address
= irmp_tmp_address
; // store address
2361 irmp_command
= irmp_tmp_command
; // store command
2365 ANALYZE_PRINTF ("waiting for inverted command repetition\n");
2366 irmp_ir_detected
= FALSE
;
2367 last_irmp_denon_command
= irmp_tmp_command
;
2371 #endif // IRMP_SUPPORT_DENON_PROTOCOL
2373 #if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1
2374 if (irmp_param
.protocol
== IRMP_GRUNDIG_PROTOCOL
&& irmp_tmp_command
== 0x01ff)
2375 { // Grundig start frame?
2376 ANALYZE_PRINTF ("Detected GRUNDIG start frame, ignoring it\n");
2377 irmp_ir_detected
= FALSE
;
2380 #endif // IRMP_SUPPORT_GRUNDIG_PROTOCOL
2382 #if IRMP_SUPPORT_NOKIA_PROTOCOL == 1
2383 if (irmp_param
.protocol
== IRMP_NOKIA_PROTOCOL
&& irmp_tmp_address
== 0x00ff && irmp_tmp_command
== 0x00fe)
2384 { // Nokia start frame?
2385 ANALYZE_PRINTF ("Detected NOKIA start frame, ignoring it\n");
2386 irmp_ir_detected
= FALSE
;
2389 #endif // IRMP_SUPPORT_NOKIA_PROTOCOL
2391 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
2392 if (irmp_param
.protocol
== IRMP_NEC_PROTOCOL
&& irmp_bit
== 0) // repetition frame
2394 irmp_tmp_address
= last_irmp_address
; // address is last address
2395 irmp_tmp_command
= last_irmp_command
; // command is last command
2396 irmp_flags
|= IRMP_FLAG_REPETITION
;
2398 #endif // IRMP_SUPPORT_NEC_PROTOCOL
2399 irmp_protocol
= irmp_param
.protocol
;
2401 #if IRMP_SUPPORT_FDC_PROTOCOL == 1
2402 if (irmp_param
.protocol
== IRMP_FDC_PROTOCOL
)
2404 if (irmp_tmp_command
& 0x000F) // released key?
2406 irmp_tmp_command
= (irmp_tmp_command
>> 4) | 0x80; // yes, set bit 7
2410 irmp_tmp_command
>>= 4; // no, it's a pressed key
2412 irmp_tmp_command
|= (irmp_tmp_address
<< 2) & 0x0F00; // 000000CCCCAAAAAA -> 0000CCCC00000000
2413 irmp_tmp_address
&= 0x003F;
2417 irmp_address
= irmp_tmp_address
; // store address
2418 #if IRMP_SUPPORT_NEC_PROTOCOL == 1
2419 last_irmp_address
= irmp_tmp_address
; // store as last address, too
2422 #if IRMP_SUPPORT_RC5_PROTOCOL == 1
2423 if (irmp_param
.protocol
== IRMP_RC5_PROTOCOL
)
2425 irmp_tmp_command
|= rc5_cmd_bit6
; // store bit 6
2428 irmp_command
= irmp_tmp_command
; // store command
2430 #if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1
2431 irmp_id
= irmp_tmp_id
;
2436 if (irmp_ir_detected
)
2438 if (last_irmp_command
== irmp_command
&&
2439 last_irmp_address
== irmp_address
&&
2440 repetition_counter
< IRMP_KEY_REPETITION_LEN
)
2442 irmp_flags
|= IRMP_FLAG_REPETITION
;
2445 last_irmp_address
= irmp_tmp_address
; // store as last address, too
2446 last_irmp_command
= irmp_tmp_command
; // store as last command, too
2448 repetition_counter
= 0;
2452 ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');
2455 irmp_start_bit_detected
= 0; // and wait for next start bit
2456 irmp_tmp_command
= 0;
2457 irmp_pulse_time
= 0;
2458 irmp_pause_time
= 0;
2462 return (irmp_ir_detected
);
2467 /*---------------------------------------------------------------------------------------------------------------------------------------------------
2468 * main functions - for Unix/Linux + Windows only!
2472 * Compile it under linux with:
2475 * usage: ./irmp [-v|-s|-a|-l|-p] < file
2481 * -l list pulse/pauses
2483 *---------------------------------------------------------------------------------------------------------------------------------------------------
2487 print_timings (void)
2489 printf ("IRMP_TIMEOUT_LEN: %d\n", IRMP_TIMEOUT_LEN
);
2490 printf ("IRMP_KEY_REPETITION_LEN %d\n", IRMP_KEY_REPETITION_LEN
);
2492 printf ("PROTOCOL S S-PULSE S-PAUSE PULSE-0 PAUSE-0 PULSE-1 PAUSE-1\n");
2493 printf ("====================================================================================\n");
2494 printf ("SIRCS 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2495 SIRCS_START_BIT_PULSE_LEN_MIN
, SIRCS_START_BIT_PULSE_LEN_MAX
, SIRCS_START_BIT_PAUSE_LEN_MIN
, SIRCS_START_BIT_PAUSE_LEN_MAX
,
2496 SIRCS_0_PULSE_LEN_MIN
, SIRCS_0_PULSE_LEN_MAX
, SIRCS_PAUSE_LEN_MIN
, SIRCS_PAUSE_LEN_MAX
,
2497 SIRCS_1_PULSE_LEN_MIN
, SIRCS_1_PULSE_LEN_MAX
, SIRCS_PAUSE_LEN_MIN
, SIRCS_PAUSE_LEN_MAX
);
2499 printf ("NEC 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2500 NEC_START_BIT_PULSE_LEN_MIN
, NEC_START_BIT_PULSE_LEN_MAX
, NEC_START_BIT_PAUSE_LEN_MIN
, NEC_START_BIT_PAUSE_LEN_MAX
,
2501 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_0_PAUSE_LEN_MIN
, NEC_0_PAUSE_LEN_MAX
,
2502 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_1_PAUSE_LEN_MIN
, NEC_1_PAUSE_LEN_MAX
);
2504 printf ("NEC (rep) 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2505 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
,
2506 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_0_PAUSE_LEN_MIN
, NEC_0_PAUSE_LEN_MAX
,
2507 NEC_PULSE_LEN_MIN
, NEC_PULSE_LEN_MAX
, NEC_1_PAUSE_LEN_MIN
, NEC_1_PAUSE_LEN_MAX
);
2509 printf ("SAMSUNG 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2510 SAMSUNG_START_BIT_PULSE_LEN_MIN
, SAMSUNG_START_BIT_PULSE_LEN_MAX
, SAMSUNG_START_BIT_PAUSE_LEN_MIN
, SAMSUNG_START_BIT_PAUSE_LEN_MAX
,
2511 SAMSUNG_PULSE_LEN_MIN
, SAMSUNG_PULSE_LEN_MAX
, SAMSUNG_0_PAUSE_LEN_MIN
, SAMSUNG_0_PAUSE_LEN_MAX
,
2512 SAMSUNG_PULSE_LEN_MIN
, SAMSUNG_PULSE_LEN_MAX
, SAMSUNG_1_PAUSE_LEN_MIN
, SAMSUNG_1_PAUSE_LEN_MAX
);
2514 printf ("MATSUSHITA 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2515 MATSUSHITA_START_BIT_PULSE_LEN_MIN
, MATSUSHITA_START_BIT_PULSE_LEN_MAX
, MATSUSHITA_START_BIT_PAUSE_LEN_MIN
, MATSUSHITA_START_BIT_PAUSE_LEN_MAX
,
2516 MATSUSHITA_PULSE_LEN_MIN
, MATSUSHITA_PULSE_LEN_MAX
, MATSUSHITA_0_PAUSE_LEN_MIN
, MATSUSHITA_0_PAUSE_LEN_MAX
,
2517 MATSUSHITA_PULSE_LEN_MIN
, MATSUSHITA_PULSE_LEN_MAX
, MATSUSHITA_1_PAUSE_LEN_MIN
, MATSUSHITA_1_PAUSE_LEN_MAX
);
2519 printf ("KASEIKYO 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2520 KASEIKYO_START_BIT_PULSE_LEN_MIN
, KASEIKYO_START_BIT_PULSE_LEN_MAX
, KASEIKYO_START_BIT_PAUSE_LEN_MIN
, KASEIKYO_START_BIT_PAUSE_LEN_MAX
,
2521 KASEIKYO_PULSE_LEN_MIN
, KASEIKYO_PULSE_LEN_MAX
, KASEIKYO_0_PAUSE_LEN_MIN
, KASEIKYO_0_PAUSE_LEN_MAX
,
2522 KASEIKYO_PULSE_LEN_MIN
, KASEIKYO_PULSE_LEN_MAX
, KASEIKYO_1_PAUSE_LEN_MIN
, KASEIKYO_1_PAUSE_LEN_MAX
);
2524 printf ("RECS80 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2525 RECS80_START_BIT_PULSE_LEN_MIN
, RECS80_START_BIT_PULSE_LEN_MAX
, RECS80_START_BIT_PAUSE_LEN_MIN
, RECS80_START_BIT_PAUSE_LEN_MAX
,
2526 RECS80_PULSE_LEN_MIN
, RECS80_PULSE_LEN_MAX
, RECS80_0_PAUSE_LEN_MIN
, RECS80_0_PAUSE_LEN_MAX
,
2527 RECS80_PULSE_LEN_MIN
, RECS80_PULSE_LEN_MAX
, RECS80_1_PAUSE_LEN_MIN
, RECS80_1_PAUSE_LEN_MAX
);
2529 printf ("RC5 1 %3d - %3d %3d - %3d %3d - %3d\n",
2530 RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
, RC5_START_BIT_LEN_MIN
, RC5_START_BIT_LEN_MAX
,
2531 RC5_BIT_LEN_MIN
, RC5_BIT_LEN_MAX
);
2533 printf ("DENON 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2534 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
,
2535 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
, DENON_0_PAUSE_LEN_MIN
, DENON_0_PAUSE_LEN_MAX
,
2536 DENON_PULSE_LEN_MIN
, DENON_PULSE_LEN_MAX
, DENON_1_PAUSE_LEN_MIN
, DENON_1_PAUSE_LEN_MAX
);
2538 printf ("RC6 1 %3d - %3d %3d - %3d %3d - %3d\n",
2539 RC6_START_BIT_PULSE_LEN_MIN
, RC6_START_BIT_PULSE_LEN_MAX
, RC6_START_BIT_PAUSE_LEN_MIN
, RC6_START_BIT_PAUSE_LEN_MAX
,
2540 RC6_BIT_LEN_MIN
, RC6_BIT_LEN_MAX
);
2542 printf ("RECS80EXT 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2543 RECS80EXT_START_BIT_PULSE_LEN_MIN
, RECS80EXT_START_BIT_PULSE_LEN_MAX
, RECS80EXT_START_BIT_PAUSE_LEN_MIN
, RECS80EXT_START_BIT_PAUSE_LEN_MAX
,
2544 RECS80EXT_PULSE_LEN_MIN
, RECS80EXT_PULSE_LEN_MAX
, RECS80EXT_0_PAUSE_LEN_MIN
, RECS80EXT_0_PAUSE_LEN_MAX
,
2545 RECS80EXT_PULSE_LEN_MIN
, RECS80EXT_PULSE_LEN_MAX
, RECS80EXT_1_PAUSE_LEN_MIN
, RECS80EXT_1_PAUSE_LEN_MAX
);
2547 printf ("NUBERT 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2548 NUBERT_START_BIT_PULSE_LEN_MIN
, NUBERT_START_BIT_PULSE_LEN_MAX
, NUBERT_START_BIT_PAUSE_LEN_MIN
, NUBERT_START_BIT_PAUSE_LEN_MAX
,
2549 NUBERT_0_PULSE_LEN_MIN
, NUBERT_0_PULSE_LEN_MAX
, NUBERT_0_PAUSE_LEN_MIN
, NUBERT_0_PAUSE_LEN_MAX
,
2550 NUBERT_1_PULSE_LEN_MIN
, NUBERT_1_PULSE_LEN_MAX
, NUBERT_1_PAUSE_LEN_MIN
, NUBERT_1_PAUSE_LEN_MAX
);
2552 printf ("BANG_OLUFSEN 1 %3d - %3d %3d - %3d\n",
2553 BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX
,
2554 BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX
);
2556 printf ("BANG_OLUFSEN 2 %3d - %3d %3d - %3d\n",
2557 BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX
,
2558 BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX
);
2560 printf ("BANG_OLUFSEN 3 %3d - %3d %3d - %3d\n",
2561 BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX
,
2562 BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX
);
2564 printf ("BANG_OLUFSEN 4 %3d - %3d %3d - %3d\n",
2565 BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX
,
2566 BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN
, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX
);
2568 printf ("BANG_OLUFSEN - %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2569 BANG_OLUFSEN_PULSE_LEN_MIN
, BANG_OLUFSEN_PULSE_LEN_MAX
, BANG_OLUFSEN_0_PAUSE_LEN_MIN
, BANG_OLUFSEN_0_PAUSE_LEN_MAX
,
2570 BANG_OLUFSEN_PULSE_LEN_MIN
, BANG_OLUFSEN_PULSE_LEN_MAX
, BANG_OLUFSEN_1_PAUSE_LEN_MIN
, BANG_OLUFSEN_1_PAUSE_LEN_MAX
);
2572 printf ("GRUNDIG/NOKIA 1 %3d - %3d %3d - %3d %3d - %3d\n",
2573 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
,
2574 GRUNDIG_OR_NOKIA_BIT_LEN_MIN
, GRUNDIG_OR_NOKIA_BIT_LEN_MAX
);
2576 printf ("SIEMENS 1 %3d - %3d %3d - %3d %3d - %3d\n",
2577 SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
, SIEMENS_START_BIT_LEN_MIN
, SIEMENS_START_BIT_LEN_MAX
,
2578 SIEMENS_BIT_LEN_MIN
, SIEMENS_BIT_LEN_MAX
);
2580 printf ("FDC 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2581 FDC_START_BIT_PULSE_LEN_MIN
, FDC_START_BIT_PULSE_LEN_MAX
, FDC_START_BIT_PAUSE_LEN_MIN
, FDC_START_BIT_PAUSE_LEN_MAX
,
2582 FDC_PULSE_LEN_MIN
, FDC_PULSE_LEN_MAX
, FDC_0_PAUSE_LEN_MIN
, FDC_0_PAUSE_LEN_MAX
,
2583 FDC_PULSE_LEN_MIN
, FDC_PULSE_LEN_MAX
, FDC_1_PAUSE_LEN_MIN
, FDC_1_PAUSE_LEN_MAX
);
2585 printf ("RCCAR 1 %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d %3d - %3d\n",
2586 RCCAR_START_BIT_PULSE_LEN_MIN
, RCCAR_START_BIT_PULSE_LEN_MAX
, RCCAR_START_BIT_PAUSE_LEN_MIN
, RCCAR_START_BIT_PAUSE_LEN_MAX
,
2587 RCCAR_PULSE_LEN_MIN
, RCCAR_PULSE_LEN_MAX
, RCCAR_0_PAUSE_LEN_MIN
, RCCAR_0_PAUSE_LEN_MAX
,
2588 RCCAR_PULSE_LEN_MIN
, RCCAR_PULSE_LEN_MAX
, RCCAR_1_PAUSE_LEN_MIN
, RCCAR_1_PAUSE_LEN_MAX
);
2592 print_spectrum (char * text
, int * buf
, int is_pulse
)
2605 puts ("-------------------------------------------------------------------------------");
2606 printf ("%s:\n", text
);
2608 for (i
= 0; i
< 256; i
++)
2610 if (buf
[i
] > max_value
)
2616 for (i
= 0; i
< 100; i
++)
2621 value
= (buf
[i
] * 60) / max_value
;
2623 for (j
= 0; j
< value
; j
++)
2627 printf (" %d\n", buf
[i
]);
2638 average
= (float) sum
/ (float) counter
;
2649 printf ("avg: %4.1f=%6.1f us, ", average
, (1000000. * average
) / (float) F_INTERRUPTS
);
2650 printf ("min: %2d=%6.1f us, ", min
, (1000000. * min
) / (float) F_INTERRUPTS
);
2651 printf ("max: %2d=%6.1f us, ", max
, (1000000. * max
) / (float) F_INTERRUPTS
);
2653 tolerance
= (max
- average
);
2655 if (average
- min
> tolerance
)
2657 tolerance
= average
- min
;
2660 tolerance
= tolerance
* 100 / average
;
2661 printf ("tol: %4.1f%%\n", tolerance
);
2671 #define STATE_LEFT_SHIFT 0x01
2672 #define STATE_RIGHT_SHIFT 0x02
2673 #define STATE_LEFT_CTRL 0x04
2674 #define STATE_LEFT_ALT 0x08
2675 #define STATE_RIGHT_ALT 0x10
2677 #define KEY_ESCAPE 0x1B // keycode = 0x006e
2678 #define KEY_MENUE 0x80 // keycode = 0x0070
2679 #define KEY_BACK 0x81 // keycode = 0x0071
2680 #define KEY_FORWARD 0x82 // keycode = 0x0072
2681 #define KEY_ADDRESS 0x83 // keycode = 0x0073
2682 #define KEY_WINDOW 0x84 // keycode = 0x0074
2683 #define KEY_1ST_PAGE 0x85 // keycode = 0x0075
2684 #define KEY_STOP 0x86 // keycode = 0x0076
2685 #define KEY_MAIL 0x87 // keycode = 0x0077
2686 #define KEY_FAVORITES 0x88 // keycode = 0x0078
2687 #define KEY_NEW_PAGE 0x89 // keycode = 0x0079
2688 #define KEY_SETUP 0x8A // keycode = 0x007a
2689 #define KEY_FONT 0x8B // keycode = 0x007b
2690 #define KEY_PRINT 0x8C // keycode = 0x007c
2691 #define KEY_ON_OFF 0x8E // keycode = 0x007c
2693 #define KEY_INSERT 0x90 // keycode = 0x004b
2694 #define KEY_DELETE 0x91 // keycode = 0x004c
2695 #define KEY_LEFT 0x92 // keycode = 0x004f
2696 #define KEY_HOME 0x93 // keycode = 0x0050
2697 #define KEY_END 0x94 // keycode = 0x0051
2698 #define KEY_UP 0x95 // keycode = 0x0053
2699 #define KEY_DOWN 0x96 // keycode = 0x0054
2700 #define KEY_PAGE_UP 0x97 // keycode = 0x0055
2701 #define KEY_PAGE_DOWN 0x98 // keycode = 0x0056
2702 #define KEY_RIGHT 0x99 // keycode = 0x0059
2703 #define KEY_MOUSE_1 0x9E // keycode = 0x0400
2704 #define KEY_MOUSE_2 0x9F // keycode = 0x0800
2707 get_fdc_key (uint16_t cmd
)
2709 static uint8_t key_table
[128] =
2711 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2712 0, '^', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'ß', '´', 0, '\b',
2713 '\t','q', 'w', 'e', 'r', 't', 'z', 'u', 'i', 'o', 'p', 'ü', '+', 0, 0, 'a',
2714 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'ö', 'ä', '#', '\r', 0, '<', 'y', 'x',
2715 'c', 'v', 'b', 'n', 'm', ',', '.', '-', 0, 0, 0, 0, 0, ' ', 0, 0,
2717 0, '°', '!', '"', '§', '$', '%', '&', '/', '(', ')', '=', '?', '`', 0, '\b',
2718 '\t','Q', 'W', 'E', 'R', 'T', 'Z', 'U', 'I', 'O', 'P', 'Ü', '*', 0, 0, 'A',
2719 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'Ö', 'Ä', '\'','\r', 0, '>', 'Y', 'X',
2720 'C', 'V', 'B', 'N', 'M', ';', ':', '_', 0, 0, 0, 0, 0, ' ', 0, 0
2722 static uint8_t state
;
2728 case 0x002C: state
|= STATE_LEFT_SHIFT
; break; // pressed left shift
2729 case 0x00AC: state
&= ~STATE_LEFT_SHIFT
; break; // released left shift
2730 case 0x0039: state
|= STATE_RIGHT_SHIFT
; break; // pressed right shift
2731 case 0x00B9: state
&= ~STATE_RIGHT_SHIFT
; break; // released right shift
2732 case 0x003A: state
|= STATE_LEFT_CTRL
; break; // pressed left ctrl
2733 case 0x00BA: state
&= ~STATE_LEFT_CTRL
; break; // released left ctrl
2734 case 0x003C: state
|= STATE_LEFT_ALT
; break; // pressed left alt
2735 case 0x00BC: state
&= ~STATE_LEFT_ALT
; break; // released left alt
2736 case 0x003E: state
|= STATE_RIGHT_ALT
; break; // pressed left alt
2737 case 0x00BE: state
&= ~STATE_RIGHT_ALT
; break; // released left alt
2739 case 0x006e: key
= KEY_ESCAPE
; break;
2740 case 0x004b: key
= KEY_INSERT
; break;
2741 case 0x004c: key
= KEY_DELETE
; break;
2742 case 0x004f: key
= KEY_LEFT
; break;
2743 case 0x0050: key
= KEY_HOME
; break;
2744 case 0x0051: key
= KEY_END
; break;
2745 case 0x0053: key
= KEY_UP
; break;
2746 case 0x0054: key
= KEY_DOWN
; break;
2747 case 0x0055: key
= KEY_PAGE_UP
; break;
2748 case 0x0056: key
= KEY_PAGE_DOWN
; break;
2749 case 0x0059: key
= KEY_RIGHT
; break;
2750 case 0x0400: key
= KEY_MOUSE_1
; break;
2751 case 0x0800: key
= KEY_MOUSE_2
; break;
2755 if (!(cmd
& 0x80)) // pressed key
2757 if (cmd
>= 0x70 && cmd
<= 0x7F) // function keys
2759 key
= cmd
+ 0x10; // 7x -> 8x
2761 else if (cmd
< 64) // key listed in key_table
2763 if (state
& (STATE_LEFT_ALT
| STATE_RIGHT_ALT
))
2767 case 0x0003: key
= '²'; break;
2768 case 0x0008: key
= '{'; break;
2769 case 0x0009: key
= '['; break;
2770 case 0x000A: key
= ']'; break;
2771 case 0x000B: key
= '}'; break;
2772 case 0x000C: key
= '\\'; break;
2773 case 0x001C: key
= '~'; break;
2774 case 0x002D: key
= '|'; break;
2775 case 0x0034: key
= 'µ'; break;
2778 else if (state
& (STATE_LEFT_CTRL
))
2780 if (key_table
[cmd
] >= 'a' && key_table
[cmd
] <= 'z')
2782 key
= key_table
[cmd
] - 'a' + 1;
2786 key
= key_table
[cmd
];
2791 int idx
= cmd
+ ((state
& (STATE_LEFT_SHIFT
| STATE_RIGHT_SHIFT
)) ? 64 : 0);
2795 key
= key_table
[idx
];
2808 main (int argc
, char ** argv
)
2811 int analyze
= FALSE
;
2818 int start_pulses
[256];
2819 int start_pauses
[256];
2823 int first_pulse
= TRUE
;
2824 int first_pause
= TRUE
;
2826 IRMP_DATA irmp_data
;
2830 if (! strcmp (argv
[1], "-v"))
2834 else if (! strcmp (argv
[1], "-l"))
2838 else if (! strcmp (argv
[1], "-a"))
2842 else if (! strcmp (argv
[1], "-s"))
2846 else if (! strcmp (argv
[1], "-p"))
2853 for (i
= 0; i
< 256; i
++)
2855 start_pulses
[i
] = 0;
2856 start_pauses
[i
] = 0;
2863 while ((ch
= getchar ()) != EOF
)
2865 if (ch
== '_' || ch
== '0')
2873 printf ("pause: %d\n", pause
);
2882 start_pauses
[pause
]++;
2884 first_pause
= FALSE
;
2900 else if (ch
== 0xaf || ch
== '-' || ch
== '1')
2906 printf ("pulse: %d ", pulse
);
2915 start_pulses
[pulse
]++;
2917 first_pulse
= FALSE
;
2933 else if (ch
== '\n')
2937 if (list
&& pause
> 0)
2939 printf ("pause: %d\n", pause
);
2945 for (i
= 0; i
< (int) ((8000.0 * F_INTERRUPTS
) / 10000); i
++) // newline: long pause of 800 msec
2957 while ((ch
= getchar()) != '\n' && ch
!= EOF
)
2964 puts ("-------------------------------------------------------------------");
2967 while ((ch
= getchar()) != '\n' && ch
!= EOF
)
2969 if (ch
!= '\r') // ignore CR in DOS/Windows files
2981 if (! analyze
&& ! list
)
2985 if (irmp_get_data (&irmp_data
))
2989 ANALYZE_ONLY_NORMAL_PUTCHAR (' ');
2991 if (irmp_data
.protocol
== IRMP_FDC_PROTOCOL
&& (key
= get_fdc_key (irmp_data
.command
)) != 0)
2993 if ((key
>= 0x20 && key
< 0x7F) || key
>= 0xA0)
2995 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x, key = '%c'\n",
2996 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
, key
, key
);
2998 else if (key
== '\r' || key
== '\t' || key
== KEY_ESCAPE
|| (key
>= 0x80 && key
<= 0x9F)) // function keys
3000 char * p
= (char *) NULL
;
3004 case '\t' : p
= "TAB"; break;
3005 case '\r' : p
= "CR"; break;
3006 case KEY_ESCAPE
: p
= "ESCAPE"; break;
3007 case KEY_MENUE
: p
= "MENUE"; break;
3008 case KEY_BACK
: p
= "BACK"; break;
3009 case KEY_FORWARD
: p
= "FORWARD"; break;
3010 case KEY_ADDRESS
: p
= "ADDRESS"; break;
3011 case KEY_WINDOW
: p
= "WINDOW"; break;
3012 case KEY_1ST_PAGE
: p
= "1ST_PAGE"; break;
3013 case KEY_STOP
: p
= "STOP"; break;
3014 case KEY_MAIL
: p
= "MAIL"; break;
3015 case KEY_FAVORITES
: p
= "FAVORITES"; break;
3016 case KEY_NEW_PAGE
: p
= "NEW_PAGE"; break;
3017 case KEY_SETUP
: p
= "SETUP"; break;
3018 case KEY_FONT
: p
= "FONT"; break;
3019 case KEY_PRINT
: p
= "PRINT"; break;
3020 case KEY_ON_OFF
: p
= "ON_OFF"; break;
3022 case KEY_INSERT
: p
= "INSERT"; break;
3023 case KEY_DELETE
: p
= "DELETE"; break;
3024 case KEY_LEFT
: p
= "LEFT"; break;
3025 case KEY_HOME
: p
= "HOME"; break;
3026 case KEY_END
: p
= "END"; break;
3027 case KEY_UP
: p
= "UP"; break;
3028 case KEY_DOWN
: p
= "DOWN"; break;
3029 case KEY_PAGE_UP
: p
= "PAGE_UP"; break;
3030 case KEY_PAGE_DOWN
: p
= "PAGE_DOWN"; break;
3031 case KEY_RIGHT
: p
= "RIGHT"; break;
3032 case KEY_MOUSE_1
: p
= "KEY_MOUSE_1"; break;
3033 case KEY_MOUSE_2
: p
= "KEY_MOUSE_2"; break;
3034 default : p
= "<UNKNWON>"; break;
3037 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x, key = %s\n",
3038 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
, key
, p
);
3042 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x, asc = 0x%02x\n",
3043 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
, key
);
3048 printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x\n",
3049 irmp_data
.protocol
, irmp_data
.address
, irmp_data
.command
, irmp_data
.flags
);
3057 print_spectrum ("START PULSES", start_pulses
, TRUE
);
3058 print_spectrum ("START PAUSES", start_pauses
, FALSE
);
3059 print_spectrum ("PULSES", pulses
, TRUE
);
3060 print_spectrum ("PAUSES", pauses
, FALSE
);
3061 puts ("-------------------------------------------------------------------------------");