*\r
* Copyright (c) 2009-2010 Frank Meyer - frank(at)fli4l.de\r
*\r
- * $Id: irmp.c,v 1.31 2010/05/26 08:34:30 fm Exp $\r
+ * $Id: irmp.c,v 1.50 2010/06/14 22:00:51 fm Exp $\r
*\r
* ATMEGA88 @ 8 MHz\r
*\r
* PANASONIC - Panasonic (older, yet not implemented)\r
* GRUNDIG - Grundig\r
* NOKIA - Nokia\r
+ * SIEMENS - Siemens, e.g. Gigaset M740AV\r
*\r
*---------------------------------------------------------------------------------------------------------------------------------------------------\r
*\r
*\r
* data "0": data "1":\r
* ------________________ ------______________\r
- * 275us 1050us 275us 1900us\r
+ * 275us 775us 275us 1900us\r
*\r
*---------------------------------------------------------------------------------------------------------------------------------------------------\r
*\r
#include <string.h>\r
#include <inttypes.h>\r
\r
-#define DEBUG\r
+#define ANALYZE\r
#define PROGMEM\r
#define memcpy_P memcpy\r
\r
#include <string.h>\r
typedef unsigned char uint8_t;\r
typedef unsigned short uint16_t;\r
-#define DEBUG\r
+#define ANALYZE\r
#define PROGMEM\r
#define memcpy_P memcpy\r
\r
#define IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL 0\r
#endif\r
\r
-#define IRMP_TIMEOUT_TIME 16500.0e-6 // timeout after 16.5 ms darkness\r
+#if IRMP_SUPPORT_RC5_PROTOCOL == 1 || IRMP_SUPPORT_RC6_PROTOCOL == 1 || IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1 || IRMP_SUPPORT_SIEMENS_PROTOCOL == 1 \r
+#define IRMP_SUPPORT_MANCHESTER 1\r
+#else\r
+#define IRMP_SUPPORT_MANCHESTER 0\r
+#endif\r
+\r
+#define IRMP_TIMEOUT_TIME 16000.0e-6 // timeout after 16 ms darkness\r
+#define IRMP_TIMEOUT_TIME_MS 16L // timeout after 16 ms darkness\r
+\r
+#if (F_INTERRUPTS * IRMP_TIMEOUT_TIME_MS) / 1000 >= 255\r
+#define IRMP_TIMEOUT_LEN (uint16_t)(F_INTERRUPTS * IRMP_TIMEOUT_TIME + 0.5)\r
+typedef uint16_t PAUSE_LEN;\r
+#else\r
#define IRMP_TIMEOUT_LEN (uint8_t)(F_INTERRUPTS * IRMP_TIMEOUT_TIME + 0.5)\r
+typedef uint8_t PAUSE_LEN;\r
+#endif\r
+\r
#define IRMP_KEY_REPETITION_LEN (uint16_t)(F_INTERRUPTS * 150.0e-3 + 0.5) // autodetect key repetition within 150 msec\r
\r
#define MIN_TOLERANCE_00 1.0 // -0%\r
#define RC5_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
#define RC5_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC5_BIT_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
\r
-#define DENON_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)\r
-#define DENON_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
-#define DENON_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)\r
-#define DENON_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
-#define DENON_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)\r
-#define DENON_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
+#define DENON_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define DENON_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define DENON_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define DENON_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define DENON_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define DENON_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * DENON_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
\r
#define RC6_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
#define RC6_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RC6_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
#define NUBERT_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)\r
#define NUBERT_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * NUBERT_0_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
\r
-#define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_R_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_R_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-#define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MIN_TOLERANCE_05 + 0.5) - 1)\r
-#define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1)\r
-\r
-#define GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)\r
-#define GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
-#define GRUNDIG_OR_NOKIA_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)\r
-#define GRUNDIG_OR_NOKIA_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
-#define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) + 1)\r
-#define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
+#define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT2_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT3_PAUSE_TIME * MAX_TOLERANCE_05 + 0.5) + 1) // 10% is too big (uint8_t)\r
+#define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_START_BIT4_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_1_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_0_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_R_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_R_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_R_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+\r
+#define GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)\r
+#define GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
+#define GRUNDIG_OR_NOKIA_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MIN_TOLERANCE_20 + 0.5) - 1)\r
+#define GRUNDIG_OR_NOKIA_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_BIT_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
+#define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MIN_TOLERANCE_20 + 0.5) + 1)\r
+#define GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * GRUNDIG_OR_NOKIA_PRE_PAUSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
+\r
+#define SIEMENS_START_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) - 1)\r
+#define SIEMENS_START_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) + 1)\r
+#define SIEMENS_BIT_LEN_MIN ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) - 1)\r
+#define SIEMENS_BIT_LEN_MAX ((uint8_t)(F_INTERRUPTS * SIEMENS_BIT_TIME * 1 + 0.5) + 1)\r
+\r
+#define FDC_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define FDC_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define FDC_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define FDC_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define FDC_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)\r
+#define FDC_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_PULSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)\r
+#define FDC_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)\r
+#define FDC_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)\r
+#define FDC_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * FDC_0_PAUSE_TIME * MIN_TOLERANCE_40 + 0.5) - 1)\r
+#define FDC_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * FDC_0_PAUSE_TIME * MAX_TOLERANCE_40 + 0.5) + 1)\r
+\r
+#define RCCAR_START_BIT_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define RCCAR_START_BIT_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PULSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define RCCAR_START_BIT_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MIN_TOLERANCE_10 + 0.5) - 1)\r
+#define RCCAR_START_BIT_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_START_BIT_PAUSE_TIME * MAX_TOLERANCE_10 + 0.5) + 1)\r
+#define RCCAR_PULSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MIN_TOLERANCE_20 + 0.5) - 1)\r
+#define RCCAR_PULSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_PULSE_TIME * MAX_TOLERANCE_20 + 0.5) + 1)\r
+#define RCCAR_1_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)\r
+#define RCCAR_1_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_1_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)\r
+#define RCCAR_0_PAUSE_LEN_MIN ((uint8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MIN_TOLERANCE_30 + 0.5) - 1)\r
+#define RCCAR_0_PAUSE_LEN_MAX ((uint8_t)(F_INTERRUPTS * RCCAR_0_PAUSE_TIME * MAX_TOLERANCE_30 + 0.5) + 1)\r
\r
#define AUTO_FRAME_REPETITION_LEN (uint16_t)(F_INTERRUPTS * AUTO_FRAME_REPETITION_TIME + 0.5) // use uint16_t!\r
\r
-#ifdef DEBUG\r
-#define DEBUG_PUTCHAR(a) { if (! silent) { putchar (a); } }\r
-#define DEBUG_PRINTF(...) { if (! silent) { printf (__VA_ARGS__); } }\r
-static int silent;\r
-static int time_counter;\r
+#ifdef ANALYZE\r
+#define ANALYZE_PUTCHAR(a) { if (! silent) { putchar (a); } }\r
+#define ANALYZE_ONLY_NORMAL_PUTCHAR(a) { if (! silent && !verbose) { putchar (a); } }\r
+#define ANALYZE_PRINTF(...) { if (verbose) { printf (__VA_ARGS__); } }\r
+#define ANALYZE_NEWLINE() { if (verbose) { putchar ('\n'); } }\r
+static int silent;\r
+static int time_counter;\r
+static int verbose;\r
#else\r
-#define DEBUG_PUTCHAR(a)\r
-#define DEBUG_PRINTF(...)\r
+#define ANALYZE_PUTCHAR(a)\r
+#define ANALYZE_ONLY_NORMAL_PUTCHAR(a)\r
+#define ANALYZE_PRINTF(...)\r
+#define ANALYZE_NEWLINE()\r
#endif\r
\r
#if IRMP_LOGGING == 1\r
-#define UART_BAUD 9600L\r
+#define BAUD 9600L\r
+#include <util/setbaud.h>\r
+\r
+#ifdef UBRR0H\r
+\r
+#define UART0_UBRRH UBRR0H\r
+#define UART0_UBRRL UBRR0L\r
+#define UART0_UCSRA UCSR0A\r
+#define UART0_UCSRB UCSR0B\r
+#define UART0_UCSRC UCSR0C\r
+#define UART0_UDRE_BIT_VALUE (1<<UDRE0)\r
+#define UART0_UCSZ1_BIT_VALUE (1<<UCSZ01)\r
+#define UART0_UCSZ0_BIT_VALUE (1<<UCSZ00)\r
+#ifdef URSEL0\r
+#define UART0_URSEL_BIT_VALUE (1<<URSEL0)\r
+#else\r
+#define UART0_URSEL_BIT_VALUE (0)\r
+#endif\r
+#define UART0_TXEN_BIT_VALUE (1<<TXEN0)\r
+#define UART0_UDR UDR0\r
\r
-// calculate real baud rate:\r
-#define UBRR_VAL ((F_CPU + UART_BAUD * 8) / (UART_BAUD * 16) - 1) // round\r
-#define BAUD_REAL (F_CPU / (16 * (UBRR_VAL + 1))) // real baudrate\r
-#define BAUD_ERROR ((BAUD_REAL * 1000) / UART_BAUD) // error in promille\r
+#else\r
+\r
+#define UART0_UBRRH UBRRH\r
+#define UART0_UBRRL UBRRL\r
+#define UART0_UCSRA UCSRA\r
+#define UART0_UCSRB UCSRB\r
+#define UART0_UCSRC UCSRC\r
+#define UART0_UDRE_BIT_VALUE (1<<UDRE)\r
+#define UART0_UCSZ1_BIT_VALUE (1<<UCSZ1)\r
+#define UART0_UCSZ0_BIT_VALUE (1<<UCSZ0)\r
+#ifdef URSEL\r
+#define UART0_URSEL_BIT_VALUE (1<<URSEL)\r
+#else\r
+#define UART0_URSEL_BIT_VALUE (0)\r
+#endif\r
+#define UART0_TXEN_BIT_VALUE (1<<TXEN)\r
+#define UART0_UDR UDR\r
\r
-#if ((BAUD_ERROR < 990) || (BAUD_ERROR > 1010))\r
-# error Error of baud rate of RS232 UARTx is more than 1%. That is too high!\r
#endif\r
\r
/*---------------------------------------------------------------------------------------------------------------------------------------------------\r
void\r
irmp_uart_init (void)\r
{\r
- UCSR0B |= (1<<TXEN0); // activate UART0 TX\r
- UBRR0H = UBRR_VAL >> 8; // store baudrate (upper byte)\r
- UBRR0L = UBRR_VAL & 0xFF; // store baudrate (lower byte)\r
+ UART0_UBRRH = UBRRH_VALUE; // set baud rate\r
+ UART0_UBRRL = UBRRL_VALUE;\r
+\r
+#if USE_2X\r
+ UART0_UCSRA = (1<<U2X);\r
+#else\r
+ UART0_UCSRA = 0;\r
+#endif\r
+\r
+ UART0_UCSRC = UART0_UCSZ1_BIT_VALUE | UART0_UCSZ0_BIT_VALUE | UART0_URSEL_BIT_VALUE;\r
+ UART0_UCSRB |= UART0_TXEN_BIT_VALUE; // enable UART TX\r
}\r
\r
/*---------------------------------------------------------------------------------------------------------------------------------------------------\r
void\r
irmp_uart_putc (unsigned char ch)\r
{\r
- while (!(UCSR0A & (1<<UDRE0)))\r
+ while (!(UART0_UCSRA & UART0_UDRE_BIT_VALUE))\r
{\r
;\r
}\r
\r
- UDR0 = ch;\r
+ UART0_UDR = ch;\r
}\r
\r
/*---------------------------------------------------------------------------------------------------------------------------------------------------\r
uint8_t complete_len; // complete length of frame\r
uint8_t stop_bit; // flag: frame has stop bit\r
uint8_t lsb_first; // flag: LSB first\r
+ uint8_t flags; // some flags\r
} IRMP_PARAMETER;\r
\r
#if IRMP_SUPPORT_SIRCS_PROTOCOL == 1\r
SIRCS_COMMAND_OFFSET + SIRCS_COMMAND_LEN, // command_end: end of command\r
SIRCS_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
SIRCS_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- SIRCS_LSB // lsb_first: flag: LSB first\r
+ SIRCS_LSB, // lsb_first: flag: LSB first\r
+ SIRCS_FLAGS // flags: some flags\r
};\r
\r
#endif\r
NEC_COMMAND_OFFSET + NEC_COMMAND_LEN, // command_end: end of command\r
NEC_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
NEC_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- NEC_LSB // lsb_first: flag: LSB first\r
+ NEC_LSB, // lsb_first: flag: LSB first\r
+ NEC_FLAGS // flags: some flags\r
};\r
\r
static PROGMEM IRMP_PARAMETER nec_rep_param =\r
0, // command_end: end of command\r
0, // complete_len: complete length of frame\r
NEC_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- NEC_LSB // lsb_first: flag: LSB first\r
+ NEC_LSB, // lsb_first: flag: LSB first\r
+ NEC_FLAGS // flags: some flags\r
};\r
\r
#endif\r
SAMSUNG_COMMAND_OFFSET + SAMSUNG_COMMAND_LEN, // command_end: end of command\r
SAMSUNG_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
SAMSUNG_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- SAMSUNG_LSB // lsb_first: flag: LSB first\r
+ SAMSUNG_LSB, // lsb_first: flag: LSB first\r
+ SAMSUNG_FLAGS // flags: some flags\r
};\r
\r
#endif\r
MATSUSHITA_COMMAND_OFFSET + MATSUSHITA_COMMAND_LEN, // command_end: end of command\r
MATSUSHITA_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
MATSUSHITA_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- MATSUSHITA_LSB // lsb_first: flag: LSB first\r
+ MATSUSHITA_LSB, // lsb_first: flag: LSB first\r
+ MATSUSHITA_FLAGS // flags: some flags\r
};\r
\r
#endif\r
KASEIKYO_COMMAND_OFFSET + KASEIKYO_COMMAND_LEN, // command_end: end of command\r
KASEIKYO_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
KASEIKYO_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- KASEIKYO_LSB // lsb_first: flag: LSB first\r
+ KASEIKYO_LSB, // lsb_first: flag: LSB first\r
+ KASEIKYO_FLAGS // flags: some flags\r
};\r
\r
#endif\r
RECS80_COMMAND_OFFSET + RECS80_COMMAND_LEN, // command_end: end of command\r
RECS80_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
RECS80_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- RECS80_LSB // lsb_first: flag: LSB first\r
+ RECS80_LSB, // lsb_first: flag: LSB first\r
+ RECS80_FLAGS // flags: some flags\r
};\r
\r
#endif\r
RC5_COMMAND_OFFSET + RC5_COMMAND_LEN, // command_end: end of command\r
RC5_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
RC5_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- RC5_LSB // lsb_first: flag: LSB first\r
+ RC5_LSB, // lsb_first: flag: LSB first\r
+ RC5_FLAGS // flags: some flags\r
};\r
\r
#endif\r
DENON_COMMAND_OFFSET + DENON_COMMAND_LEN, // command_end: end of command\r
DENON_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
DENON_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- DENON_LSB // lsb_first: flag: LSB first\r
+ DENON_LSB, // lsb_first: flag: LSB first\r
+ DENON_FLAGS // flags: some flags\r
};\r
\r
#endif\r
RC6_COMMAND_OFFSET + RC6_COMMAND_LEN, // command_end: end of command\r
RC6_COMPLETE_DATA_LEN_SHORT, // complete_len: complete length of frame\r
RC6_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- RC6_LSB // lsb_first: flag: LSB first\r
+ RC6_LSB, // lsb_first: flag: LSB first\r
+ RC6_FLAGS // flags: some flags\r
};\r
\r
#endif\r
RECS80EXT_COMMAND_OFFSET + RECS80EXT_COMMAND_LEN, // command_end: end of command\r
RECS80EXT_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
RECS80EXT_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- RECS80EXT_LSB // lsb_first: flag: LSB first\r
+ RECS80EXT_LSB, // lsb_first: flag: LSB first\r
+ RECS80EXT_FLAGS // flags: some flags\r
};\r
\r
#endif\r
NUBERT_COMMAND_OFFSET + NUBERT_COMMAND_LEN, // command_end: end of command\r
NUBERT_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
NUBERT_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- NUBERT_LSB // lsb_first: flag: LSB first\r
+ NUBERT_LSB, // lsb_first: flag: LSB first\r
+ NUBERT_FLAGS // flags: some flags\r
};\r
\r
#endif\r
BANG_OLUFSEN_COMMAND_OFFSET + BANG_OLUFSEN_COMMAND_LEN, // command_end: end of command\r
BANG_OLUFSEN_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
BANG_OLUFSEN_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- BANG_OLUFSEN_LSB // lsb_first: flag: LSB first\r
+ BANG_OLUFSEN_LSB, // lsb_first: flag: LSB first\r
+ BANG_OLUFSEN_FLAGS // flags: some flags\r
};\r
\r
#endif\r
GRUNDIG_COMMAND_OFFSET + GRUNDIG_COMMAND_LEN + 1, // command_end: end of command (USE 1 bit MORE to STORE NOKIA DATA!)\r
NOKIA_COMPLETE_DATA_LEN, // complete_len: complete length of frame, here: NOKIA instead of GRUNDIG!\r
GRUNDIG_OR_NOKIA_STOP_BIT, // stop_bit: flag: frame has stop bit\r
- GRUNDIG_OR_NOKIA_LSB // lsb_first: flag: LSB first\r
+ GRUNDIG_OR_NOKIA_LSB, // lsb_first: flag: LSB first\r
+ GRUNDIG_OR_NOKIA_FLAGS // flags: some flags\r
+};\r
+\r
+#endif\r
+\r
+#if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1\r
+\r
+static PROGMEM IRMP_PARAMETER siemens_param =\r
+{\r
+ IRMP_SIEMENS_PROTOCOL, // protocol: ir protocol\r
+ SIEMENS_BIT_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1\r
+ SIEMENS_BIT_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1\r
+ SIEMENS_BIT_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1\r
+ SIEMENS_BIT_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1\r
+ 1, // tricky: use this as stop bit length // pulse_0_len_min: minimum length of pulse with bit value 0\r
+ 1, // pulse_0_len_max: maximum length of pulse with bit value 0\r
+ 1, // pause_0_len_min: minimum length of pause with bit value 0\r
+ 1, // pause_0_len_max: maximum length of pause with bit value 0\r
+ SIEMENS_ADDRESS_OFFSET, // address_offset: address offset\r
+ SIEMENS_ADDRESS_OFFSET + SIEMENS_ADDRESS_LEN, // address_end: end of address\r
+ SIEMENS_COMMAND_OFFSET, // command_offset: command offset\r
+ SIEMENS_COMMAND_OFFSET + SIEMENS_COMMAND_LEN, // command_end: end of command\r
+ SIEMENS_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
+ SIEMENS_STOP_BIT, // stop_bit: flag: frame has stop bit\r
+ SIEMENS_LSB, // lsb_first: flag: LSB first\r
+ SIEMENS_FLAGS // flags: some flags\r
+};\r
+\r
+#endif\r
+\r
+#if IRMP_SUPPORT_FDC_PROTOCOL == 1\r
+\r
+static PROGMEM IRMP_PARAMETER fdc_param =\r
+{\r
+ IRMP_FDC_PROTOCOL, // protocol: ir protocol\r
+ FDC_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1\r
+ FDC_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1\r
+ FDC_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1\r
+ FDC_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1\r
+ FDC_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0\r
+ FDC_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0\r
+ FDC_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0\r
+ FDC_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0\r
+ FDC_ADDRESS_OFFSET, // address_offset: address offset\r
+ FDC_ADDRESS_OFFSET + FDC_ADDRESS_LEN, // address_end: end of address\r
+ FDC_COMMAND_OFFSET, // command_offset: command offset\r
+ FDC_COMMAND_OFFSET + FDC_COMMAND_LEN, // command_end: end of command\r
+ FDC_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
+ FDC_STOP_BIT, // stop_bit: flag: frame has stop bit\r
+ FDC_LSB, // lsb_first: flag: LSB first\r
+ FDC_FLAGS // flags: some flags\r
+};\r
+\r
+#endif\r
+\r
+#if IRMP_SUPPORT_RCCAR_PROTOCOL == 1\r
+\r
+static PROGMEM IRMP_PARAMETER rccar_param =\r
+{\r
+ IRMP_RCCAR_PROTOCOL, // protocol: ir protocol\r
+ RCCAR_PULSE_LEN_MIN, // pulse_1_len_min: minimum length of pulse with bit value 1\r
+ RCCAR_PULSE_LEN_MAX, // pulse_1_len_max: maximum length of pulse with bit value 1\r
+ RCCAR_1_PAUSE_LEN_MIN, // pause_1_len_min: minimum length of pause with bit value 1\r
+ RCCAR_1_PAUSE_LEN_MAX, // pause_1_len_max: maximum length of pause with bit value 1\r
+ RCCAR_PULSE_LEN_MIN, // pulse_0_len_min: minimum length of pulse with bit value 0\r
+ RCCAR_PULSE_LEN_MAX, // pulse_0_len_max: maximum length of pulse with bit value 0\r
+ RCCAR_0_PAUSE_LEN_MIN, // pause_0_len_min: minimum length of pause with bit value 0\r
+ RCCAR_0_PAUSE_LEN_MAX, // pause_0_len_max: maximum length of pause with bit value 0\r
+ RCCAR_ADDRESS_OFFSET, // address_offset: address offset\r
+ RCCAR_ADDRESS_OFFSET + RCCAR_ADDRESS_LEN, // address_end: end of address\r
+ RCCAR_COMMAND_OFFSET, // command_offset: command offset\r
+ RCCAR_COMMAND_OFFSET + RCCAR_COMMAND_LEN, // command_end: end of command\r
+ RCCAR_COMPLETE_DATA_LEN, // complete_len: complete length of frame\r
+ RCCAR_STOP_BIT, // stop_bit: flag: frame has stop bit\r
+ RCCAR_LSB, // lsb_first: flag: LSB first\r
+ RCCAR_FLAGS // flags: some flags\r
};\r
\r
#endif\r
static volatile uint16_t irmp_id; // only used for SAMSUNG protocol\r
static volatile uint8_t irmp_flags;\r
\r
-#ifdef DEBUG\r
+#ifdef ANALYZE\r
static uint8_t IRMP_PIN;\r
#endif\r
\r
* @details Configures IRMP input pin\r
*---------------------------------------------------------------------------------------------------------------------------------------------------\r
*/\r
-#ifndef DEBUG\r
+#ifndef ANALYZE\r
void\r
irmp_init (void)\r
{\r
}\r
else if ((irmp_command & 0xFF00) == 0xD100)\r
{\r
- DEBUG_PRINTF ("Switching to APPLE protocol\n");\r
+ ANALYZE_PRINTF ("Switching to APPLE protocol\n");\r
irmp_protocol = IRMP_APPLE_PROTOCOL;\r
irmp_command &= 0xff;\r
rtc = TRUE;\r
}\r
break;\r
+#endif\r
+#if IRMP_SUPPORT_RCCAR_PROTOCOL == 1\r
+ case IRMP_RCCAR_PROTOCOL:\r
+ // frame in irmp_data:\r
+ // Bit 12 11 10 9 8 7 6 5 4 3 2 1 0\r
+ // V D7 D6 D5 D4 D3 D2 D1 D0 A1 A0 C1 C0 // 10 9 8 7 6 5 4 3 2 1 0\r
+ irmp_address = (irmp_command & 0x000C) >> 2; // addr: 0 0 0 0 0 0 0 0 0 A1 A0\r
+ irmp_command = ((irmp_command & 0x1000) >> 2) | // V-Bit: V 0 0 0 0 0 0 0 0 0 0\r
+ ((irmp_command & 0x0003) << 8) | // C-Bits: 0 C1 C0 0 0 0 0 0 0 0 0\r
+ ((irmp_command & 0x0FF0) >> 4); // D-Bits: D7 D6 D5 D4 D3 D2 D1 D0\r
+ rtc = TRUE; // Summe: V C1 C0 D7 D6 D5 D4 D3 D2 D1 D0\r
+ break;\r
#endif\r
default:\r
rtc = TRUE;\r
* @details ISR routine, called 10000 times per second\r
*---------------------------------------------------------------------------------------------------------------------------------------------------\r
*/\r
-void\r
+uint8_t\r
irmp_ISR (void)\r
{\r
- static uint8_t irmp_start_bit_detected; // flag: start bit detected\r
- static uint8_t wait_for_space; // flag: wait for data bit space\r
- static uint8_t wait_for_start_space; // flag: wait for start bit space\r
- static uint8_t irmp_pulse_time; // count bit time for pulse\r
- static uint8_t irmp_pause_time; // count bit time for pause\r
- static uint16_t last_irmp_address = 0xFFFF; // save last irmp address to recognize key repetition\r
- static uint16_t last_irmp_command = 0xFFFF; // save last irmp command to recognize key repetition\r
- static uint16_t repetition_counter; // SIRCS repeats frame 2-5 times with 45 ms pause\r
- static uint8_t repetition_frame_number;\r
+ static uint8_t irmp_start_bit_detected; // flag: start bit detected\r
+ static uint8_t wait_for_space; // flag: wait for data bit space\r
+ static uint8_t wait_for_start_space; // flag: wait for start bit space\r
+ static uint8_t irmp_pulse_time; // count bit time for pulse\r
+ static PAUSE_LEN irmp_pause_time; // count bit time for pause\r
+ static uint16_t last_irmp_address = 0xFFFF; // save last irmp address to recognize key repetition\r
+ static uint16_t last_irmp_command = 0xFFFF; // save last irmp command to recognize key repetition\r
+ static uint16_t repetition_counter; // SIRCS repeats frame 2-5 times with 45 ms pause\r
+ static uint8_t repetition_frame_number;\r
#if IRMP_SUPPORT_DENON_PROTOCOL == 1\r
- static uint16_t last_irmp_denon_command; // save last irmp command to recognize DENON frame repetition\r
+ static uint16_t last_irmp_denon_command; // save last irmp command to recognize DENON frame repetition\r
#endif\r
#if IRMP_SUPPORT_RC5_PROTOCOL == 1\r
- static uint8_t rc5_cmd_bit6; // bit 6 of RC5 command is the inverted 2nd start bit\r
+ static uint8_t rc5_cmd_bit6; // bit 6 of RC5 command is the inverted 2nd start bit\r
#endif\r
-#if IRMP_SUPPORT_RC5_PROTOCOL == 1 || IRMP_SUPPORT_RC6_PROTOCOL == 1\r
- static uint8_t last_pause; // last pause value\r
+#if IRMP_SUPPORT_MANCHESTER == 1\r
+ static PAUSE_LEN last_pause; // last pause value\r
#endif\r
-#if IRMP_SUPPORT_RC5_PROTOCOL == 1 || IRMP_SUPPORT_RC6_PROTOCOL == 1 || IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1 || IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1\r
- static uint8_t last_value; // last bit value\r
+#if IRMP_SUPPORT_MANCHESTER == 1 || IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1\r
+ static uint8_t last_value; // last bit value\r
#endif\r
- uint8_t irmp_input; // input value\r
+ uint8_t irmp_input; // input value\r
\r
-#ifdef DEBUG\r
+#ifdef ANALYZE\r
time_counter++;\r
#endif\r
\r
{ // no...\r
if (! irmp_input) // receiving burst?\r
{ // yes...\r
-#ifdef DEBUG\r
+#ifdef ANALYZE\r
if (! irmp_pulse_time)\r
{\r
- DEBUG_PRINTF("%8d [starting pulse]\n", time_counter);\r
+ ANALYZE_PRINTF("%8d [starting pulse]\n", time_counter);\r
}\r
#endif\r
irmp_pulse_time++; // increment counter\r
\r
if (irmp_pause_time > IRMP_TIMEOUT_LEN) // timeout?\r
{ // yes...\r
- DEBUG_PRINTF ("error 1: pause after start bit %d too long: %d\n", irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_PRINTF ("error 1: pause after start bit pulse %d too long: %d\n", irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');\r
irmp_start_bit_detected = 0; // reset flags, let's wait for another start bit\r
irmp_pulse_time = 0;\r
irmp_pause_time = 0;\r
{ // receiving first data pulse!\r
IRMP_PARAMETER * irmp_param_p = (IRMP_PARAMETER *) 0;\r
\r
- DEBUG_PRINTF ("start-bit: pulse = %d, pause = %d\n", irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_PRINTF ("start-bit: pulse = %d, pause = %d\n", irmp_pulse_time, irmp_pause_time);\r
\r
#if IRMP_SUPPORT_SIRCS_PROTOCOL == 1\r
if (irmp_pulse_time >= SIRCS_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= SIRCS_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= SIRCS_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= SIRCS_START_BIT_PAUSE_LEN_MAX)\r
{ // it's SIRCS\r
- DEBUG_PRINTF ("protocol = SIRCS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = SIRCS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
SIRCS_START_BIT_PULSE_LEN_MIN, SIRCS_START_BIT_PULSE_LEN_MAX,\r
SIRCS_START_BIT_PAUSE_LEN_MIN, SIRCS_START_BIT_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) (IRMP_PARAMETER *) &sircs_param;\r
if (irmp_pulse_time >= NEC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= NEC_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= NEC_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= NEC_START_BIT_PAUSE_LEN_MAX)\r
{\r
- DEBUG_PRINTF ("protocol = NEC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = NEC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
NEC_START_BIT_PULSE_LEN_MIN, NEC_START_BIT_PULSE_LEN_MAX,\r
NEC_START_BIT_PAUSE_LEN_MIN, NEC_START_BIT_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &nec_param;\r
else if (irmp_pulse_time >= NEC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= NEC_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= NEC_REPEAT_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= NEC_REPEAT_START_BIT_PAUSE_LEN_MAX)\r
{ // it's NEC\r
- DEBUG_PRINTF ("protocol = NEC (repetition frame), start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = NEC (repetition frame), start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
NEC_START_BIT_PULSE_LEN_MIN, NEC_START_BIT_PULSE_LEN_MAX,\r
NEC_REPEAT_START_BIT_PAUSE_LEN_MIN, NEC_REPEAT_START_BIT_PAUSE_LEN_MAX);\r
\r
if (irmp_pulse_time >= SAMSUNG_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= SAMSUNG_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= SAMSUNG_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= SAMSUNG_START_BIT_PAUSE_LEN_MAX)\r
{ // it's SAMSUNG\r
- DEBUG_PRINTF ("protocol = SAMSUNG, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = SAMSUNG, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
SAMSUNG_START_BIT_PULSE_LEN_MIN, SAMSUNG_START_BIT_PULSE_LEN_MAX,\r
SAMSUNG_START_BIT_PAUSE_LEN_MIN, SAMSUNG_START_BIT_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &samsung_param;\r
if (irmp_pulse_time >= MATSUSHITA_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= MATSUSHITA_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= MATSUSHITA_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= MATSUSHITA_START_BIT_PAUSE_LEN_MAX)\r
{ // it's MATSUSHITA\r
- DEBUG_PRINTF ("protocol = MATSUSHITA, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = MATSUSHITA, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
MATSUSHITA_START_BIT_PULSE_LEN_MIN, MATSUSHITA_START_BIT_PULSE_LEN_MAX,\r
MATSUSHITA_START_BIT_PAUSE_LEN_MIN, MATSUSHITA_START_BIT_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &matsushita_param;\r
if (irmp_pulse_time >= KASEIKYO_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= KASEIKYO_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= KASEIKYO_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= KASEIKYO_START_BIT_PAUSE_LEN_MAX)\r
{ // it's KASEIKYO\r
- DEBUG_PRINTF ("protocol = KASEIKYO, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = KASEIKYO, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
KASEIKYO_START_BIT_PULSE_LEN_MIN, KASEIKYO_START_BIT_PULSE_LEN_MAX,\r
KASEIKYO_START_BIT_PAUSE_LEN_MIN, KASEIKYO_START_BIT_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &kaseikyo_param;\r
if (irmp_pulse_time >= RECS80_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RECS80_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= RECS80_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RECS80_START_BIT_PAUSE_LEN_MAX)\r
{ // it's RECS80\r
- DEBUG_PRINTF ("protocol = RECS80, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = RECS80, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
RECS80_START_BIT_PULSE_LEN_MIN, RECS80_START_BIT_PULSE_LEN_MAX,\r
RECS80_START_BIT_PAUSE_LEN_MIN, RECS80_START_BIT_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &recs80_param;\r
((irmp_pause_time >= RC5_START_BIT_LEN_MIN && irmp_pause_time <= RC5_START_BIT_LEN_MAX) ||\r
(irmp_pause_time >= 2 * RC5_START_BIT_LEN_MIN && irmp_pause_time <= 2 * RC5_START_BIT_LEN_MAX)))\r
{ // it's RC5\r
- DEBUG_PRINTF ("protocol = RC5, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = RC5, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
RC5_START_BIT_LEN_MIN, RC5_START_BIT_LEN_MAX,\r
RC5_START_BIT_LEN_MIN, RC5_START_BIT_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &rc5_param;\r
((irmp_pause_time >= DENON_1_PAUSE_LEN_MIN && irmp_pause_time <= DENON_1_PAUSE_LEN_MAX) ||\r
(irmp_pause_time >= DENON_0_PAUSE_LEN_MIN && irmp_pause_time <= DENON_0_PAUSE_LEN_MAX)))\r
{ // it's DENON\r
- DEBUG_PRINTF ("protocol = DENON, start bit timings: pulse: %3d - %3d, pause: %3d - %3d or %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = DENON, start bit timings: pulse: %3d - %3d, pause: %3d - %3d or %3d - %3d\n",\r
DENON_PULSE_LEN_MIN, DENON_PULSE_LEN_MAX,\r
DENON_1_PAUSE_LEN_MIN, DENON_1_PAUSE_LEN_MAX,\r
DENON_0_PAUSE_LEN_MIN, DENON_0_PAUSE_LEN_MAX);\r
if (irmp_pulse_time >= RC6_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RC6_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= RC6_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RC6_START_BIT_PAUSE_LEN_MAX)\r
{ // it's RC6\r
- DEBUG_PRINTF ("protocol = RC6, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = RC6, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
RC6_START_BIT_PULSE_LEN_MIN, RC6_START_BIT_PULSE_LEN_MAX,\r
RC6_START_BIT_PAUSE_LEN_MIN, RC6_START_BIT_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &rc6_param;\r
if (irmp_pulse_time >= RECS80EXT_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RECS80EXT_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= RECS80EXT_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RECS80EXT_START_BIT_PAUSE_LEN_MAX)\r
{ // it's RECS80EXT\r
- DEBUG_PRINTF ("protocol = RECS80EXT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = RECS80EXT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
RECS80EXT_START_BIT_PULSE_LEN_MIN, RECS80EXT_START_BIT_PULSE_LEN_MAX,\r
RECS80EXT_START_BIT_PAUSE_LEN_MIN, RECS80EXT_START_BIT_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &recs80ext_param;\r
if (irmp_pulse_time >= NUBERT_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= NUBERT_START_BIT_PULSE_LEN_MAX &&\r
irmp_pause_time >= NUBERT_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= NUBERT_START_BIT_PAUSE_LEN_MAX)\r
{ // it's NUBERT\r
- DEBUG_PRINTF ("protocol = NUBERT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = NUBERT, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
NUBERT_START_BIT_PULSE_LEN_MIN, NUBERT_START_BIT_PULSE_LEN_MAX,\r
NUBERT_START_BIT_PAUSE_LEN_MIN, NUBERT_START_BIT_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &nubert_param;\r
if (irmp_pulse_time >= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN && irmp_pulse_time <= BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX &&\r
irmp_pause_time >= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX)\r
{ // it's BANG_OLUFSEN\r
- DEBUG_PRINTF ("protocol = BANG_OLUFSEN\n");\r
- DEBUG_PRINTF ("start bit 1 timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = BANG_OLUFSEN\n");\r
+ ANALYZE_PRINTF ("start bit 1 timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
BANG_OLUFSEN_START_BIT1_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT1_PULSE_LEN_MAX,\r
BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT1_PAUSE_LEN_MAX);\r
- DEBUG_PRINTF ("start bit 2 timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("start bit 2 timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
BANG_OLUFSEN_START_BIT2_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT2_PULSE_LEN_MAX,\r
BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT2_PAUSE_LEN_MAX);\r
- DEBUG_PRINTF ("start bit 3 timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("start bit 3 timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
BANG_OLUFSEN_START_BIT3_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT3_PULSE_LEN_MAX,\r
BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX);\r
- DEBUG_PRINTF ("start bit 4 timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("start bit 4 timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX,\r
BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &bang_olufsen_param;\r
if (irmp_pulse_time >= GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN && irmp_pulse_time <= GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX &&\r
irmp_pause_time >= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN && irmp_pause_time <= GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX)\r
{ // it's GRUNDIG\r
- DEBUG_PRINTF ("protocol = GRUNDIG, pre bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ ANALYZE_PRINTF ("protocol = GRUNDIG, pre bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
GRUNDIG_OR_NOKIA_START_BIT_LEN_MIN, GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX,\r
GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MIN, GRUNDIG_OR_NOKIA_PRE_PAUSE_LEN_MAX);\r
irmp_param_p = (IRMP_PARAMETER *) &grundig_param;\r
else\r
#endif // IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1\r
\r
+#if IRMP_SUPPORT_SIEMENS_PROTOCOL == 1\r
+ if (((irmp_pulse_time >= SIEMENS_START_BIT_LEN_MIN && irmp_pulse_time <= SIEMENS_START_BIT_LEN_MAX) ||\r
+ (irmp_pulse_time >= 2 * SIEMENS_START_BIT_LEN_MIN && irmp_pulse_time <= 2 * SIEMENS_START_BIT_LEN_MAX)) &&\r
+ ((irmp_pause_time >= SIEMENS_START_BIT_LEN_MIN && irmp_pause_time <= SIEMENS_START_BIT_LEN_MAX) ||\r
+ (irmp_pause_time >= 2 * SIEMENS_START_BIT_LEN_MIN && irmp_pause_time <= 2 * SIEMENS_START_BIT_LEN_MAX)))\r
+ { // it's SIEMENS\r
+ ANALYZE_PRINTF ("protocol = SIEMENS, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ SIEMENS_START_BIT_LEN_MIN, SIEMENS_START_BIT_LEN_MAX,\r
+ SIEMENS_START_BIT_LEN_MIN, SIEMENS_START_BIT_LEN_MAX);\r
+ irmp_param_p = (IRMP_PARAMETER *) &siemens_param;\r
+ last_pause = irmp_pause_time;\r
+ last_value = 1;\r
+ }\r
+ else\r
+#endif // IRMP_SUPPORT_SIEMENS_PROTOCOL == 1\r
+#if IRMP_SUPPORT_FDC_PROTOCOL == 1\r
+ if (irmp_pulse_time >= FDC_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= FDC_START_BIT_PULSE_LEN_MAX &&\r
+ irmp_pause_time >= FDC_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= FDC_START_BIT_PAUSE_LEN_MAX)\r
{\r
- DEBUG_PRINTF ("protocol = UNKNOWN\n");\r
+ ANALYZE_PRINTF ("protocol = FDC, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ FDC_START_BIT_PULSE_LEN_MIN, FDC_START_BIT_PULSE_LEN_MAX,\r
+ FDC_START_BIT_PAUSE_LEN_MIN, FDC_START_BIT_PAUSE_LEN_MAX);\r
+ irmp_param_p = (IRMP_PARAMETER *) &fdc_param;\r
+ }\r
+ else\r
+#endif // IRMP_SUPPORT_FDC_PROTOCOL == 1\r
+#if IRMP_SUPPORT_RCCAR_PROTOCOL == 1\r
+ if (irmp_pulse_time >= RCCAR_START_BIT_PULSE_LEN_MIN && irmp_pulse_time <= RCCAR_START_BIT_PULSE_LEN_MAX &&\r
+ irmp_pause_time >= RCCAR_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= RCCAR_START_BIT_PAUSE_LEN_MAX)\r
+ {\r
+ ANALYZE_PRINTF ("protocol = RCCAR, start bit timings: pulse: %3d - %3d, pause: %3d - %3d\n",\r
+ RCCAR_START_BIT_PULSE_LEN_MIN, RCCAR_START_BIT_PULSE_LEN_MAX,\r
+ RCCAR_START_BIT_PAUSE_LEN_MIN, RCCAR_START_BIT_PAUSE_LEN_MAX);\r
+ irmp_param_p = (IRMP_PARAMETER *) &rccar_param;\r
+ }\r
+ else\r
+#endif // IRMP_SUPPORT_RCCAR_PROTOCOL == 1\r
+ {\r
+ ANALYZE_PRINTF ("protocol = UNKNOWN\n");\r
irmp_start_bit_detected = 0; // wait for another start bit...\r
}\r
\r
{\r
memcpy_P (&irmp_param, irmp_param_p, sizeof (IRMP_PARAMETER));\r
\r
- DEBUG_PRINTF ("pulse_1: %3d - %3d\n", irmp_param.pulse_1_len_min, irmp_param.pulse_1_len_max);\r
- DEBUG_PRINTF ("pause_1: %3d - %3d\n", irmp_param.pause_1_len_min, irmp_param.pause_1_len_max);\r
+#ifdef ANALYZE\r
+ if (! (irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER))\r
+ {\r
+ ANALYZE_PRINTF ("pulse_1: %3d - %3d\n", irmp_param.pulse_1_len_min, irmp_param.pulse_1_len_max);\r
+ ANALYZE_PRINTF ("pause_1: %3d - %3d\n", irmp_param.pause_1_len_min, irmp_param.pause_1_len_max);\r
+ }\r
+ else\r
+ {\r
+ ANALYZE_PRINTF ("pulse: %3d - %3d or %3d - %3d\n", irmp_param.pulse_1_len_min, irmp_param.pulse_1_len_max,\r
+ 2 * irmp_param.pulse_1_len_min, 2 * irmp_param.pulse_1_len_max);\r
+ ANALYZE_PRINTF ("pause: %3d - %3d or %3d - %3d\n", irmp_param.pause_1_len_min, irmp_param.pause_1_len_max,\r
+ 2 * irmp_param.pause_1_len_min, 2 * irmp_param.pause_1_len_max);\r
+ }\r
\r
#if IRMP_SUPPORT_RC6_PROTOCOL == 1\r
if (irmp_param.protocol == IRMP_RC6_PROTOCOL)\r
{\r
- DEBUG_PRINTF ("pulse_toggle: %3d - %3d\n", RC6_TOGGLE_BIT_LEN_MIN, RC6_TOGGLE_BIT_LEN_MAX);\r
+ ANALYZE_PRINTF ("pulse_toggle: %3d - %3d\n", RC6_TOGGLE_BIT_LEN_MIN, RC6_TOGGLE_BIT_LEN_MAX);\r
}\r
#endif\r
- DEBUG_PRINTF ("pulse_0: %3d - %3d\n", irmp_param.pulse_0_len_min, irmp_param.pulse_0_len_max);\r
- DEBUG_PRINTF ("pause_0: %3d - %3d\n", irmp_param.pause_0_len_min, irmp_param.pause_0_len_max);\r
+\r
+ if (! (irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER))\r
+ {\r
+ ANALYZE_PRINTF ("pulse_0: %3d - %3d\n", irmp_param.pulse_0_len_min, irmp_param.pulse_0_len_max);\r
+ ANALYZE_PRINTF ("pause_0: %3d - %3d\n", irmp_param.pause_0_len_min, irmp_param.pause_0_len_max);\r
+ }\r
\r
#if IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL == 1\r
if (irmp_param.protocol == IRMP_BANG_OLUFSEN_PROTOCOL)\r
{\r
- DEBUG_PRINTF ("pulse_r: %3d - %3d\n", irmp_param.pulse_0_len_min, irmp_param.pulse_0_len_max);\r
- DEBUG_PRINTF ("pause_r: %3d - %3d\n", BANG_OLUFSEN_R_PAUSE_LEN_MIN, BANG_OLUFSEN_R_PAUSE_LEN_MAX);\r
+ ANALYZE_PRINTF ("pulse_r: %3d - %3d\n", irmp_param.pulse_0_len_min, irmp_param.pulse_0_len_max);\r
+ ANALYZE_PRINTF ("pause_r: %3d - %3d\n", BANG_OLUFSEN_R_PAUSE_LEN_MIN, BANG_OLUFSEN_R_PAUSE_LEN_MAX);\r
}\r
#endif\r
\r
- DEBUG_PRINTF ("command_offset: %2d\n", irmp_param.command_offset);\r
- DEBUG_PRINTF ("command_len: %3d\n", irmp_param.command_end - irmp_param.command_offset);\r
- DEBUG_PRINTF ("complete_len: %3d\n", irmp_param.complete_len);\r
- DEBUG_PRINTF ("stop_bit: %3d\n", irmp_param.stop_bit);\r
+ ANALYZE_PRINTF ("command_offset: %2d\n", irmp_param.command_offset);\r
+ ANALYZE_PRINTF ("command_len: %3d\n", irmp_param.command_end - irmp_param.command_offset);\r
+ ANALYZE_PRINTF ("complete_len: %3d\n", irmp_param.complete_len);\r
+ ANALYZE_PRINTF ("stop_bit: %3d\n", irmp_param.stop_bit);\r
+#endif // ANALYZE\r
}\r
\r
irmp_bit = 0;\r
\r
-#if IRMP_SUPPORT_RC5_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_RC5_PROTOCOL)\r
+#if IRMP_SUPPORT_MANCHESTER == 1\r
+ if ((irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER) && irmp_param.protocol != IRMP_RC6_PROTOCOL) // manchester, but not rc6\r
{\r
- if (irmp_pause_time > RC5_START_BIT_LEN_MAX && irmp_pause_time <= 2 * RC5_START_BIT_LEN_MAX)\r
+ if (irmp_pause_time > irmp_param.pulse_1_len_max && irmp_pause_time <= 2 * irmp_param.pulse_1_len_max)\r
{\r
- DEBUG_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
- DEBUG_PUTCHAR ('1');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (1);\r
+ ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_PUTCHAR ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? '0' : '1');\r
+ ANALYZE_NEWLINE ();\r
+ irmp_store_bit ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 0 : 1);\r
}\r
else if (! last_value)\r
{\r
- DEBUG_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
- DEBUG_PUTCHAR ('0');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (0);\r
- }\r
- }\r
- else\r
-#endif // IRMP_SUPPORT_RC5_PROTOCOL == 1\r
+ ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
\r
-#if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL || irmp_param.protocol == IRMP_NOKIA_PROTOCOL)\r
- {\r
- if (irmp_pause_time > GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX && irmp_pause_time <= 2 * GRUNDIG_OR_NOKIA_START_BIT_LEN_MAX)\r
- {\r
- DEBUG_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
- DEBUG_PUTCHAR ('0');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (0);\r
- }\r
- else if (! last_value)\r
- {\r
- DEBUG_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
- DEBUG_PUTCHAR ('1');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (1);\r
+ ANALYZE_PUTCHAR ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? '1' : '0');\r
+ ANALYZE_NEWLINE ();\r
+ irmp_store_bit ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 1 : 0);\r
}\r
}\r
else\r
-#endif // IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1\r
+#endif // IRMP_SUPPORT_MANCHESTER == 1\r
\r
#if IRMP_SUPPORT_DENON_PROTOCOL == 1\r
if (irmp_param.protocol == IRMP_DENON_PROTOCOL)\r
{\r
- DEBUG_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
\r
if (irmp_pause_time >= DENON_1_PAUSE_LEN_MIN && irmp_pause_time <= DENON_1_PAUSE_LEN_MAX)\r
{ // pause timings correct for "1"?\r
- DEBUG_PUTCHAR ('1'); // yes, store 1\r
- DEBUG_PUTCHAR ('\n');\r
+ ANALYZE_PUTCHAR ('1'); // yes, store 1\r
+ ANALYZE_NEWLINE ();\r
irmp_store_bit (1);\r
}\r
else // if (irmp_pause_time >= DENON_0_PAUSE_LEN_MIN && irmp_pause_time <= DENON_0_PAUSE_LEN_MAX)\r
{ // pause timings correct for "0"?\r
- DEBUG_PUTCHAR ('0'); // yes, store 0\r
- DEBUG_PUTCHAR ('\n');\r
+ ANALYZE_PUTCHAR ('0'); // yes, store 0\r
+ ANALYZE_NEWLINE ();\r
irmp_store_bit (0);\r
}\r
}\r
{\r
if (irmp_pulse_time >= irmp_param.pulse_0_len_min && irmp_pulse_time <= irmp_param.pulse_0_len_max)\r
{\r
-#ifdef DEBUG\r
- if (irmp_param.protocol != IRMP_RC5_PROTOCOL &&\r
- irmp_param.protocol != IRMP_RC6_PROTOCOL &&\r
- irmp_param.protocol != IRMP_GRUNDIG_PROTOCOL &&\r
- irmp_param.protocol != IRMP_NOKIA_PROTOCOL)\r
+#ifdef ANALYZE\r
+ if (! (irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER))\r
{\r
- DEBUG_PRINTF ("stop bit detected\n");\r
+ ANALYZE_PRINTF ("stop bit detected\n");\r
}\r
#endif\r
irmp_param.stop_bit = 0;\r
}\r
else\r
{\r
- DEBUG_PRINTF ("stop bit timing wrong\n");\r
+ ANALYZE_PRINTF ("stop bit timing wrong\n");\r
\r
irmp_start_bit_detected = 0; // wait for another start bit...\r
irmp_pulse_time = 0;\r
}\r
else\r
#endif\r
-#if IRMP_SUPPORT_RC5_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_RC5_PROTOCOL &&\r
- irmp_pause_time > 2 * RC5_BIT_LEN_MAX && irmp_bit >= RC5_COMPLETE_DATA_LEN - 2 && !irmp_param.stop_bit)\r
- { // special rc5 decoder\r
- got_light = TRUE; // this is a lie, but generates a stop bit ;-)\r
- irmp_param.stop_bit = TRUE; // set flag\r
- }\r
- else\r
-#endif\r
-#if IRMP_SUPPORT_RC6_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_RC6_PROTOCOL &&\r
- irmp_pause_time > 2 * RC6_BIT_LEN_MAX && irmp_bit >= irmp_param.complete_len - 2 && !irmp_param.stop_bit)\r
- { // special rc6 decoder\r
- got_light = TRUE; // this is a lie, but generates a stop bit ;-)\r
- irmp_param.stop_bit = TRUE; // set flag\r
- }\r
- else\r
-#endif\r
-#if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL &&\r
- irmp_pause_time > 2 * GRUNDIG_OR_NOKIA_BIT_LEN_MAX && irmp_bit >= GRUNDIG_COMPLETE_DATA_LEN - 2 && !irmp_param.stop_bit)\r
- { // special Grundig/Nokia decoder\r
- irmp_param.complete_len = GRUNDIG_COMPLETE_DATA_LEN; // correct complete len\r
- got_light = TRUE; // this is a lie, but generates a stop bit ;-)\r
- irmp_param.stop_bit = TRUE; // set flag\r
- }\r
- else\r
-#endif\r
-#if IRMP_SUPPORT_NOKIA_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL &&\r
- irmp_bit >= GRUNDIG_COMPLETE_DATA_LEN)\r
+#if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1\r
+ if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL && !irmp_param.stop_bit)\r
{\r
- DEBUG_PRINTF ("Switching to NOKIA protocol\n");\r
- irmp_param.protocol = IRMP_NOKIA_PROTOCOL; // change protocol\r
- irmp_param.address_offset = NOKIA_ADDRESS_OFFSET;\r
- irmp_param.address_end = NOKIA_ADDRESS_OFFSET + NOKIA_ADDRESS_LEN;\r
- irmp_param.command_offset = NOKIA_COMMAND_OFFSET;\r
- irmp_param.command_end = NOKIA_COMMAND_OFFSET + NOKIA_COMMAND_LEN;\r
-\r
- if (irmp_tmp_command & 0x300)\r
+ if (irmp_pause_time > 2 * irmp_param.pause_1_len_max && irmp_bit >= GRUNDIG_COMPLETE_DATA_LEN - 2)\r
+ { // special manchester decoder\r
+ irmp_param.complete_len = GRUNDIG_COMPLETE_DATA_LEN; // correct complete len\r
+ got_light = TRUE; // this is a lie, but generates a stop bit ;-)\r
+ irmp_param.stop_bit = TRUE; // set flag\r
+ }\r
+ else if (irmp_bit >= GRUNDIG_COMPLETE_DATA_LEN)\r
{\r
- irmp_tmp_address = (irmp_tmp_command >> 8);\r
- irmp_tmp_command &= 0xFF;\r
+ ANALYZE_PRINTF ("Switching to NOKIA protocol\n");\r
+ irmp_param.protocol = IRMP_NOKIA_PROTOCOL; // change protocol\r
+ irmp_param.address_offset = NOKIA_ADDRESS_OFFSET;\r
+ irmp_param.address_end = NOKIA_ADDRESS_OFFSET + NOKIA_ADDRESS_LEN;\r
+ irmp_param.command_offset = NOKIA_COMMAND_OFFSET;\r
+ irmp_param.command_end = NOKIA_COMMAND_OFFSET + NOKIA_COMMAND_LEN;\r
+\r
+ if (irmp_tmp_command & 0x300)\r
+ {\r
+ irmp_tmp_address = (irmp_tmp_command >> 8);\r
+ irmp_tmp_command &= 0xFF;\r
+ }\r
}\r
}\r
else\r
#endif\r
-#if IRMP_SUPPORT_NOKIA_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_NOKIA_PROTOCOL &&\r
- irmp_pause_time > 2 * GRUNDIG_OR_NOKIA_BIT_LEN_MAX && irmp_bit >= NOKIA_COMPLETE_DATA_LEN - 2 && !irmp_param.stop_bit)\r
- { // special Grundig/Nokia decoder\r
- got_light = TRUE; // this is a lie, but generates a stop bit ;-)\r
- irmp_param.stop_bit = TRUE; // set flag\r
+#if IRMP_SUPPORT_MANCHESTER == 1\r
+ if ((irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER) &&\r
+ irmp_pause_time > 2 * irmp_param.pause_1_len_max && irmp_bit >= irmp_param.complete_len - 2 && !irmp_param.stop_bit)\r
+ { // special manchester decoder\r
+ got_light = TRUE; // this is a lie, but generates a stop bit ;-)\r
+ irmp_param.stop_bit = TRUE; // set flag\r
}\r
else\r
-#endif\r
+#endif // IRMP_SUPPORT_MANCHESTER == 1\r
if (irmp_pause_time > IRMP_TIMEOUT_LEN) // timeout?\r
{ // yes...\r
if (irmp_bit == irmp_param.complete_len - 1 && irmp_param.stop_bit == 0)\r
}\r
else\r
{\r
- DEBUG_PRINTF ("error 2: pause %d after data bit %d too long\n", irmp_pause_time, irmp_bit);\r
+ ANALYZE_PRINTF ("error 2: pause %d after data bit %d too long\n", irmp_pause_time, irmp_bit);\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');\r
\r
irmp_start_bit_detected = 0; // wait for another start bit...\r
irmp_pulse_time = 0;\r
\r
if (got_light)\r
{\r
- DEBUG_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_PRINTF ("%8d [bit %2d: pulse = %3d, pause = %3d] ", time_counter, irmp_bit, irmp_pulse_time, irmp_pause_time);\r
\r
-#if IRMP_SUPPORT_RC5_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_RC5_PROTOCOL) // special rc5 decoder\r
+#if IRMP_SUPPORT_MANCHESTER == 1\r
+ if ((irmp_param.flags & IRMP_PARAM_FLAG_IS_MANCHESTER)) // manchester\r
{\r
- if (irmp_pulse_time > RC5_BIT_LEN_MAX && irmp_pulse_time <= 2 * RC5_BIT_LEN_MAX)\r
- {\r
- DEBUG_PUTCHAR ('1');\r
- irmp_store_bit (1);\r
- DEBUG_PUTCHAR ('0');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (0);\r
- last_value = 0;\r
- }\r
-\r
- else // if (irmp_pulse_time >= RC5_BIT_LEN_MIN && irmp_pulse_time <= RC5_BIT_LEN_MAX)\r
+#if IRMP_SUPPORT_RC6_PROTOCOL == 1\r
+ if (irmp_param.protocol == IRMP_RC6_PROTOCOL && irmp_bit >= 3 && irmp_bit <= 5) // special bits of rc6\r
{\r
- uint8_t rc5_value;\r
-\r
- if (last_pause > RC5_BIT_LEN_MAX && last_pause <= 2 * RC5_BIT_LEN_MAX)\r
+ if (irmp_pulse_time > RC6_TOGGLE_BIT_LEN_MAX && irmp_pause_time > RC6_TOGGLE_BIT_LEN_MAX)\r
{\r
- rc5_value = last_value ? 0 : 1;\r
- last_value = rc5_value;\r
- }\r
- else\r
- {\r
- rc5_value = last_value;\r
+ ANALYZE_PUTCHAR ('1');\r
+ irmp_store_bit (1);\r
}\r
\r
- DEBUG_PUTCHAR (rc5_value + '0');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (rc5_value);\r
+ ANALYZE_PUTCHAR ('0');\r
+ irmp_store_bit (0);\r
+ last_value = 0;\r
+ ANALYZE_NEWLINE ();\r
}\r
-\r
- last_pause = irmp_pause_time;\r
- wait_for_space = 0;\r
- }\r
- else\r
-#endif\r
-\r
-#if IRMP_SUPPORT_GRUNDIG_OR_NOKIA_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL || // special Grundig decoder\r
- irmp_param.protocol == IRMP_NOKIA_PROTOCOL) // special Nokia decoder\r
- {\r
- if (irmp_pulse_time > GRUNDIG_OR_NOKIA_BIT_LEN_MAX && irmp_pulse_time <= 2 * GRUNDIG_OR_NOKIA_BIT_LEN_MAX)\r
+ else\r
+#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1\r
+ if (irmp_pulse_time > irmp_param.pulse_1_len_max && irmp_pulse_time <= 2 * irmp_param.pulse_1_len_max)\r
{\r
- DEBUG_PUTCHAR ('0');\r
- irmp_store_bit (0);\r
- DEBUG_PUTCHAR ('1');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (1);\r
- last_value = 1;\r
+ ANALYZE_PUTCHAR ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? '0' : '1');\r
+ irmp_store_bit ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 0 : 1 );\r
+ ANALYZE_PUTCHAR ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? '1' : '0');\r
+ irmp_store_bit ((irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 1 : 0 );\r
+ ANALYZE_NEWLINE ();\r
+ last_value = (irmp_param.flags & IRMP_PARAM_FLAG_1ST_PULSE_IS_1) ? 1 : 0;\r
}\r
-\r
- else // if (irmp_pulse_time >= GRUNDIG_BIT_LEN_MIN && irmp_pulse_time <= GRUNDIG_OR_NOKIA_BIT_LEN_MAX)\r
+ else // if (irmp_pulse_time >= irmp_param.pulse_1_len_max && irmp_pulse_time <= irmp_param.pulse_1_len_max)\r
{\r
- uint8_t grundig_value;\r
+ uint8_t manchester_value;\r
\r
- if (last_pause > GRUNDIG_OR_NOKIA_BIT_LEN_MAX && last_pause <= 2 * GRUNDIG_OR_NOKIA_BIT_LEN_MAX)\r
+ if (last_pause > irmp_param.pause_1_len_max && last_pause <= 2 * irmp_param.pause_1_len_max)\r
{\r
- grundig_value = last_value ? 0 : 1;\r
- last_value = grundig_value;\r
+ manchester_value = last_value ? 0 : 1;\r
+ last_value = manchester_value;\r
}\r
else\r
{\r
- grundig_value = last_value;\r
+ manchester_value = last_value;\r
}\r
\r
- DEBUG_PUTCHAR (grundig_value + '0');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (grundig_value);\r
- }\r
-\r
- last_pause = irmp_pause_time;\r
- wait_for_space = 0;\r
- }\r
- else\r
-#endif\r
-\r
+#if 0\r
#if IRMP_SUPPORT_RC6_PROTOCOL == 1\r
- if (irmp_param.protocol == IRMP_RC6_PROTOCOL) // special rc6 decoder\r
- {\r
- switch (irmp_bit)\r
- { // handle toggle bit, which is 2 times longer than other bits\r
- case 3:\r
- case 4:\r
- case 5:\r
- if (irmp_pulse_time > RC6_TOGGLE_BIT_LEN_MAX && irmp_pause_time > RC6_TOGGLE_BIT_LEN_MAX)\r
- {\r
- DEBUG_PUTCHAR ('1');\r
- irmp_store_bit (1);\r
- }\r
-\r
- DEBUG_PUTCHAR ('0');\r
- irmp_store_bit (0);\r
- last_value = 0;\r
- DEBUG_PUTCHAR ('\n');\r
- break;\r
-\r
- default:\r
- if (irmp_pulse_time > RC6_BIT_LEN_MAX && irmp_pulse_time <= 2 * RC6_BIT_LEN_MAX)\r
- {\r
- DEBUG_PUTCHAR ('0');\r
- irmp_store_bit (0);\r
- DEBUG_PUTCHAR ('1');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (1);\r
- last_value = 1;\r
- }\r
- else // if (irmp_pulse_time >= RC6_BIT_LEN_MIN && irmp_pulse_time <= RC6_BIT_LEN_MAX)\r
- {\r
- uint8_t rc5_value;\r
-\r
- if (last_pause > RC6_BIT_LEN_MAX && last_pause <= 2 * RC6_BIT_LEN_MAX)\r
- {\r
- rc5_value = last_value ? 0 : 1;\r
- last_value = rc5_value;\r
- }\r
- else\r
- {\r
- rc5_value = last_value;\r
- }\r
-\r
- if (irmp_bit == 1 && rc5_value == 0)\r
- {\r
- irmp_param.complete_len = RC6_COMPLETE_DATA_LEN_LONG;\r
- }\r
-\r
- DEBUG_PUTCHAR (rc5_value + '0');\r
- DEBUG_PUTCHAR ('\n');\r
- irmp_store_bit (rc5_value);\r
- }\r
+ if (irmp_param.protocol == IRMP_RC6_PROTOCOL && irmp_bit == 1 && manchester_value == 0) // RC6 mode != 0 ???\r
+ {\r
+ irmp_param.complete_len = RC6_COMPLETE_DATA_LEN_LONG;\r
+ }\r
+#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1\r
+#endif // 0\r
\r
- last_pause = irmp_pause_time;\r
- break;\r
- } // switch\r
+ ANALYZE_PUTCHAR (manchester_value + '0');\r
+ ANALYZE_NEWLINE ();\r
+ irmp_store_bit (manchester_value);\r
+ }\r
\r
- wait_for_space = 0;\r
+ last_pause = irmp_pause_time;\r
+ wait_for_space = 0;\r
}\r
else\r
-#endif // IRMP_SUPPORT_RC6_PROTOCOL == 1\r
+#endif // IRMP_SUPPORT_MANCHESTER == 1\r
+\r
\r
#if IRMP_SUPPORT_SAMSUNG_PROTOCOL == 1\r
if (irmp_param.protocol == IRMP_SAMSUNG_PROTOCOL && irmp_bit == 16) // Samsung: 16th bit\r
if (irmp_pulse_time >= SAMSUNG_PULSE_LEN_MIN && irmp_pulse_time <= SAMSUNG_PULSE_LEN_MAX &&\r
irmp_pause_time >= SAMSUNG_START_BIT_PAUSE_LEN_MIN && irmp_pause_time <= SAMSUNG_START_BIT_PAUSE_LEN_MAX)\r
{\r
- DEBUG_PRINTF ("SYNC\n");\r
+ ANALYZE_PRINTF ("SYNC\n");\r
wait_for_space = 0;\r
irmp_tmp_id = 0;\r
irmp_bit++;\r
\r
if (irmp_pause_time >= SAMSUNG_1_PAUSE_LEN_MIN && irmp_pause_time <= SAMSUNG_1_PAUSE_LEN_MAX)\r
{\r
- DEBUG_PUTCHAR ('1');\r
- DEBUG_PUTCHAR ('\n');\r
+ ANALYZE_PUTCHAR ('1');\r
+ ANALYZE_NEWLINE ();\r
irmp_store_bit (1);\r
wait_for_space = 0;\r
}\r
else\r
{\r
- DEBUG_PUTCHAR ('0');\r
- DEBUG_PUTCHAR ('\n');\r
+ ANALYZE_PUTCHAR ('0');\r
+ ANALYZE_NEWLINE ();\r
irmp_store_bit (0);\r
wait_for_space = 0;\r
}\r
\r
- DEBUG_PRINTF ("Switching to SAMSUNG32 protocol\n");\r
+ ANALYZE_PRINTF ("Switching to SAMSUNG32 protocol\n");\r
}\r
else\r
{ // timing incorrect!\r
- DEBUG_PRINTF ("error 3 Samsung: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_PRINTF ("error 3 Samsung: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');\r
irmp_start_bit_detected = 0; // reset flags and wait for next start bit\r
irmp_pause_time = 0;\r
}\r
{\r
if (irmp_pause_time >= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_START_BIT3_PAUSE_LEN_MAX)\r
{\r
- DEBUG_PRINTF ("3rd start bit\n");\r
+ ANALYZE_PRINTF ("3rd start bit\n");\r
wait_for_space = 0;\r
irmp_tmp_id = 0;\r
irmp_bit++;\r
}\r
else\r
{ // timing incorrect!\r
- DEBUG_PRINTF ("error 3a B&O: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ 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);\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');\r
irmp_start_bit_detected = 0; // reset flags and wait for next start bit\r
irmp_pause_time = 0;\r
}\r
{\r
if (irmp_pause_time >= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_TRAILER_BIT_PAUSE_LEN_MAX)\r
{\r
- DEBUG_PRINTF ("trailer bit\n");\r
+ ANALYZE_PRINTF ("trailer bit\n");\r
wait_for_space = 0;\r
irmp_tmp_id = 0;\r
irmp_bit++;\r
}\r
else\r
{ // timing incorrect!\r
- DEBUG_PRINTF ("error 3b B&O: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ 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);\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');\r
irmp_start_bit_detected = 0; // reset flags and wait for next start bit\r
irmp_pause_time = 0;\r
}\r
{\r
if (irmp_pause_time >= BANG_OLUFSEN_1_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_1_PAUSE_LEN_MAX)\r
{ // pulse & pause timings correct for "1"?\r
- DEBUG_PUTCHAR ('1');\r
- DEBUG_PUTCHAR ('\n');\r
+ ANALYZE_PUTCHAR ('1');\r
+ ANALYZE_NEWLINE ();\r
irmp_store_bit (1);\r
last_value = 1;\r
wait_for_space = 0;\r
}\r
else if (irmp_pause_time >= BANG_OLUFSEN_0_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_0_PAUSE_LEN_MAX)\r
{ // pulse & pause timings correct for "0"?\r
- DEBUG_PUTCHAR ('0');\r
- DEBUG_PUTCHAR ('\n');\r
+ ANALYZE_PUTCHAR ('0');\r
+ ANALYZE_NEWLINE ();\r
irmp_store_bit (0);\r
last_value = 0;\r
wait_for_space = 0;\r
}\r
else if (irmp_pause_time >= BANG_OLUFSEN_R_PAUSE_LEN_MIN && irmp_pause_time <= BANG_OLUFSEN_R_PAUSE_LEN_MAX)\r
{\r
- DEBUG_PUTCHAR (last_value + '0');\r
- DEBUG_PUTCHAR ('\n');\r
+ ANALYZE_PUTCHAR (last_value + '0');\r
+ ANALYZE_NEWLINE ();\r
irmp_store_bit (last_value);\r
wait_for_space = 0;\r
}\r
else\r
{ // timing incorrect!\r
- DEBUG_PRINTF ("error 3c B&O: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ 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);\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');\r
irmp_start_bit_detected = 0; // reset flags and wait for next start bit\r
irmp_pause_time = 0;\r
}\r
}\r
else\r
{ // timing incorrect!\r
- DEBUG_PRINTF ("error 3d B&O: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ 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);\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');\r
irmp_start_bit_detected = 0; // reset flags and wait for next start bit\r
irmp_pause_time = 0;\r
}\r
if (irmp_pulse_time >= irmp_param.pulse_1_len_min && irmp_pulse_time <= irmp_param.pulse_1_len_max &&\r
irmp_pause_time >= irmp_param.pause_1_len_min && irmp_pause_time <= irmp_param.pause_1_len_max)\r
{ // pulse & pause timings correct for "1"?\r
- DEBUG_PUTCHAR ('1');\r
- DEBUG_PUTCHAR ('\n');\r
+ ANALYZE_PUTCHAR ('1');\r
+ ANALYZE_NEWLINE ();\r
irmp_store_bit (1);\r
wait_for_space = 0;\r
}\r
else if (irmp_pulse_time >= irmp_param.pulse_0_len_min && irmp_pulse_time <= irmp_param.pulse_0_len_max &&\r
irmp_pause_time >= irmp_param.pause_0_len_min && irmp_pause_time <= irmp_param.pause_0_len_max)\r
{ // pulse & pause timings correct for "0"?\r
- DEBUG_PUTCHAR ('0');\r
- DEBUG_PUTCHAR ('\n');\r
+ ANALYZE_PUTCHAR ('0');\r
+ ANALYZE_NEWLINE ();\r
irmp_store_bit (0);\r
wait_for_space = 0;\r
}\r
else\r
{ // timing incorrect!\r
- DEBUG_PRINTF ("error 3: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_PRINTF ("error 3: timing not correct: data bit %d, pulse: %d, pause: %d\n", irmp_bit, irmp_pulse_time, irmp_pause_time);\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');\r
irmp_start_bit_detected = 0; // reset flags and wait for next start bit\r
irmp_pause_time = 0;\r
}\r
// if SIRCS protocol and the code will be repeated within 50 ms, we will ignore 2nd and 3rd repetition frame\r
if (irmp_param.protocol == IRMP_SIRCS_PROTOCOL && (repetition_frame_number == 1 || repetition_frame_number == 2))\r
{\r
- DEBUG_PRINTF ("code skipped: SIRCS auto repetition frame #%d, counter = %d, auto repetition len = %d\n",\r
+ ANALYZE_PRINTF ("code skipped: SIRCS auto repetition frame #%d, counter = %d, auto repetition len = %d\n",\r
repetition_frame_number + 1, repetition_counter, AUTO_FRAME_REPETITION_LEN);\r
repetition_counter = 0;\r
}\r
// if SAMSUNG32 protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame\r
if (irmp_param.protocol == IRMP_SAMSUNG32_PROTOCOL && (repetition_frame_number & 0x01))\r
{\r
- DEBUG_PRINTF ("code skipped: SAMSUNG32 auto repetition frame #%d, counter = %d, auto repetition len = %d\n",\r
+ ANALYZE_PRINTF ("code skipped: SAMSUNG32 auto repetition frame #%d, counter = %d, auto repetition len = %d\n",\r
repetition_frame_number + 1, repetition_counter, AUTO_FRAME_REPETITION_LEN);\r
repetition_counter = 0;\r
}\r
// if NUBERT protocol and the code will be repeated within 50 ms, we will ignore every 2nd frame\r
if (irmp_param.protocol == IRMP_NUBERT_PROTOCOL && (repetition_frame_number & 0x01))\r
{\r
- DEBUG_PRINTF ("code skipped: NUBERT auto repetition frame #%d, counter = %d, auto repetition len = %d\n",\r
+ ANALYZE_PRINTF ("code skipped: NUBERT auto repetition frame #%d, counter = %d, auto repetition len = %d\n",\r
repetition_frame_number + 1, repetition_counter, AUTO_FRAME_REPETITION_LEN);\r
repetition_counter = 0;\r
}\r
#endif\r
\r
{\r
- DEBUG_PRINTF ("code detected, length = %d\n", irmp_bit);\r
+ ANALYZE_PRINTF ("code detected, length = %d\n", irmp_bit);\r
irmp_ir_detected = TRUE;\r
\r
#if IRMP_SUPPORT_DENON_PROTOCOL == 1\r
}\r
else\r
{\r
- DEBUG_PRINTF ("waiting for inverted command repetition\n");\r
+ ANALYZE_PRINTF ("waiting for inverted command repetition\n");\r
irmp_ir_detected = FALSE;\r
last_irmp_denon_command = irmp_tmp_command;\r
}\r
#if IRMP_SUPPORT_GRUNDIG_PROTOCOL == 1\r
if (irmp_param.protocol == IRMP_GRUNDIG_PROTOCOL && irmp_tmp_command == 0x01ff)\r
{ // Grundig start frame?\r
- DEBUG_PRINTF ("Detected GRUNDIG start frame, ignoring it\n");\r
+ ANALYZE_PRINTF ("Detected GRUNDIG start frame, ignoring it\n");\r
irmp_ir_detected = FALSE;\r
}\r
else\r
#if IRMP_SUPPORT_NOKIA_PROTOCOL == 1\r
if (irmp_param.protocol == IRMP_NOKIA_PROTOCOL && irmp_tmp_address == 0x00ff && irmp_tmp_command == 0x00fe)\r
{ // Nokia start frame?\r
- DEBUG_PRINTF ("Detected NOKIA start frame, ignoring it\n");\r
+ ANALYZE_PRINTF ("Detected NOKIA start frame, ignoring it\n");\r
irmp_ir_detected = FALSE;\r
}\r
else\r
\r
repetition_counter = 0;\r
}\r
+ else\r
+ {\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR ('\n');\r
+ }\r
\r
irmp_start_bit_detected = 0; // and wait for next start bit\r
irmp_tmp_command = 0;\r
}\r
}\r
}\r
+ return (irmp_ir_detected);\r
}\r
\r
-#ifdef DEBUG\r
+#ifdef ANALYZE\r
\r
// main function - for unix/linux + windows only!\r
// AVR: see main.c!\r
// Compile it under linux with:\r
// cc irmp.c -o irmp\r
//\r
-// usage: ./irmp [-v|-s|-a|-p] < file\r
+// usage: ./irmp [-v|-s|-a|-l|-p] < file\r
+// options:\r
+// -v verbose\r
+// -s silent\r
+// -a analyze\r
+// -l list pulse/pauses\r
+// -p print timings\r
\r
static void\r
print_timings (void)\r
BANG_OLUFSEN_START_BIT4_PULSE_LEN_MIN, BANG_OLUFSEN_START_BIT4_PULSE_LEN_MAX, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MIN, BANG_OLUFSEN_START_BIT4_PAUSE_LEN_MAX);\r
printf ("GRUNDIG/NOKIA 1 %3d - %3d %3d - %3d\n",\r
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);\r
+ printf ("SIEMENS 1 %3d - %3d %3d - %3d\n",\r
+ SIEMENS_START_BIT_LEN_MIN, SIEMENS_START_BIT_LEN_MAX, SIEMENS_START_BIT_LEN_MIN, SIEMENS_START_BIT_LEN_MAX);\r
+ printf ("FDC 1 %3d - %3d %3d - %3d\n",\r
+ FDC_START_BIT_PULSE_LEN_MIN, FDC_START_BIT_PULSE_LEN_MAX, FDC_START_BIT_PAUSE_LEN_MIN, FDC_START_BIT_PAUSE_LEN_MAX);\r
+ printf ("RCCAR 1 %3d - %3d %3d - %3d\n",\r
+ RCCAR_START_BIT_PULSE_LEN_MIN, RCCAR_START_BIT_PULSE_LEN_MAX, RCCAR_START_BIT_PAUSE_LEN_MIN, RCCAR_START_BIT_PAUSE_LEN_MAX);\r
+}\r
+\r
+void\r
+print_spectrum (char * text, int * buf, int is_pulse)\r
+{\r
+ int i;\r
+ int j;\r
+ int min;\r
+ int max;\r
+ int max_value = 0;\r
+ int value;\r
+ int sum = 0;\r
+ int counter = 0;\r
+ double average = 0;\r
+ double tolerance;\r
+\r
+ puts ("-------------------------------------------------------------------------------");\r
+ printf ("%s:\n", text);\r
+\r
+ for (i = 0; i < 256; i++)\r
+ {\r
+ if (buf[i] > max_value)\r
+ {\r
+ max_value = buf[i];\r
+ }\r
+ }\r
+\r
+ for (i = 0; i < 100; i++)\r
+ {\r
+ if (buf[i] > 0)\r
+ {\r
+ printf ("%3d ", i);\r
+ value = (buf[i] * 60) / max_value;\r
+\r
+ for (j = 0; j < value; j++)\r
+ {\r
+ putchar ('o');\r
+ }\r
+ printf (" %d\n", buf[i]);\r
+\r
+ sum += i * buf[i];\r
+ counter += buf[i];\r
+ }\r
+ else\r
+ {\r
+ max = i - 1;\r
+\r
+ if (counter > 0)\r
+ {\r
+ average = (float) sum / (float) counter;\r
+\r
+ if (is_pulse)\r
+ {\r
+ printf ("pulse ");\r
+ }\r
+ else\r
+ {\r
+ printf ("pause ");\r
+ }\r
+\r
+ printf ("avg: %4.1f=%6.1f us, ", average, (1000000. * average) / (float) F_INTERRUPTS);\r
+ printf ("min: %2d=%6.1f us, ", min, (1000000. * min) / (float) F_INTERRUPTS);\r
+ printf ("max: %2d=%6.1f us, ", max, (1000000. * max) / (float) F_INTERRUPTS);\r
+\r
+ tolerance = (max - average);\r
+\r
+ if (average - min > tolerance)\r
+ {\r
+ tolerance = average - min;\r
+ }\r
+\r
+ tolerance = tolerance * 100 / average;\r
+ printf ("tol: %4.1f%%\n", tolerance);\r
+ }\r
+\r
+ counter = 0;\r
+ sum = 0;\r
+ min = i + 1;\r
+ }\r
+ }\r
}\r
\r
int\r
main (int argc, char ** argv)\r
{\r
int i;\r
- int verbose = FALSE;\r
int analyze = FALSE;\r
+ int list = FALSE;\r
int ch;\r
int last_ch = 0;\r
int pulse = 0;\r
int pause = 0;\r
\r
- int min_pulse_long = 100000;\r
- int max_pulse_long = 0;\r
- int sum_pulses_long = 0;\r
- int n_pulses_long = 0;\r
-\r
- int min_pulse_short = 100000;\r
- int max_pulse_short = 0;\r
- int sum_pulses_short = 0;\r
- int n_pulses_short = 0;\r
-\r
- int min_pause_long = 100000;\r
- int max_pause_long = 0;\r
- int sum_pauses_long = 0;\r
- int n_pauses_long = 0;\r
-\r
- int min_pause_short = 100000;\r
- int max_pause_short = 0;\r
- int sum_pauses_short = 0;\r
- int n_pauses_short = 0;\r
-\r
- int min_start_pulse = 100000;\r
- int max_start_pulse = 0;\r
- int sum_start_pulses = 0;\r
- int n_start_pulses = 0;\r
-\r
- int min_start_pause = 100000;\r
- int max_start_pause = 0;\r
- int sum_start_pauses = 0;\r
- int n_start_pauses = 0;\r
+ int start_pulses[256];\r
+ int start_pauses[256];\r
+ int pulses[256];\r
+ int pauses[256];\r
\r
int first_pulse = TRUE;\r
int first_pause = TRUE;\r
{\r
verbose = TRUE;\r
}\r
+ else if (! strcmp (argv[1], "-l"))\r
+ {\r
+ list = TRUE;\r
+ }\r
else if (! strcmp (argv[1], "-a"))\r
{\r
analyze = TRUE;\r
- verbose = TRUE;\r
}\r
else if (! strcmp (argv[1], "-s"))\r
{\r
}\r
}\r
\r
+ for (i = 0; i < 256; i++)\r
+ {\r
+ start_pulses[i] = 0;\r
+ start_pauses[i] = 0;\r
+ pulses[i] = 0;\r
+ pauses[i] = 0;\r
+ }\r
+\r
IRMP_PIN = 0xFF;\r
\r
while ((ch = getchar ()) != EOF)\r
{\r
if (last_ch != ch)\r
{\r
- if (verbose && pause > 0)\r
+ if (pause > 0)\r
{\r
- printf ("pause: %d\n", pause);\r
-\r
- if (first_pause)\r
+ if (list)\r
{\r
- if (min_start_pause > pause)\r
- {\r
- min_start_pause = pause;\r
- }\r
- if (max_start_pause < pause)\r
- {\r
- max_start_pause = pause;\r
- }\r
- n_start_pauses++;\r
- sum_start_pauses += pause;\r
- first_pause = FALSE;\r
+ printf ("pause: %d\n", pause);\r
}\r
- else\r
+\r
+ if (analyze)\r
{\r
- if (pause >= 10)\r
+ if (first_pause)\r
{\r
- if (pause > 100) // perhaps repetition frame follows\r
+ if (pause < 256)\r
{\r
- first_pulse = TRUE;\r
- first_pause = TRUE;\r
- }\r
- else\r
- {\r
- if (min_pause_long > pause)\r
- {\r
- min_pause_long = pause;\r
- }\r
- if (max_pause_long < pause)\r
- {\r
- max_pause_long = pause;\r
- }\r
- n_pauses_long++;\r
- sum_pauses_long += pause;\r
+ start_pauses[pause]++;\r
}\r
+ first_pause = FALSE;\r
}\r
else\r
{\r
- if (min_pause_short > pause)\r
+ if (pause < 256)\r
{\r
- min_pause_short = pause;\r
+ pauses[pause]++;\r
}\r
- if (max_pause_short < pause)\r
- {\r
- max_pause_short = pause;\r
- }\r
- n_pauses_short++;\r
- sum_pauses_short += pause;\r
}\r
}\r
}\r
{\r
if (last_ch != ch)\r
{\r
- if (verbose)\r
+ if (list)\r
{\r
printf ("pulse: %d ", pulse);\r
+ }\r
\r
+ if (analyze)\r
+ {\r
if (first_pulse)\r
{\r
- if (min_start_pulse > pulse)\r
+ if (pulse < 256)\r
{\r
- min_start_pulse = pulse;\r
+ start_pulses[pulse]++;\r
}\r
- if (max_start_pulse < pulse)\r
- {\r
- max_start_pulse = pulse;\r
- }\r
- n_start_pulses++;\r
- sum_start_pulses += pulse;\r
first_pulse = FALSE;\r
}\r
else\r
{\r
- if (pulse >= 10)\r
- {\r
- if (min_pulse_long > pulse)\r
- {\r
- min_pulse_long = pulse;\r
- }\r
- if (max_pulse_long < pulse)\r
- {\r
- max_pulse_long = pulse;\r
- }\r
- n_pulses_long++;\r
- sum_pulses_long += pulse;\r
- }\r
- else\r
+ if (pulse < 256)\r
{\r
- if (min_pulse_short > pulse)\r
- {\r
- min_pulse_short = pulse;\r
- }\r
- if (max_pulse_short < pulse)\r
- {\r
- max_pulse_short = pulse;\r
- }\r
- n_pulses_short++;\r
- sum_pulses_short += pulse;\r
+ pulses[pulse]++;\r
}\r
}\r
}\r
pulse = 0;\r
}\r
+\r
pause++;\r
IRMP_PIN = 0xff;\r
}\r
{\r
IRMP_PIN = 0xff;\r
\r
- if (verbose && pause > 0)\r
+ if (list && pause > 0)\r
{\r
printf ("pause: %d\n", pause);\r
}\r
\r
if (! analyze)\r
{\r
- for (i = 0; i < 8000; i++) // newline: long pause of 800 msec\r
+ for (i = 0; i < (int) ((8000.0 * F_INTERRUPTS) / 10000); i++) // newline: long pause of 800 msec\r
{\r
- irmp_ISR ();\r
+ (void) irmp_ISR ();\r
}\r
}\r
first_pulse = TRUE;\r
}\r
else if (ch == '#')\r
{\r
- puts ("-------------------------------------------------------------------");\r
- putchar (ch);\r
-\r
- while ((ch = getchar()) != '\n' && ch != EOF)\r
+ if (analyze)\r
{\r
- if (ch != '\r') // ignore CR in DOS/Windows files\r
+ while ((ch = getchar()) != '\n' && ch != EOF)\r
{\r
- putchar (ch);\r
+ ;\r
}\r
}\r
- putchar ('\n');\r
+ else\r
+ {\r
+ puts ("-------------------------------------------------------------------");\r
+ putchar (ch);\r
+\r
+ while ((ch = getchar()) != '\n' && ch != EOF)\r
+ {\r
+ if (ch != '\r') // ignore CR in DOS/Windows files\r
+ {\r
+ putchar (ch);\r
+ }\r
+ }\r
+ putchar ('\n');\r
+ }\r
+\r
}\r
\r
last_ch = ch;\r
\r
- if (! analyze)\r
+ if (! analyze && ! list)\r
{\r
- irmp_ISR ();\r
- }\r
+ (void) irmp_ISR ();\r
\r
- if (irmp_get_data (&irmp_data))\r
- {\r
- printf ("protcol = %d, address = 0x%04x, code = 0x%04x, flags = 0x%02x\n",\r
- irmp_data.protocol, irmp_data.address, irmp_data.command, irmp_data.flags);\r
+ if (irmp_get_data (&irmp_data))\r
+ {\r
+ ANALYZE_ONLY_NORMAL_PUTCHAR (' ');\r
+ printf ("p = %2d, a = 0x%04x, c = 0x%04x, f = 0x%02x\n",\r
+ irmp_data.protocol, irmp_data.address, irmp_data.command, irmp_data.flags);\r
+ }\r
}\r
}\r
\r
if (analyze)\r
{\r
- printf ("\nSTATITSTICS:\n");\r
- printf ("---------------------------------\n");\r
- printf ("number of start pulses: %d\n", n_start_pulses);\r
- printf ("minimum start pulse length: %d usec\n", (1000000 * min_start_pulse) / F_INTERRUPTS);\r
- printf ("maximum start pulse length: %d usec\n", (1000000 * max_start_pulse) / F_INTERRUPTS);\r
- if (n_start_pulses > 0)\r
- {\r
- printf ("average start pulse length: %d usec\n", ((1000000 * sum_start_pulses) / n_start_pulses) / F_INTERRUPTS);\r
- }\r
- putchar ('\n');\r
- printf ("number of start pauses: %d\n", n_start_pauses);\r
- if (n_start_pauses > 0)\r
- {\r
- printf ("minimum start pause length: %d usec\n", (1000000 * min_start_pause) / F_INTERRUPTS);\r
- printf ("maximum start pause length: %d usec\n", (1000000 * max_start_pause) / F_INTERRUPTS);\r
- printf ("average start pause length: %d usec\n", ((1000000 * sum_start_pauses) / n_start_pauses) / F_INTERRUPTS);\r
- }\r
- putchar ('\n');\r
- printf ("number of long pulses: %d\n", n_pulses_long);\r
- if (n_pulses_long > 0)\r
- {\r
- printf ("minimum long pulse length: %d usec\n", (1000000 * min_pulse_long) / F_INTERRUPTS);\r
- printf ("maximum long pulse length: %d usec\n", (1000000 * max_pulse_long) / F_INTERRUPTS);\r
- printf ("average long pulse length: %d usec\n", ((1000000 * sum_pulses_long) / n_pulses_long) / F_INTERRUPTS);\r
- }\r
- putchar ('\n');\r
- printf ("number of short pulses: %d\n", n_pulses_short);\r
- if (n_pulses_short > 0)\r
- {\r
- printf ("minimum short pulse length: %d usec\n", (1000000 * min_pulse_short) / F_INTERRUPTS);\r
- printf ("maximum short pulse length: %d usec\n", (1000000 * max_pulse_short) / F_INTERRUPTS);\r
- printf ("average short pulse length: %d usec\n", ((1000000 * sum_pulses_short) / n_pulses_short) / F_INTERRUPTS);\r
-\r
- }\r
- putchar ('\n');\r
- printf ("number of long pauses: %d\n", n_pauses_long);\r
- if (n_pauses_long > 0)\r
- {\r
- printf ("minimum long pause length: %d usec\n", (1000000 * min_pause_long) / F_INTERRUPTS);\r
- printf ("maximum long pause length: %d usec\n", (1000000 * max_pause_long) / F_INTERRUPTS);\r
- printf ("average long pause length: %d usec\n", ((1000000 * sum_pauses_long) / n_pauses_long) / F_INTERRUPTS);\r
- }\r
- putchar ('\n');\r
- printf ("number of short pauses: %d\n", n_pauses_short);\r
- if (n_pauses_short > 0)\r
- {\r
- printf ("minimum short pause length: %d usec\n", (1000000 * min_pause_short) / F_INTERRUPTS);\r
- printf ("maximum short pause length: %d usec\n", (1000000 * max_pause_short) / F_INTERRUPTS);\r
- printf ("average short pause length: %d usec\n", ((1000000 * sum_pauses_short) / n_pauses_short) / F_INTERRUPTS);\r
- }\r
+ print_spectrum ("START PULSES", start_pulses, TRUE);\r
+ print_spectrum ("START PAUSES", start_pauses, FALSE);\r
+ print_spectrum ("PULSES", pulses, TRUE);\r
+ print_spectrum ("PAUSES", pauses, FALSE);\r
+ puts ("-------------------------------------------------------------------------------");\r
}\r
return 0;\r
}\r
\r
-#endif // DEBUG\r
+#endif // ANALYZE\r
projects / irmp.git / blobdiff