irmpprotocols.h

   1 /*---------------------------------------------------------------------------------------------------------------------------------------------------
   2  * irmpprotocols.h - irmp protocols
   3  *
   4  * DO NOT INCLUDE THIS FILE, WILL BE INCLUDED BY IRMP.H or IRSND.H!
   5  *
   6  * Copyright (c) 2013-2015 Frank Meyer - frank(at)fli4l.de
   7  *
   8  * $Id: irmpprotocols.h,v 1.36 2015/06/15 10:30:10 fm Exp $
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *---------------------------------------------------------------------------------------------------------------------------------------------------
  15  */
  16
  17 #ifndef _IRMP_PROTOCOLS_H_
  18 #define _IRMP_PROTOCOLS_H_
  19
  20 #if !defined(_IRMP_H_) && !defined(_IRSND_H_)
  21 #  error please include only irmp.h or irsnd.h, not irmpprotocols.h
  22 #endif
  23
  24 /*---------------------------------------------------------------------------------------------------------------------------------------------------
  25  * IR protocols:
  26  *---------------------------------------------------------------------------------------------------------------------------------------------------
  27  */
  28 #define IRMP_SIRCS_PROTOCOL                      1              // Sony
  29 #define IRMP_NEC_PROTOCOL                        2              // NEC, Pioneer, JVC, Toshiba, NoName etc.
  30 #define IRMP_SAMSUNG_PROTOCOL                    3              // Samsung
  31 #define IRMP_MATSUSHITA_PROTOCOL                 4              // Matsushita
  32 #define IRMP_KASEIKYO_PROTOCOL                   5              // Kaseikyo (Panasonic etc)
  33 #define IRMP_RECS80_PROTOCOL                     6              // Philips, Thomson, Nordmende, Telefunken, Saba
  34 #define IRMP_RC5_PROTOCOL                        7              // Philips etc
  35 #define IRMP_DENON_PROTOCOL                      8              // Denon, Sharp
  36 #define IRMP_RC6_PROTOCOL                        9              // Philips etc
  37 #define IRMP_SAMSUNG32_PROTOCOL                 10              // Samsung32: no sync pulse at bit 16, length 32 instead of 37
  38 #define IRMP_APPLE_PROTOCOL                     11              // Apple, very similar to NEC
  39 #define IRMP_RECS80EXT_PROTOCOL                 12              // Philips, Technisat, Thomson, Nordmende, Telefunken, Saba
  40 #define IRMP_NUBERT_PROTOCOL                    13              // Nubert
  41 #define IRMP_BANG_OLUFSEN_PROTOCOL              14              // Bang & Olufsen
  42 #define IRMP_GRUNDIG_PROTOCOL                   15              // Grundig
  43 #define IRMP_NOKIA_PROTOCOL                     16              // Nokia
  44 #define IRMP_SIEMENS_PROTOCOL                   17              // Siemens, e.g. Gigaset
  45 #define IRMP_FDC_PROTOCOL                       18              // FDC keyboard
  46 #define IRMP_RCCAR_PROTOCOL                     19              // RC Car
  47 #define IRMP_JVC_PROTOCOL                       20              // JVC (NEC with 16 bits)
  48 #define IRMP_RC6A_PROTOCOL                      21              // RC6A, e.g. Kathrein, XBOX
  49 #define IRMP_NIKON_PROTOCOL                     22              // Nikon
  50 #define IRMP_RUWIDO_PROTOCOL                    23              // Ruwido, e.g. T-Home Mediareceiver
  51 #define IRMP_IR60_PROTOCOL                      24              // IR60 (SDA2008)
  52 #define IRMP_KATHREIN_PROTOCOL                  25              // Kathrein
  53 #define IRMP_NETBOX_PROTOCOL                    26              // Netbox keyboard (bitserial)
  54 #define IRMP_NEC16_PROTOCOL                     27              // NEC with 16 bits (incl. sync)
  55 #define IRMP_NEC42_PROTOCOL                     28              // NEC with 42 bits
  56 #define IRMP_LEGO_PROTOCOL                      29              // LEGO Power Functions RC
  57 #define IRMP_THOMSON_PROTOCOL                   30              // Thomson
  58 #define IRMP_BOSE_PROTOCOL                      31              // BOSE
  59 #define IRMP_A1TVBOX_PROTOCOL                   32              // A1 TV Box
  60 #define IRMP_ORTEK_PROTOCOL                     33              // ORTEK - Hama
  61 #define IRMP_TELEFUNKEN_PROTOCOL                34              // Telefunken (1560)
  62 #define IRMP_ROOMBA_PROTOCOL                    35              // iRobot Roomba vacuum cleaner
  63 #define IRMP_RCMM32_PROTOCOL                    36              // Fujitsu-Siemens (Activy remote control)
  64 #define IRMP_RCMM24_PROTOCOL                    37              // Fujitsu-Siemens (Activy keyboard)
  65 #define IRMP_RCMM12_PROTOCOL                    38              // Fujitsu-Siemens (Activy keyboard)
  66 #define IRMP_SPEAKER_PROTOCOL                   39              // Another loudspeaker protocol, similar to Nubert
  67 #define IRMP_LGAIR_PROTOCOL                     40              // LG air conditioner
  68 #define IRMP_SAMSUNG48_PROTOCOL                 41              // air conditioner with SAMSUNG protocol (48 bits)
  69 #define IRMP_MERLIN_PROTOCOL                    42              // Merlin (Pollin 620 185)
  70 #define IRMP_PENTAX_PROTOCOL                    43              // Pentax camera
  71 #define IRMP_FAN_PROTOCOL                       44              // FAN (ventilator), very similar to NUBERT, but last bit is data bit instead of stop bit
  72 #define IRMP_S100_PROTOCOL                      45              // very similar to RC5, but 14 instead of 13 data bits
  73 #define IRMP_ACP24_PROTOCOL                     46              // Stiebel Eltron ACP24 air conditioner
  74 #define IRMP_RADIO1_PROTOCOL                    47              // Radio protocol (experimental status), do not use it yet!
  75
  76 #define IRMP_N_PROTOCOLS                        47              // number of supported protocols
  77
  78 /*---------------------------------------------------------------------------------------------------------------------------------------------------
  79  * timing constants:
  80  *---------------------------------------------------------------------------------------------------------------------------------------------------
  81  */
  82 // fm 22.09.2011: may not be more than 16000L, otherwise some JVC codes will not be accepted
  83 #define IRMP_TIMEOUT_TIME                       15500.0e-6                  // timeout after 15.5 ms darkness
  84 #define IRMP_TIMEOUT_TIME_MS                    15500L                      // timeout after 15.5 ms darkness
  85
  86 #if IRMP_SUPPORT_NIKON_PROTOCOL == 1
  87 #  define IRMP_TIMEOUT_NIKON_TIME               29500.0e-6                  // 2nd timeout after 29.5 ms darkness (only for NIKON!)
  88 #  define IRMP_TIMEOUT_NIKON_TIME_MS            29500L                      // 2nd timeout after 29.5 ms darkness
  89 typedef uint16_t    PAUSE_LEN;
  90 #  define IRMP_TIMEOUT_NIKON_LEN                (PAUSE_LEN)(F_INTERRUPTS * IRMP_TIMEOUT_NIKON_TIME + 0.5)
  91 #else
  92 #  if (F_INTERRUPTS * IRMP_TIMEOUT_TIME_MS) / 1000000 >= 254
  93 typedef uint16_t    PAUSE_LEN;
  94 #  else
  95 typedef uint8_t     PAUSE_LEN;
  96 #  endif
  97 #endif
  98
  99 #define IRMP_TIMEOUT_LEN                        (PAUSE_LEN)(F_INTERRUPTS * IRMP_TIMEOUT_TIME + 0.5)
 100
 101 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 102  * flags of struct IRMP_PARAMETER:
 103  *---------------------------------------------------------------------------------------------------------------------------------------------------
 104  */
 105 #define IRMP_PARAM_FLAG_IS_MANCHESTER           0x01
 106 #define IRMP_PARAM_FLAG_1ST_PULSE_IS_1          0x02
 107 #define IRMP_PARAM_FLAG_IS_SERIAL               0x04
 108
 109 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 110  * SIRCS:
 111  *---------------------------------------------------------------------------------------------------------------------------------------------------
 112  */
 113 #define SIRCS_START_BIT_PULSE_TIME              2400.0e-6                       // 2400 usec pulse
 114 #define SIRCS_START_BIT_PAUSE_TIME               600.0e-6                       //  600 usec pause
 115 #define SIRCS_1_PULSE_TIME                      1200.0e-6                       // 1200 usec pulse
 116 #define SIRCS_0_PULSE_TIME                       600.0e-6                       //  600 usec pulse
 117 #define SIRCS_PAUSE_TIME                         600.0e-6                       //  600 usec pause
 118 #define SIRCS_FRAMES                            3                               // SIRCS sends each frame 3 times
 119 #define SIRCS_AUTO_REPETITION_PAUSE_TIME          25.0e-3                       // auto repetition after 25ms
 120 #define SIRCS_FRAME_REPEAT_PAUSE_TIME             25.0e-3                       // frame repeat after 25ms
 121 #define SIRCS_ADDRESS_OFFSET                    15                              // skip 15 bits
 122 #define SIRCS_ADDRESS_LEN                       5                               // read up to 5 address bits
 123 #define SIRCS_COMMAND_OFFSET                    0                               // skip 0 bits
 124 #define SIRCS_COMMAND_LEN                       15                              // read 12-15 command bits
 125 #define SIRCS_MINIMUM_DATA_LEN                  12                              // minimum data length
 126 #define SIRCS_COMPLETE_DATA_LEN                 20                              // complete length - may be up to 20
 127 #define SIRCS_STOP_BIT                          0                               // has no stop bit
 128 #define SIRCS_LSB                               1                               // LSB...MSB
 129 #define SIRCS_FLAGS                             0                               // flags
 130
 131 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 132  * NEC & NEC42 & NEC16 & LGAIR:
 133  *---------------------------------------------------------------------------------------------------------------------------------------------------
 134  */
 135 #define NEC_START_BIT_PULSE_TIME                9000.0e-6                       // 9000 usec pulse
 136 #define NEC_START_BIT_PAUSE_TIME                4500.0e-6                       // 4500 usec pause
 137 #define NEC_REPEAT_START_BIT_PAUSE_TIME         2250.0e-6                       // 2250 usec pause
 138 #define NEC_PULSE_TIME                           560.0e-6                       //  560 usec pulse
 139 #define NEC_1_PAUSE_TIME                        1690.0e-6                       // 1690 usec pause
 140 #define NEC_0_PAUSE_TIME                         560.0e-6                       //  560 usec pause
 141 #define NEC_FRAME_REPEAT_PAUSE_TIME               40.0e-3                       // frame repeat after 40ms
 142 #define NEC_ADDRESS_OFFSET                       0                              // skip 0 bits
 143 #define NEC_ADDRESS_LEN                         16                              // read 16 address bits
 144 #define NEC_COMMAND_OFFSET                      16                              // skip 16 bits (8 address + 8 /address)
 145 #define NEC_COMMAND_LEN                         16                              // read 16 bits (8 command + 8 /command)
 146 #define NEC_COMPLETE_DATA_LEN                   32                              // complete length
 147 #define NEC_STOP_BIT                            1                               // has stop bit
 148 #define NEC_LSB                                 1                               // LSB...MSB
 149 #define NEC_FLAGS                               0                               // flags
 150
 151 #define NEC42_ADDRESS_OFFSET                    0                               // skip 0 bits
 152 #define NEC42_ADDRESS_LEN                      13                               // read 13 address bits
 153 #define NEC42_COMMAND_OFFSET                   26                               // skip 26 bits (2 x 13 address bits)
 154 #define NEC42_COMMAND_LEN                       8                               // read 8 command bits
 155 #define NEC42_COMPLETE_DATA_LEN                42                               // complete length (2 x 13 + 2 x 8)
 156
 157 #define LGAIR_ADDRESS_OFFSET                    0                               // skip 0 bits
 158 #define LGAIR_ADDRESS_LEN                       8                               // read 8 address bits
 159 #define LGAIR_COMMAND_OFFSET                    8                               // skip 8 bits (8 address)
 160 #define LGAIR_COMMAND_LEN                      16                               // read 16 bits (16 command)
 161 #define LGAIR_COMPLETE_DATA_LEN                28                               // complete length (8 address + 16 command + 4 checksum)
 162
 163 #define NEC16_ADDRESS_OFFSET                    0                               // skip 0 bits
 164 #define NEC16_ADDRESS_LEN                       8                               // read 8 address bits
 165 #define NEC16_COMMAND_OFFSET                    8                               // skip 8 bits (8 address)
 166 #define NEC16_COMMAND_LEN                       8                               // read 8 bits (8 command)
 167 #define NEC16_COMPLETE_DATA_LEN                 16                              // complete length
 168
 169 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 170  * SAMSUNG & SAMSUNG32 & SAMSUNG48:
 171  *---------------------------------------------------------------------------------------------------------------------------------------------------
 172  */
 173 #define SAMSUNG_START_BIT_PULSE_TIME            4500.0e-6                       // 4500 usec pulse
 174 #define SAMSUNG_START_BIT_PAUSE_TIME            4500.0e-6                       // 4500 usec pause
 175 #define SAMSUNG_PULSE_TIME                       550.0e-6                       //  550 usec pulse
 176 #define SAMSUNG_1_PAUSE_TIME                    1500.0e-6                       // 1550 usec pause
 177 #define SAMSUNG_0_PAUSE_TIME                     500.0e-6                       //  500 usec pause
 178
 179 #define SAMSUNG_FRAME_REPEAT_PAUSE_TIME           25.0e-3                       // frame repeat after 25ms
 180 #define SAMSUNG_ADDRESS_OFFSET                   0                              // skip 0 bits
 181 #define SAMSUNG_ADDRESS_LEN                     16                              // read 16 address bits
 182 #define SAMSUNG_ID_OFFSET                       17                              // skip 16 + 1 sync bit
 183 #define SAMSUNG_ID_LEN                          4                               // read 4 id bits
 184 #define SAMSUNG_COMMAND_OFFSET                  21                              // skip 16 + 1 sync + 4 data bits
 185 #define SAMSUNG_COMMAND_LEN                     16                              // read 16 command bits
 186 #define SAMSUNG_COMPLETE_DATA_LEN               37                              // complete length
 187 #define SAMSUNG_STOP_BIT                        1                               // has stop bit
 188 #define SAMSUNG_LSB                             1                               // LSB...MSB?
 189 #define SAMSUNG_FLAGS                           0                               // flags
 190
 191 #define SAMSUNG32_COMMAND_OFFSET                16                              // skip 16 bits
 192 #define SAMSUNG32_COMMAND_LEN                   16                              // read 16 command bits
 193 #define SAMSUNG32_COMPLETE_DATA_LEN             32                              // complete length
 194 #define SAMSUNG32_FRAMES                        2                               // SAMSUNG32 sends each frame 2 times // fm: correct?
 195 #define SAMSUNG32_AUTO_REPETITION_PAUSE_TIME    47.0e-3                         // repetition after 47 ms
 196 #define SAMSUNG32_FRAME_REPEAT_PAUSE_TIME       47.0e-3                         // frame repeat after 47ms
 197
 198 #define SAMSUNG48_COMMAND_OFFSET                16                              // skip 16 bits
 199 #define SAMSUNG48_COMMAND_LEN                   32                              // read 32 command bits
 200 #define SAMSUNG48_COMPLETE_DATA_LEN             48                              // complete length
 201 #define SAMSUNG48_FRAMES                        2                               // SAMSUNG48 sends each frame 2 times
 202 #define SAMSUNG48_AUTO_REPETITION_PAUSE_TIME    5.0e-3                          // repetition after 5 ms
 203 #define SAMSUNG48_FRAME_REPEAT_PAUSE_TIME       47.0e-3                         // frame repeat after 47ms
 204
 205 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 206  * MATSUSHITA:
 207  *---------------------------------------------------------------------------------------------------------------------------------------------------
 208  */
 209 #define MATSUSHITA_START_BIT_PULSE_TIME         3488.0e-6                       // 3488 usec pulse
 210 #define MATSUSHITA_START_BIT_PAUSE_TIME         3488.0e-6                       // 3488 usec pause
 211 #define MATSUSHITA_PULSE_TIME                    872.0e-6                       //  872 usec pulse
 212 #define MATSUSHITA_1_PAUSE_TIME                 2616.0e-6                       // 2616 usec pause
 213 #define MATSUSHITA_0_PAUSE_TIME                  872.0e-6                       //  872 usec pause
 214 #define MATSUSHITA_FRAME_REPEAT_PAUSE_TIME        40.0e-3                       // frame repeat after 40ms
 215 #define MATSUSHITA_ADDRESS_OFFSET               12                              // skip 12 bits
 216 #define MATSUSHITA_ADDRESS_LEN                  12                              // read 12 address bits
 217 #define MATSUSHITA_COMMAND_OFFSET               0                               // skip 0 bits
 218 #define MATSUSHITA_COMMAND_LEN                  12                              // read 12 bits (6 custom + 6 command)
 219 #define MATSUSHITA_COMPLETE_DATA_LEN            24                              // complete length
 220 #define MATSUSHITA_STOP_BIT                     1                               // has stop bit
 221 #define MATSUSHITA_LSB                          1                               // LSB...MSB?
 222 #define MATSUSHITA_FLAGS                        0                               // flags
 223
 224 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 225  * KASEIKYO:
 226  *---------------------------------------------------------------------------------------------------------------------------------------------------
 227  */
 228 #define KASEIKYO_START_BIT_PULSE_TIME           3380.0e-6                       // 3380 usec pulse
 229 #define KASEIKYO_START_BIT_PAUSE_TIME           1690.0e-6                       // 1690 usec pause
 230 #define KASEIKYO_PULSE_TIME                      423.0e-6                       //  525 usec pulse
 231 #define KASEIKYO_1_PAUSE_TIME                   1269.0e-6                       //  525 usec pause
 232 #define KASEIKYO_0_PAUSE_TIME                    423.0e-6                       // 1690 usec pause
 233 #define KASEIKYO_AUTO_REPETITION_PAUSE_TIME       74.0e-3                       // repetition after 74 ms
 234 #define KASEIKYO_FRAME_REPEAT_PAUSE_TIME          74.0e-3                       // frame repeat after 74 ms
 235 #define KASEIKYO_ADDRESS_OFFSET                  0                              // skip 0 bits
 236 #define KASEIKYO_ADDRESS_LEN                    16                              // read 16 address bits
 237 #define KASEIKYO_COMMAND_OFFSET                 28                              // skip 28 bits (16 manufacturer & 4 parity & 8 genre)
 238 #define KASEIKYO_COMMAND_LEN                    12                              // read 12 command bits (10 real command & 2 id)
 239 #define KASEIKYO_COMPLETE_DATA_LEN              48                              // complete length
 240 #define KASEIKYO_STOP_BIT                       1                               // has stop bit
 241 #define KASEIKYO_LSB                            1                               // LSB...MSB?
 242 #define KASEIKYO_FRAMES                         2                               // KASEIKYO sends 1st frame 2 times
 243 #define KASEIKYO_FLAGS                          0                               // flags
 244
 245 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 246  * RECS80:
 247  *---------------------------------------------------------------------------------------------------------------------------------------------------
 248  */
 249 #define RECS80_START_BIT_PULSE_TIME              158.0e-6                       //  158 usec pulse
 250 #define RECS80_START_BIT_PAUSE_TIME             7432.0e-6                       // 7432 usec pause
 251 #define RECS80_PULSE_TIME                        158.0e-6                       //  158 usec pulse
 252 #define RECS80_1_PAUSE_TIME                     7432.0e-6                       // 7432 usec pause
 253 #define RECS80_0_PAUSE_TIME                     4902.0e-6                       // 4902 usec pause
 254 #define RECS80_FRAME_REPEAT_PAUSE_TIME            45.0e-3                       // frame repeat after 45ms
 255 #define RECS80_ADDRESS_OFFSET                   1                               // skip 1 bit (toggle bit)
 256 #define RECS80_ADDRESS_LEN                      3                               // read 3 address bits
 257 #define RECS80_COMMAND_OFFSET                   4                               // skip 4 bits (1 toggle + 3 address)
 258 #define RECS80_COMMAND_LEN                      6                               // read 6 command bits
 259 #define RECS80_COMPLETE_DATA_LEN                10                              // complete length
 260 #define RECS80_STOP_BIT                         1                               // has stop bit
 261 #define RECS80_LSB                              0                               // MSB...LSB
 262 #define RECS80_FLAGS                            0                               // flags
 263
 264 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 265  * RC5:
 266  *---------------------------------------------------------------------------------------------------------------------------------------------------
 267  */
 268 #define RC5_BIT_TIME                             889.0e-6                       // 889 usec pulse/pause
 269 #define RC5_FRAME_REPEAT_PAUSE_TIME               88.9e-3                       // frame repeat after 88.9ms
 270
 271 #define RC5_ADDRESS_OFFSET                      1                               // skip 1 bit (2nd start)
 272 #define RC5_ADDRESS_LEN                         6                               // read 1 toggle bit (for key repetition detection) + 5 address bits
 273 #define RC5_COMMAND_OFFSET                      7                               // skip 5 bits (2nd start + 1 toggle + 5 address)
 274 #define RC5_COMMAND_LEN                         6                               // read 6 command bits
 275 #define RC5_COMPLETE_DATA_LEN                   13                              // complete length
 276 #define RC5_STOP_BIT                            0                               // has no stop bit
 277 #define RC5_LSB                                 0                               // MSB...LSB
 278 #define RC5_FLAGS                               IRMP_PARAM_FLAG_IS_MANCHESTER   // flags
 279
 280 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 281  * S100: very similar to RC5, but 14 insted of 13 bits
 282  *---------------------------------------------------------------------------------------------------------------------------------------------------
 283  */
 284 #define S100_BIT_TIME                             889.0e-6                       // 889 usec pulse/pause
 285 #define S100_FRAME_REPEAT_PAUSE_TIME               88.9e-3                       // frame repeat after 88.9ms
 286
 287 #define S100_ADDRESS_OFFSET                      1                               // skip 1 bit (2nd start)
 288 #define S100_ADDRESS_LEN                         6                               // read 1 toggle bit (for key repetition detection) + 5 address bits
 289 #define S100_COMMAND_OFFSET                      7                               // skip 5 bits (2nd start + 1 toggle + 5 address)
 290 #define S100_COMMAND_LEN                         7                               // read 7 command bits
 291 #define S100_COMPLETE_DATA_LEN                   14                              // complete length
 292 #define S100_STOP_BIT                            0                               // has no stop bit
 293 #define S100_LSB                                 0                               // MSB...LSB
 294 #define S100_FLAGS                               IRMP_PARAM_FLAG_IS_MANCHESTER   // flags
 295
 296 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 297  * DENON:
 298  *---------------------------------------------------------------------------------------------------------------------------------------------------
 299  */
 300 #define DENON_PULSE_TIME                         310.0e-6                       //  310 usec pulse in practice,  275 in theory
 301 #define DENON_1_PAUSE_TIME                      1780.0e-6                       // 1780 usec pause in practice, 1900 in theory
 302 #define DENON_0_PAUSE_TIME                       745.0e-6                       //  745 usec pause in practice,  775 in theory
 303 #define DENON_FRAMES                            2                               // DENON sends each frame 2 times
 304 #define DENON_AUTO_REPETITION_PAUSE_TIME          65.0e-3                       // inverted repetition after 65ms
 305 #define DENON_FRAME_REPEAT_PAUSE_TIME            130.0e-3                       // frame repeat after 2 * 65ms
 306 #define DENON_ADDRESS_OFFSET                    0                               // skip 0 bits
 307 #define DENON_ADDRESS_LEN                       5                               // read 5 address bits
 308 #define DENON_COMMAND_OFFSET                    5                               // skip 5
 309 #define DENON_COMMAND_LEN                       10                              // read 10 command bits
 310 #define DENON_COMPLETE_DATA_LEN                 15                              // complete length
 311 #define DENON_STOP_BIT                          1                               // has stop bit
 312 #define DENON_LSB                               0                               // MSB...LSB
 313 #define DENON_FLAGS                             0                               // flags
 314
 315 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 316  * RC6:
 317  *---------------------------------------------------------------------------------------------------------------------------------------------------
 318  */
 319 #define RC6_START_BIT_PULSE_TIME                2666.0e-6                       // 2.666 msec pulse
 320 #define RC6_START_BIT_PAUSE_TIME                 889.0e-6                       // 889 usec pause
 321 #define RC6_TOGGLE_BIT_TIME                      889.0e-6                       // 889 msec pulse/pause
 322 #define RC6_BIT_TIME                             444.0e-6                       // 889 usec pulse/pause
 323 #define RC6_FRAME_REPEAT_PAUSE_TIME               45.0e-3                       // frame repeat after 45ms
 324 #define RC6_ADDRESS_OFFSET                      5                               // skip "1" + 3 mode bits + 1 toggle bit
 325 #define RC6_ADDRESS_LEN                         8                               // read 8 address bits
 326 #define RC6_COMMAND_OFFSET                      13                              // skip 12 bits ("1" + 3 mode + 1 toggle + 8 address)
 327 #define RC6_COMMAND_LEN                         8                               // read 8 command bits
 328 #define RC6_COMPLETE_DATA_LEN_SHORT             21                              // complete length
 329 #define RC6_COMPLETE_DATA_LEN_LONG              36                              // complete length
 330 #define RC6_STOP_BIT                            0                               // has no stop bit
 331 #define RC6_LSB                                 0                               // MSB...LSB
 332 #define RC6_FLAGS                               (IRMP_PARAM_FLAG_IS_MANCHESTER | IRMP_PARAM_FLAG_1ST_PULSE_IS_1)   // flags
 333
 334 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 335  * RECS80EXT:
 336  *---------------------------------------------------------------------------------------------------------------------------------------------------
 337  */
 338 #define RECS80EXT_START_BIT_PULSE_TIME           158.0e-6                       //  158 usec pulse
 339 #define RECS80EXT_START_BIT_PAUSE_TIME          3637.0e-6                       // 3637 usec pause
 340 #define RECS80EXT_PULSE_TIME                     158.0e-6                       //  158 usec pulse
 341 #define RECS80EXT_1_PAUSE_TIME                  7432.0e-6                       // 7432 usec pause
 342 #define RECS80EXT_0_PAUSE_TIME                  4902.0e-6                       // 4902 usec pause
 343 #define RECS80EXT_FRAME_REPEAT_PAUSE_TIME         45.0e-3                       // frame repeat after 45ms
 344 #define RECS80EXT_ADDRESS_OFFSET                2                               // skip 2 bits (2nd start + 1 toggle)
 345 #define RECS80EXT_ADDRESS_LEN                   4                               // read 4 address bits
 346 #define RECS80EXT_COMMAND_OFFSET                6                               // skip 6 bits (2nd start + 1 toggle + 4 address)
 347 #define RECS80EXT_COMMAND_LEN                   6                               // read 6 command bits
 348 #define RECS80EXT_COMPLETE_DATA_LEN             12                              // complete length
 349 #define RECS80EXT_STOP_BIT                      1                               // has stop bit
 350 #define RECS80EXT_LSB                           0                               // MSB...LSB
 351 #define RECS80EXT_FLAGS                         0                               // flags
 352
 353 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 354  * NUBERT:
 355  *---------------------------------------------------------------------------------------------------------------------------------------------------
 356  */
 357 #define NUBERT_START_BIT_PULSE_TIME             1340.0e-6                       // 1340 usec pulse
 358 #define NUBERT_START_BIT_PAUSE_TIME              340.0e-6                       //  340 usec pause
 359 #define NUBERT_1_PULSE_TIME                     1340.0e-6                       // 1340 usec pulse
 360 #define NUBERT_1_PAUSE_TIME                      340.0e-6                       //  340 usec pause
 361 #define NUBERT_0_PULSE_TIME                      500.0e-6                       //  500 usec pulse
 362 #define NUBERT_0_PAUSE_TIME                     1300.0e-6                       // 1300 usec pause
 363 #define NUBERT_FRAMES                           2                               // Nubert sends 2 frames
 364 #define NUBERT_AUTO_REPETITION_PAUSE_TIME         35.0e-3                       // auto repetition after 35ms
 365 #define NUBERT_FRAME_REPEAT_PAUSE_TIME            35.0e-3                       // frame repeat after 45ms
 366 #define NUBERT_ADDRESS_OFFSET                   0                               // skip 0 bits
 367 #define NUBERT_ADDRESS_LEN                      0                               // read 0 address bits
 368 #define NUBERT_COMMAND_OFFSET                   0                               // skip 0 bits
 369 #define NUBERT_COMMAND_LEN                      10                              // read 10 bits
 370 #define NUBERT_COMPLETE_DATA_LEN                10                              // complete length
 371 #define NUBERT_STOP_BIT                         1                               // has stop bit
 372 #define NUBERT_LSB                              0                               // MSB?
 373 #define NUBERT_FLAGS                            0                               // flags
 374
 375 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 376  * FAN: (ventilator)
 377  *
 378  * Similar to NUBERT, but
 379  *   - has data bit instead of stop bit
 380  *   - has NO frame repetition
 381  *---------------------------------------------------------------------------------------------------------------------------------------------------
 382  */
 383 #define FAN_START_BIT_PULSE_TIME                1280.0e-6                       // 1280 usec pulse
 384 #define FAN_START_BIT_PAUSE_TIME                 380.0e-6                       //  380 usec pause
 385 #define FAN_1_PULSE_TIME                        1280.0e-6                       // 1280 usec pulse
 386 #define FAN_1_PAUSE_TIME                         380.0e-6                       //  380 usec pause
 387 #define FAN_0_PULSE_TIME                         380.0e-6                       //  380 usec pulse
 388 #define FAN_0_PAUSE_TIME                        1280.0e-6                       // 1280 usec pause
 389 #define FAN_FRAMES                              1                               // FAN sends only 1 frame (NUBERT sends 2)
 390 #define FAN_AUTO_REPETITION_PAUSE_TIME            6.6e-3                        // auto repetition after 6.6ms
 391 #define FAN_FRAME_REPEAT_PAUSE_TIME               6.6e-3                        // frame repeat after 6.6ms
 392 #define FAN_ADDRESS_OFFSET                      0                               // skip 0 bits
 393 #define FAN_ADDRESS_LEN                         0                               // read 0 address bits
 394 #define FAN_COMMAND_OFFSET                      0                               // skip 0 bits
 395 #define FAN_COMMAND_LEN                         11                              // read 10 bits
 396 #define FAN_COMPLETE_DATA_LEN                   11                              // complete length
 397 #define FAN_STOP_BIT                            0                               // has NO stop bit
 398 #define FAN_LSB                                 0                               // MSB
 399 #define FAN_FLAGS                               0                               // flags
 400
 401 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 402  * SPEAKER:
 403  *---------------------------------------------------------------------------------------------------------------------------------------------------
 404  */
 405 #define SPEAKER_START_BIT_PULSE_TIME             440.0e-6                       //  440 usec pulse
 406 #define SPEAKER_START_BIT_PAUSE_TIME            1250.0e-6                       // 1250 usec pause
 407 #define SPEAKER_1_PULSE_TIME                    1250.0e-6                       // 1250 usec pulse
 408 #define SPEAKER_1_PAUSE_TIME                     440.0e-6                       //  440 usec pause
 409 #define SPEAKER_0_PULSE_TIME                     440.0e-6                       //  440 usec pulse
 410 #define SPEAKER_0_PAUSE_TIME                    1250.0e-6                       // 1250 usec pause
 411 #define SPEAKER_FRAMES                          2                               // SPEAKER sends 2 frames
 412 #define SPEAKER_AUTO_REPETITION_PAUSE_TIME        35.0e-3                       // auto repetition after 35ms
 413 #define SPEAKER_FRAME_REPEAT_PAUSE_TIME           35.0e-3                       // frame repeat after 45ms
 414 #define SPEAKER_ADDRESS_OFFSET                  0                               // skip 0 bits
 415 #define SPEAKER_ADDRESS_LEN                     0                               // read 0 address bits
 416 #define SPEAKER_COMMAND_OFFSET                  0                               // skip 0 bits
 417 #define SPEAKER_COMMAND_LEN                     10                              // read 10 bits
 418 #define SPEAKER_COMPLETE_DATA_LEN               10                              // complete length
 419 #define SPEAKER_STOP_BIT                        1                               // has stop bit
 420 #define SPEAKER_LSB                             0                               // MSB?
 421 #define SPEAKER_FLAGS                           0                               // flags
 422
 423 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 424  * BANG_OLUFSEN:
 425  *---------------------------------------------------------------------------------------------------------------------------------------------------
 426  */
 427 #define BANG_OLUFSEN_START_BIT1_PULSE_TIME       200.0e-6                       //   200 usec pulse
 428 #define BANG_OLUFSEN_START_BIT1_PAUSE_TIME      3125.0e-6                       //  3125 usec pause
 429 #define BANG_OLUFSEN_START_BIT2_PULSE_TIME       200.0e-6                       //   200 usec pulse
 430 #define BANG_OLUFSEN_START_BIT2_PAUSE_TIME      3125.0e-6                       //  3125 usec pause
 431 #define BANG_OLUFSEN_START_BIT3_PULSE_TIME       200.0e-6                       //   200 usec pulse
 432 #define BANG_OLUFSEN_START_BIT3_PAUSE_TIME     15625.0e-6                       // 15625 usec pause
 433 #define BANG_OLUFSEN_START_BIT4_PULSE_TIME       200.0e-6                       //   200 usec pulse
 434 #define BANG_OLUFSEN_START_BIT4_PAUSE_TIME      3125.0e-6                       //  3125 usec pause
 435 #define BANG_OLUFSEN_PULSE_TIME                  200.0e-6                       //   200 usec pulse
 436 #define BANG_OLUFSEN_1_PAUSE_TIME               9375.0e-6                       //  9375 usec pause
 437 #define BANG_OLUFSEN_0_PAUSE_TIME               3125.0e-6                       //  3125 usec pause
 438 #define BANG_OLUFSEN_R_PAUSE_TIME               6250.0e-6                       //  6250 usec pause (repeat last bit)
 439 #define BANG_OLUFSEN_TRAILER_BIT_PAUSE_TIME    12500.0e-6                       // 12500 usec pause (trailer bit)
 440 #define BANG_OLUFSEN_FRAME_REPEAT_PAUSE_TIME      45.0e-3                       // frame repeat after 45ms
 441 #define BANG_OLUFSEN_ADDRESS_OFFSET             0                               // no address bits
 442 #define BANG_OLUFSEN_ADDRESS_LEN                0                               // no address bits
 443 #define BANG_OLUFSEN_COMMAND_OFFSET             3                               // skip startbits 2, 3, 4
 444 #define BANG_OLUFSEN_COMMAND_LEN                16                              // read 16 command bits
 445 #define BANG_OLUFSEN_COMPLETE_DATA_LEN          20                              // complete length: startbits 2, 3, 4 + 16 data bits + trailer bit
 446 #define BANG_OLUFSEN_STOP_BIT                   1                               // has stop bit
 447 #define BANG_OLUFSEN_LSB                        0                               // MSB...LSB
 448 #define BANG_OLUFSEN_FLAGS                      0                               // flags
 449
 450 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 451  * GRUNDIG & NOKIA
 452  *---------------------------------------------------------------------------------------------------------------------------------------------------
 453  */
 454 #define GRUNDIG_NOKIA_IR60_BIT_TIME             528.0e-6                        // 528 usec pulse/pause
 455 #define GRUNDIG_NOKIA_IR60_PRE_PAUSE_TIME       2639.0e-6                       // 2639 usec pause after pre bit
 456 #define GRUNDIG_NOKIA_IR60_FRAME_REPEAT_PAUSE_TIME  117.76e-3                   // info frame repeat after 117.76 ms
 457 #define GRUNDIG_NOKIA_IR60_STOP_BIT             0                               // has no stop bit
 458 #define GRUNDIG_NOKIA_IR60_LSB                  1                               // MSB...LSB
 459 #define GRUNDIG_NOKIA_IR60_FLAGS                (IRMP_PARAM_FLAG_IS_MANCHESTER | IRMP_PARAM_FLAG_1ST_PULSE_IS_1)  // flags
 460
 461 #define GRUNDIG_FRAMES                          2                               // GRUNDIG sends each frame 1+1 times
 462 #define GRUNDIG_AUTO_REPETITION_PAUSE_TIME      20.0e-3                         // repetition after 20ms
 463 #define GRUNDIG_ADDRESS_OFFSET                  0                               // no address
 464 #define GRUNDIG_ADDRESS_LEN                     0                               // no address
 465 #define GRUNDIG_COMMAND_OFFSET                  1                               // skip 1 start bit
 466 #define GRUNDIG_COMMAND_LEN                     9                               // read 9 command bits
 467 #define GRUNDIG_COMPLETE_DATA_LEN               10                              // complete length: 1 start bit + 9 data bits
 468
 469 #define NOKIA_FRAMES                            3                               // NOKIA sends each frame 1 + 1 + 1 times
 470 #define NOKIA_AUTO_REPETITION_PAUSE_TIME        20.0e-3                         // repetition after 20ms
 471 #define NOKIA_ADDRESS_OFFSET                    9                               // skip 9 bits (1 start bit + 8 data bits)
 472 #define NOKIA_ADDRESS_LEN                       8                               // 7 address bits
 473 #define NOKIA_COMMAND_OFFSET                    1                               // skip 1 bit (1 start bit)
 474 #define NOKIA_COMMAND_LEN                       8                               // read 8 command bits
 475 #define NOKIA_COMPLETE_DATA_LEN                 17                              // complete length: 1 start bit + 8 address bits + 8 command bits
 476
 477 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 478  * IR60:
 479  *---------------------------------------------------------------------------------------------------------------------------------------------------
 480  */
 481 #define IR60_FRAMES                             2                               // IR60 sends each frame 1+1 times
 482 #define IR60_AUTO_REPETITION_PAUSE_TIME         22.2e-3                         // repetition after 22.2ms
 483 #define IR60_TIMEOUT_TIME                       5000.0e-6                       // timeout grundig frame, switch to IR60
 484 #define IR60_ADDRESS_OFFSET                     0                               // skip 1 bits
 485 #define IR60_ADDRESS_LEN                        0                               // read 0 address bits
 486 #define IR60_COMMAND_OFFSET                     0                               // skip 1 bit (start bit after pre bit, always 1)
 487 #define IR60_COMMAND_LEN                        7                               // read 6 command bits
 488 #define IR60_COMPLETE_DATA_LEN                  7                               // complete length
 489
 490 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 491  * SIEMENS & RUWIDO:
 492  *---------------------------------------------------------------------------------------------------------------------------------------------------
 493  */
 494
 495 #if 0
 496 #define SIEMENS_OR_RUWIDO_START_BIT_PULSE_TIME    275.0e-6                      //  275 usec pulse
 497 #define SIEMENS_OR_RUWIDO_START_BIT_PAUSE_TIME    550.0e-6                      //  550 usec pause
 498 #define SIEMENS_OR_RUWIDO_BIT_PULSE_TIME          275.0e-6                      //  275 usec short pulse
 499 #define SIEMENS_OR_RUWIDO_BIT_PULSE_TIME_2        550.0e-6                      //  550 usec long pulse
 500 #define SIEMENS_OR_RUWIDO_BIT_PAUSE_TIME          275.0e-6                      //  275 usec short pause
 501 #define SIEMENS_OR_RUWIDO_BIT_PAUSE_TIME_2        550.0e-6                      //  550 usec long pause
 502 #else
 503 #define SIEMENS_OR_RUWIDO_START_BIT_PULSE_TIME    370.0e-6                      //  370 usec pulse
 504 #define SIEMENS_OR_RUWIDO_START_BIT_PAUSE_TIME    550.0e-6                      //  550 usec pause
 505 #define SIEMENS_OR_RUWIDO_BIT_PULSE_TIME          370.0e-6                      //  370 usec short pulse
 506 #define SIEMENS_OR_RUWIDO_BIT_PULSE_TIME_2        680.0e-6                      //  680 usec long pulse
 507 #define SIEMENS_OR_RUWIDO_BIT_PAUSE_TIME          275.0e-6                      //  275 usec short pause
 508 #define SIEMENS_OR_RUWIDO_BIT_PAUSE_TIME_2        550.0e-6                      //  550 usec long pause
 509 #endif
 510
 511 #define SIEMENS_OR_RUWIDO_FRAME_REPEAT_PAUSE_TIME 45.0e-3                       // frame repeat after 45ms
 512 #define SIEMENS_OR_RUWIDO_STOP_BIT                0                             // has no stop bit
 513 #define SIEMENS_OR_RUWIDO_LSB                     0                             // MSB...LSB
 514 #define SIEMENS_OR_RUWIDO_FLAGS                   (IRMP_PARAM_FLAG_IS_MANCHESTER | IRMP_PARAM_FLAG_1ST_PULSE_IS_1)  // flags
 515
 516 #define RUWIDO_ADDRESS_OFFSET                   0                               // skip 0 bits
 517 #define RUWIDO_ADDRESS_LEN                      9                               // read 9 address bits
 518 #define RUWIDO_COMMAND_OFFSET                   9                               // skip 9 bits
 519 #define RUWIDO_COMMAND_LEN                      8                               // read 7 + 1 command bits, last bit is only check bit
 520 #define RUWIDO_COMPLETE_DATA_LEN                17                              // complete length
 521
 522 #define SIEMENS_ADDRESS_OFFSET                  0                               // skip 0 bits
 523 #define SIEMENS_ADDRESS_LEN                     11                              // read 11 bits
 524 #define SIEMENS_COMMAND_OFFSET                  11                              // skip 11 bits
 525 #define SIEMENS_COMMAND_LEN                     11                              // read 10 + 1 command bits, last bit is only check bit
 526 #define SIEMENS_COMPLETE_DATA_LEN               22                              // complete length
 527
 528 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 529  * FDC:
 530  *---------------------------------------------------------------------------------------------------------------------------------------------------
 531  */
 532 #define FDC_START_BIT_PULSE_TIME                 2085.0e-6                      // 2085 usec pulse
 533 #define FDC_START_BIT_PAUSE_TIME                  966.0e-6                      //  966 usec pause
 534 #define FDC_PULSE_TIME                            300.0e-6                      //  300 usec pulse
 535 #define FDC_1_PAUSE_TIME                          715.0e-6                      //  715 usec pause
 536 #define FDC_0_PAUSE_TIME                          220.0e-6                      //  220 usec pause
 537 #define FDC_FRAME_REPEAT_PAUSE_TIME                60.0e-3                      // frame repeat after 60ms
 538 #define FDC_ADDRESS_OFFSET                       0                              // skip 0 bits
 539 #define FDC_ADDRESS_LEN                         14                              // read 14 address bits, but use only 6, shift 8 into command
 540 #define FDC_COMMAND_OFFSET                      20                              // skip 20 bits
 541 #define FDC_COMMAND_LEN                         12                              // read 12 bits
 542 #define FDC_COMPLETE_DATA_LEN                   40                              // complete length
 543 #define FDC_STOP_BIT                            1                               // has stop bit
 544 #define FDC_LSB                                 1                               // LSB...MSB
 545 #define FDC_FLAGS                               0                               // flags
 546
 547 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 548  * RCCAR:
 549  *---------------------------------------------------------------------------------------------------------------------------------------------------
 550  */
 551 #define RCCAR_START_BIT_PULSE_TIME               2000.0e-6                      // 2000 usec pulse
 552 #define RCCAR_START_BIT_PAUSE_TIME               2000.0e-6                      // 2000 usec pause
 553 #define RCCAR_PULSE_TIME                          600.0e-6                      //  360 usec pulse
 554 #define RCCAR_1_PAUSE_TIME                        450.0e-6                      //  650 usec pause
 555 #define RCCAR_0_PAUSE_TIME                        900.0e-6                      //  180 usec pause
 556 #define RCCAR_FRAME_REPEAT_PAUSE_TIME              40.0e-3                      // frame repeat after 40ms
 557 #define RCCAR_ADDRESS_OFFSET                     0                              // skip 0 bits
 558 #define RCCAR_ADDRESS_LEN                        0                              // read 0 address bits
 559 #define RCCAR_COMMAND_OFFSET                     0                              // skip 0 bits
 560 #define RCCAR_COMMAND_LEN                       13                              // read 13 bits
 561 #define RCCAR_COMPLETE_DATA_LEN                 13                              // complete length
 562 #define RCCAR_STOP_BIT                          1                               // has stop bit
 563 #define RCCAR_LSB                               1                               // LSB...MSB
 564 #define RCCAR_FLAGS                             0                               // flags
 565
 566 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 567  * JVC:
 568  *---------------------------------------------------------------------------------------------------------------------------------------------------
 569  */
 570 #define JVC_START_BIT_PULSE_TIME                9000.0e-6                       // 9000 usec pulse
 571 #define JVC_START_BIT_PAUSE_TIME                4500.0e-6                       // 4500 usec pause
 572 #define JVC_PULSE_TIME                           560.0e-6                       //  560 usec pulse
 573 #define JVC_1_PAUSE_TIME                        1690.0e-6                       // 1690 usec pause
 574 #define JVC_0_PAUSE_TIME                         560.0e-6                       //  560 usec pause
 575 #define JVC_FRAME_REPEAT_PAUSE_TIME               22.0e-3                       // frame repeat after 22ms
 576 #define JVC_ADDRESS_OFFSET                       0                              // skip 0 bits
 577 #define JVC_ADDRESS_LEN                          4                              // read 4 address bits
 578 #define JVC_COMMAND_OFFSET                       4                              // skip 4 bits
 579 #define JVC_COMMAND_LEN                         12                              // read 12 bits
 580 #define JVC_COMPLETE_DATA_LEN                   16                              // complete length
 581 #define JVC_STOP_BIT                            1                               // has stop bit
 582 #define JVC_LSB                                 1                               // LSB...MSB
 583 #define JVC_FLAGS                               0                               // flags
 584
 585 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 586  * NIKON:
 587  *---------------------------------------------------------------------------------------------------------------------------------------------------
 588  */
 589 #define NIKON_START_BIT_PULSE_TIME              2200.0e-6                       //  2200 usec pulse
 590 #define NIKON_START_BIT_PAUSE_TIME             27100.0e-6                       // 27100 usec pause
 591 #define NIKON_PULSE_TIME                         500.0e-6                       //   500 usec pulse
 592 #define NIKON_1_PAUSE_TIME                      3500.0e-6                       //  3500 usec pause
 593 #define NIKON_0_PAUSE_TIME                      1500.0e-6                       //  1500 usec pause
 594 #define NIKON_FRAME_REPEAT_PAUSE_TIME             60.0e-3                       // frame repeat after 60ms
 595 #define NIKON_ADDRESS_OFFSET                    0                               // skip 0 bits
 596 #define NIKON_ADDRESS_LEN                       0                               // read 0 address bits
 597 #define NIKON_COMMAND_OFFSET                    0                               // skip 0 bits
 598 #define NIKON_COMMAND_LEN                       2                               // read 2 bits
 599 #define NIKON_COMPLETE_DATA_LEN                 2                               // complete length
 600 #define NIKON_STOP_BIT                          1                               // has stop bit
 601 #define NIKON_LSB                               0                               // LSB...MSB
 602 #define NIKON_FLAGS                             0                               // flags
 603
 604 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 605  * KATHREIN:
 606  *---------------------------------------------------------------------------------------------------------------------------------------------------
 607  */
 608 #define KATHREIN_START_BIT_PULSE_TIME            210.0e-6                       // 1340 usec pulse
 609 #define KATHREIN_START_BIT_PAUSE_TIME           6218.0e-6                       //  340 usec pause
 610 #define KATHREIN_1_PULSE_TIME                    210.0e-6                       // 1340 usec pulse
 611 #define KATHREIN_1_PAUSE_TIME                   3000.0e-6                       //  340 usec pause
 612 #define KATHREIN_0_PULSE_TIME                    210.0e-6                       //  500 usec pulse
 613 #define KATHREIN_0_PAUSE_TIME                   1400.0e-6                       // 1300 usec pause
 614 #define KATHREIN_SYNC_BIT_PAUSE_LEN_TIME        4600.0e-6                       // 4600 usec sync (on 6th and/or 8th bit)
 615 #define KATHREIN_FRAMES                         1                               // Kathrein sends 1 frame
 616 #define KATHREIN_AUTO_REPETITION_PAUSE_TIME     35.0e-3                         // auto repetition after 35ms
 617 #define KATHREIN_FRAME_REPEAT_PAUSE_TIME        35.0e-3                         // frame repeat after 35ms
 618 #define KATHREIN_ADDRESS_OFFSET                 1                               // skip 1 bits
 619 #define KATHREIN_ADDRESS_LEN                    4                               // read 4 address bits
 620 #define KATHREIN_COMMAND_OFFSET                 5                               // skip 5 bits
 621 #define KATHREIN_COMMAND_LEN                    7                               // read 7 bits
 622 #define KATHREIN_COMPLETE_DATA_LEN              13                              // complete length
 623 #define KATHREIN_STOP_BIT                       1                               // has stop bit
 624 #define KATHREIN_LSB                            0                               // MSB
 625 #define KATHREIN_FLAGS                          0                               // flags
 626
 627 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 628  * NETBOX:
 629  *---------------------------------------------------------------------------------------------------------------------------------------------------
 630  */
 631 #define NETBOX_START_BIT_PULSE_TIME             2400.0e-6                       // 2400 usec pulse
 632 #define NETBOX_START_BIT_PAUSE_TIME              800.0e-6                       //  800 usec pause
 633 #define NETBOX_PULSE_TIME                        800.0e-6                       //  800 usec pulse
 634 #define NETBOX_PAUSE_TIME                        800.0e-6                       //  800 usec pause
 635 #define NETBOX_FRAMES                           1                               // Netbox sends 1 frame
 636 #define NETBOX_AUTO_REPETITION_PAUSE_TIME       35.0e-3                         // auto repetition after 35ms
 637 #define NETBOX_FRAME_REPEAT_PAUSE_TIME          35.0e-3                         // frame repeat after 35ms
 638 #define NETBOX_ADDRESS_OFFSET                   0                               // skip 0 bits
 639 #define NETBOX_ADDRESS_LEN                      3                               // read 3 address bits
 640 #define NETBOX_COMMAND_OFFSET                   3                               // skip 3 bits
 641 #define NETBOX_COMMAND_LEN                      13                              // read 13 bits
 642 #define NETBOX_COMPLETE_DATA_LEN                16                              // complete length
 643 #define NETBOX_STOP_BIT                         0                               // has no stop bit
 644 #define NETBOX_LSB                              1                               // LSB
 645 #define NETBOX_FLAGS                            IRMP_PARAM_FLAG_IS_SERIAL       // flags
 646
 647 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 648  * LEGO:
 649  *---------------------------------------------------------------------------------------------------------------------------------------------------
 650  */
 651 #define LEGO_START_BIT_PULSE_TIME                158.0e-6                       //  158 usec pulse ( 6 x 1/38kHz)
 652 #define LEGO_START_BIT_PAUSE_TIME               1026.0e-6                       // 1026 usec pause (39 x 1/38kHz)
 653 #define LEGO_PULSE_TIME                          158.0e-6                       //  158 usec pulse ( 6 x 1/38kHz)
 654 #define LEGO_1_PAUSE_TIME                        553.0e-6                       //  553 usec pause (21 x 1/38kHz)
 655 #define LEGO_0_PAUSE_TIME                        263.0e-6                       //  263 usec pause (10 x 1/38kHz)
 656 #define LEGO_FRAME_REPEAT_PAUSE_TIME              40.0e-3                       // frame repeat after 40ms
 657 #define LEGO_ADDRESS_OFFSET                     0                               // skip 0 bits
 658 #define LEGO_ADDRESS_LEN                        0                               // read 0 address bits
 659 #define LEGO_COMMAND_OFFSET                     0                               // skip 0 bits
 660 #define LEGO_COMMAND_LEN                        16                              // read 16 bits (12 command + 4 CRC)
 661 #define LEGO_COMPLETE_DATA_LEN                  16                              // complete length
 662 #define LEGO_STOP_BIT                           1                               // has stop bit
 663 #define LEGO_LSB                                0                               // MSB...LSB
 664 #define LEGO_FLAGS                              0                               // flags
 665
 666 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 667  * THOMSON:
 668  *---------------------------------------------------------------------------------------------------------------------------------------------------
 669  */
 670 #define THOMSON_PULSE_TIME                       550.0e-6                       //  550 usec pulse
 671 #define THOMSON_1_PAUSE_TIME                    4500.0e-6                       // 4500 usec pause
 672 #define THOMSON_0_PAUSE_TIME                    2000.0e-6                       // 2000 usec pause
 673 #define THOMSON_FRAMES                          1                               // THOMSON sends 1 frame
 674 #define THOMSON_AUTO_REPETITION_PAUSE_TIME        35.0e-3                       // repetition after 35ms
 675 #define THOMSON_FRAME_REPEAT_PAUSE_TIME           35.0e-3                       // frame repeat after 35ms
 676 #define THOMSON_ADDRESS_OFFSET                  0                               // skip 0 bits
 677 #define THOMSON_ADDRESS_LEN                     4                               // read 4 address bits
 678 #define THOMSON_COMMAND_OFFSET                  5                               // skip 4 address bits + 1 toggle bit
 679 #define THOMSON_COMMAND_LEN                     7                               // read 7 command bits
 680 #define THOMSON_COMPLETE_DATA_LEN               12                              // complete length
 681 #define THOMSON_STOP_BIT                        1                               // has stop bit
 682 #define THOMSON_LSB                             0                               // MSB...LSB
 683 #define THOMSON_FLAGS                           0                               // flags
 684
 685 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 686  * BOSE:
 687  *---------------------------------------------------------------------------------------------------------------------------------------------------
 688  */
 689 #define BOSE_START_BIT_PULSE_TIME               1060.0e-6                       // 1060 usec pulse
 690 #define BOSE_START_BIT_PAUSE_TIME               1425.0e-6                       // 1425 usec pause
 691 #define BOSE_PULSE_TIME                          550.0e-6                       //  550 usec pulse
 692 #define BOSE_1_PAUSE_TIME                       1425.0e-6                       // 1425 usec pause
 693 #define BOSE_0_PAUSE_TIME                        437.0e-6                       //  437 usec pause
 694 #define BOSE_FRAME_REPEAT_PAUSE_TIME              40.0e-3                       // frame repeat after 40ms???
 695 #define BOSE_ADDRESS_OFFSET                      0                              // skip 0 bits
 696 #define BOSE_ADDRESS_LEN                         0                              // read 16 address bits
 697 #define BOSE_COMMAND_OFFSET                      0                              // skip 16 bits (8 address + 8 /address)
 698 #define BOSE_COMMAND_LEN                        16                              // read 16 bits (8 command + 8 /command)
 699 #define BOSE_COMPLETE_DATA_LEN                  16                              // complete length
 700 #define BOSE_STOP_BIT                           1                               // has stop bit
 701 #define BOSE_LSB                                1                               // LSB...MSB
 702 #define BOSE_FLAGS                              0                               // flags
 703
 704 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 705  * A1TVBOX:
 706  * In reality A1 TV Box has no start bit with 300/340 usec. There are 2 start bits "10" with 250us pulse + 150us pause + 150us pause + 250us pulse
 707  * This is not very easy to detect, because 1st and 2nd pause of both start bits are closely spaced.
 708  * So IRMP looks for pseudo start bit with 300/340 usec and ignores the second half of the 2nd bit (250us pulse)
 709  * This method only works because the first data bit (which is the 3rd bit) following is always "1":
 710  * IRMP treats the first "long" pulse (250us of 2nd start bit + 250us of 1st data bit) of this "1" as a first _short_ pulse.
 711  * This is a bug in IRMP's manchester decoder, but a good feature here ;-)
 712  *---------------------------------------------------------------------------------------------------------------------------------------------------
 713  */
 714 #define A1TVBOX_START_BIT_PULSE_TIME            300.0e-6                        // 300 usec pulse
 715 #define A1TVBOX_START_BIT_PAUSE_TIME            340.0e-6                        // 340 usec pause
 716 #define A1TVBOX_BIT_PULSE_TIME                  250.0e-6                        // 250 usec pulse
 717 #define A1TVBOX_BIT_PAUSE_TIME                  150.0e-6                        // 150 usec pulse
 718 #define A1TVBOX_STOP_BIT                        0                               // has no stop bit
 719 #define A1TVBOX_LSB                             0                               // MSB...LSB
 720 #define A1TVBOX_FLAGS                           (IRMP_PARAM_FLAG_IS_MANCHESTER | IRMP_PARAM_FLAG_1ST_PULSE_IS_1 )  // flags
 721 #define A1TVBOX_FRAMES                          1                               // A1TVBOX sends each frame 1 times
 722 #define A1TVBOX_ADDRESS_OFFSET                  1                               // skip 1 bits
 723 #define A1TVBOX_ADDRESS_LEN                     8                               // read 8 address bits
 724 #define A1TVBOX_COMMAND_OFFSET                  9                               // skip 9 bits (start bit + address)
 725 #define A1TVBOX_COMMAND_LEN                     8                               // read 8 command bits
 726 #define A1TVBOX_COMPLETE_DATA_LEN               17                              // complete length incl. start bit
 727 #define A1TVBOX_FRAME_REPEAT_PAUSE_TIME         50.0e-3                         // 50 msec pause between frames, don't know if it is correct
 728
 729 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 730  * MERLIN:
 731  * See notes for A1TVBOX
 732  *---------------------------------------------------------------------------------------------------------------------------------------------------
 733  */
 734 #define MERLIN_START_BIT_PULSE_TIME            210.0e-6                         // 210 usec pulse
 735 #define MERLIN_START_BIT_PAUSE_TIME            420.0e-6                         // 429 usec pause
 736 #define MERLIN_BIT_PULSE_TIME                  210.0e-6                         // 210 usec pulse
 737 #define MERLIN_BIT_PAUSE_TIME                  210.0e-6                         // 210 usec pulse
 738 #define MERLIN_STOP_BIT                        0                                // has no stop bit
 739 #define MERLIN_LSB                             0                                // MSB...LSB
 740 #define MERLIN_FLAGS                           (IRMP_PARAM_FLAG_IS_MANCHESTER | IRMP_PARAM_FLAG_1ST_PULSE_IS_1 )  // flags
 741 #define MERLIN_FRAMES                          1                                // MERLIN sends each frame 1 times
 742 #define MERLIN_ADDRESS_OFFSET                  1                                // skip 1 bits
 743 #define MERLIN_ADDRESS_LEN                     8                                // read 8 address bits
 744 #define MERLIN_COMMAND_OFFSET                  8                                // skip 9 bits (start bit + address)
 745 #define MERLIN_COMMAND_LEN                     10                               // read 8 command bits
 746 #define MERLIN_COMPLETE_DATA_LEN               19                               // complete length incl. start bit
 747 #define MERLIN_FRAME_REPEAT_PAUSE_TIME         50.0e-3                          // 50 msec pause between frames, don't know if it is correct
 748
 749 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 750  * ORTEK (Hama): 6 address bits + 2 frame type bits + 6 command bits + 1 parity bit + 1 unknown bit + "1" + "0"
 751  *---------------------------------------------------------------------------------------------------------------------------------------------------
 752  */
 753 #define ORTEK_START_BIT_PULSE_TIME              2000.0e-6                       // 2000 usec pulse
 754 #define ORTEK_START_BIT_PAUSE_TIME              1000.0e-6                       // 1000 usec pause
 755 #define ORTEK_BIT_TIME                           500.0e-6                       //  500 usec pulse/pause
 756 #define ORTEK_FRAME_REPEAT_PAUSE_TIME             45.0e-3                       // frame repeat after 45ms
 757 #define ORTEK_ADDRESS_OFFSET                    0                               // skip 0 bits
 758 #define ORTEK_ADDRESS_LEN                       8                               // read 6 address bits + 2 special bits
 759 #define ORTEK_COMMAND_OFFSET                    8                               // skip 6 address bits + 2 special bits
 760 #define ORTEK_COMMAND_LEN                       6                               // read 6 command bits
 761 #define ORTEK_COMPLETE_DATA_LEN                 18                              // complete length
 762 #define ORTEK_STOP_BIT                          0                               // has no stop bit
 763 #define ORTEK_LSB                               0                               // MSB...LSB
 764 #define ORTEK_FLAGS                             (IRMP_PARAM_FLAG_IS_MANCHESTER | IRMP_PARAM_FLAG_1ST_PULSE_IS_1)   // flags
 765
 766 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 767  * TELEFUNKEN:
 768  *---------------------------------------------------------------------------------------------------------------------------------------------------
 769  */
 770 #define TELEFUNKEN_START_BIT_PULSE_TIME          600.0e-6                       //  600 usec pulse
 771 #define TELEFUNKEN_START_BIT_PAUSE_TIME         1500.0e-6                       // 1500 usec pause
 772 #define TELEFUNKEN_PULSE_TIME                    600.0e-6                       //  600 usec pulse
 773 #define TELEFUNKEN_1_PAUSE_TIME                 1500.0e-6                       // 1500 usec pause
 774 #define TELEFUNKEN_0_PAUSE_TIME                  600.0e-6                       //  600 usec pause
 775 #define TELEFUNKEN_FRAME_REPEAT_PAUSE_TIME        22.0e-3                       // frame repeat after XX ms ?????
 776 #define TELEFUNKEN_ADDRESS_OFFSET                0                              // skip 0 bits
 777 #define TELEFUNKEN_ADDRESS_LEN                   0                              // read 0 address bits
 778 #define TELEFUNKEN_COMMAND_OFFSET                0                              // skip 0 bits
 779 #define TELEFUNKEN_COMMAND_LEN                  15                              // read 15 bits
 780 #define TELEFUNKEN_COMPLETE_DATA_LEN            15                              // complete length
 781 #define TELEFUNKEN_STOP_BIT                     1                               // has stop bit
 782 #define TELEFUNKEN_LSB                          0                               // LSB...MSB
 783 #define TELEFUNKEN_FLAGS                        0                               // flags
 784
 785 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 786  * ROOMBA
 787  *---------------------------------------------------------------------------------------------------------------------------------------------------
 788  */
 789 #define ROOMBA_START_BIT_PULSE_TIME             2790.0e-6                       // 2790 usec pulse
 790 #define ROOMBA_START_BIT_PAUSE_TIME              930.0e-6                       //  930 usec pause
 791 #define ROOMBA_0_PULSE_TIME                      930.0e-6                       //  930 usec pulse
 792 #define ROOMBA_1_PULSE_TIME                     2790.0e-6                       // 2790 usec pulse
 793 #define ROOMBA_0_PAUSE_TIME                     2790.0e-6                       // 2790 usec pause
 794 #define ROOMBA_1_PAUSE_TIME                      930.0e-6                       //  930 usec pause
 795 #define ROOMBA_FRAME_REPEAT_PAUSE_TIME            18.0e-3                       // frame repeat after 18ms
 796 #define ROOMBA_ADDRESS_OFFSET                    0                              // skip 0 bits
 797 #define ROOMBA_ADDRESS_LEN                       0                              // read 0 address bits
 798 #define ROOMBA_COMMAND_OFFSET                    0                              // skip 0 bits
 799 #define ROOMBA_COMMAND_LEN                       7                              // read 7 bits
 800 #define ROOMBA_COMPLETE_DATA_LEN                 7                              // complete length
 801 #define ROOMBA_STOP_BIT                         0                               // has stop bit
 802 #define ROOMBA_LSB                              0                               // MSB...LSB
 803 #define ROOMBA_FLAGS                            0                               // flags
 804 #define ROOMBA_FRAMES                           8                               // ROOMBA sends 8 frames (this is a lie, but more comfortable)
 805
 806 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 807  * RC-MM (32, 24, or 12 bit)
 808  *---------------------------------------------------------------------------------------------------------------------------------------------------
 809  */
 810 #define RCMM32_START_BIT_PULSE_TIME              500.0e-6                       // 500 usec pulse
 811 #define RCMM32_START_BIT_PAUSE_TIME              220.0e-6                       // 220 usec pause
 812 #define RCMM32_PULSE_TIME                        230.0e-6                       // 230 usec pulse
 813 #define RCMM32_00_PAUSE_TIME                     220.0e-6                       // 220 usec pause
 814 #define RCMM32_01_PAUSE_TIME                     370.0e-6                       // 370 usec pause
 815 #define RCMM32_10_PAUSE_TIME                     540.0e-6                       // 540 usec pause
 816 #define RCMM32_11_PAUSE_TIME                     720.0e-6                       // 720 usec pause
 817
 818 #define RCMM32_FRAME_REPEAT_PAUSE_TIME            80.0e-3                       // frame repeat after 80 ms
 819 #define RCMM32_ADDRESS_OFFSET                    0                              // skip 0 bits
 820 #define RCMM32_ADDRESS_LEN                      16                              //  read 16 address bits
 821 #define RCMM32_COMMAND_OFFSET                   17                              // skip 17 bits
 822 #define RCMM32_COMMAND_LEN                      15                              // read 15 bits
 823 #define RCMM32_COMPLETE_DATA_LEN                32                              // complete length
 824 #define RCMM32_STOP_BIT                         1                               // has stop bit
 825 #define RCMM32_LSB                              0                               // LSB...MSB
 826 #define RCMM32_FLAGS                            0                               // flags
 827
 828 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 829  * PENTAX:
 830  *---------------------------------------------------------------------------------------------------------------------------------------------------
 831  */
 832 #define PENTAX_START_BIT_PULSE_TIME             13000.0e-6                      // 13 msec pulse
 833 #define PENTAX_START_BIT_PAUSE_TIME              3000.0e-6                      // 3 msec pause
 834 #define PENTAX_PULSE_TIME                        1000.0e-6                      // 1 msec pulse
 835 #define PENTAX_1_PAUSE_TIME                      3000.0e-6                      // 3 msec pause
 836 #define PENTAX_0_PAUSE_TIME                      1000.0e-6                      // 1 msec pause
 837 #define PENTAX_FRAME_REPEAT_PAUSE_TIME             60.0e-3                      // frame repeat after 60ms
 838 #define PENTAX_ADDRESS_OFFSET                  0                                // skip 0 bits
 839 #define PENTAX_ADDRESS_LEN                     0                                // read 0 address bits
 840 #define PENTAX_COMMAND_OFFSET                  0                                // skip 0 bits
 841 #define PENTAX_COMMAND_LEN                     6                                // read 6 bits
 842 #define PENTAX_COMPLETE_DATA_LEN               6                                // complete length
 843 #define PENTAX_STOP_BIT                        1                                // has stop bit
 844 #define PENTAX_LSB                             0                                // LSB...MSB
 845 #define PENTAX_FLAGS                           0                                // flags
 846
 847 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 848  * ACP24: Stiebel Eltron ACP24 air conditioner
 849  *---------------------------------------------------------------------------------------------------------------------------------------------------
 850  */
 851 #define ACP24_START_BIT_PULSE_TIME               390.0e-6                       //  390 usec pulse
 852 #define ACP24_START_BIT_PAUSE_TIME               950.0e-6                       //  950 usec pause
 853 #define ACP24_PULSE_TIME                         390.0e-6                       //  390 usec pulse
 854 #define ACP24_1_PAUSE_TIME                      1300.0e-6                       // 1300 usec pause
 855 #define ACP24_0_PAUSE_TIME                       950.0e-6                       //  950 usec pause
 856 #define ACP24_FRAME_REPEAT_PAUSE_TIME             22.0e-3                       // frame repeat after 22ms?
 857 #define ACP24_ADDRESS_OFFSET                     0                              // skip 0 bits
 858 #define ACP24_ADDRESS_LEN                        0                              // read 6 address bits
 859 #define ACP24_COMMAND_OFFSET                     0                              // skip 6 bits
 860 #define ACP24_COMMAND_LEN                        0                              // read 0 bits (70 bits will be read and compressed by special routine)
 861 #define ACP24_COMPLETE_DATA_LEN                 70                              // complete length
 862 #define ACP24_STOP_BIT                          1                               // has stop bit
 863 #define ACP24_LSB                               0                               // LSB...MSB
 864 #define ACP24_FLAGS                             0                               // flags
 865
 866 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 867  * RADIO1 - e.g. Tevion
 868  *---------------------------------------------------------------------------------------------------------------------------------------------------
 869  */
 870 #define RADIO1_START_BIT_PULSE_TIME            3000.0e-6                        // 3000 usec pulse
 871 #define RADIO1_START_BIT_PAUSE_TIME            7000.0e-6                        // 7000 usec pulse
 872 #define RADIO1_0_PULSE_TIME                     500.0e-6                        //  500 usec pulse
 873 #define RADIO1_0_PAUSE_TIME                    1000.0e-6                        // 1000 usec pause
 874 #define RADIO1_1_PULSE_TIME                    1000.0e-6                        // 1000 usec pulse
 875 #define RADIO1_1_PAUSE_TIME                     500.0e-6                        //  500 usec pause
 876
 877 #define RADIO1_FRAME_REPEAT_PAUSE_TIME           25.0e-3                        // frame repeat after 25ms
 878 #define RADIO1_ADDRESS_OFFSET                   4                               // skip 4 bits
 879 #define RADIO1_ADDRESS_LEN                     16                               // read 16 address bits
 880 #define RADIO1_COMMAND_OFFSET                  20                               // skip 4 + 16 bits
 881 #define RADIO1_COMMAND_LEN                      3                               // read 3 command bits
 882 #define RADIO1_COMPLETE_DATA_LEN               23                               // complete length
 883 #define RADIO1_STOP_BIT                        1                                // has stop bit
 884 #define RADIO1_LSB                             1                                // LSB...MSB?
 885 #define RADIO1_FLAGS                           0                                // flags
 886
 887 /*---------------------------------------------------------------------------------------------------------------------------------------------------
 888  * Frame Repetitions:
 889  *---------------------------------------------------------------------------------------------------------------------------------------------------
 890  */
 891 #define AUTO_FRAME_REPETITION_TIME              80.0e-3                         // SIRCS/SAMSUNG32/NUBERT: automatic repetition after 25-50ms
 892
 893 #endif // _IRMP_PROTOCOLS_H_