IRremote
ir_Kaseikyo.hpp
Go to the documentation of this file.
1 /*
2  * ir_Kaseikyo.hpp
3  *
4  * Contains functions for receiving and sending Kaseikyo/Panasonic IR Protocol in "raw" and standard format with 16 bit address + 8 bit command
5  *
6  * This file is part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.
7  *
8  ************************************************************************************
9  * MIT License
10  *
11  * Copyright (c) 2020-2022 Armin Joachimsmeyer
12  *
13  * Permission is hereby granted, free of charge, to any person obtaining a copy
14  * of this software and associated documentation files (the "Software"), to deal
15  * in the Software without restriction, including without limitation the rights
16  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
17  * copies of the Software, and to permit persons to whom the Software is furnished
18  * to do so, subject to the following conditions:
19  *
20  * The above copyright notice and this permission notice shall be included in all
21  * copies or substantial portions of the Software.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
24  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
25  * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
27  * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
28  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29  *
30  ************************************************************************************
31  */
32 #ifndef _IR_KASEIKYO_HPP
33 #define _IR_KASEIKYO_HPP
34 
35 #if defined(DEBUG) && !defined(LOCAL_DEBUG)
36 #define LOCAL_DEBUG
37 #else
38 //#define LOCAL_DEBUG // This enables debug output only for this file
39 #endif
40 
44 //==============================================================================
45 // PPPP AAA N N AAA SSSS OOO N N IIIII CCCC
46 // P P A A NN N A A S O O NN N I C
47 // PPPP AAAAA N N N AAAAA SSS O O N N N I C
48 // P A A N NN A A S O O N NN I C
49 // P A A N N A A SSSS OOO N N IIIII CCCC
50 //==============================================================================
51 /*
52 Protocol=Panasonic Address=0xFF1 Command=0x76 Raw-Data=0x9976FF10 48 bits LSB first
53  +3450,-1700
54  + 450,- 400 + 500,-1250 + 450,- 400 + 500,- 400
55  + 450,- 400 + 400,- 450 + 500,- 350 + 450,- 450
56  + 450,- 400 + 450,- 400 + 500,- 400 + 450,- 400
57  + 450,- 400 + 500,-1250 + 450,- 400 + 500,- 350
58  + 500,- 400 + 450,- 400 + 450,- 450 + 450,- 400
59  + 450,-1250 + 500,- 400 + 450,- 400 + 450,- 400
60  + 450,-1300 + 450,-1250 + 450,-1300 + 400,-1300
61  + 450,-1300 + 450,-1250 + 450,-1250 + 500,-1250
62  + 450,- 450 + 450,-1250 + 450,-1250 + 500,- 400
63  + 450,-1250 + 450,-1300 + 450,-1250 + 450,- 450
64  + 450,-1250 + 450,- 400 + 450,- 400 + 500,-1250
65  + 450,-1250 + 450,- 400 + 500,- 400 + 450,-1250
66  + 450
67 Sum: 64300
68  */
69 // http://www.hifi-remote.com/johnsfine/DecodeIR.html#Panasonic
70 // http://www.hifi-remote.com/johnsfine/DecodeIR.html#Kaseikyo
71 // The first two (8-bit) bytes contains the vendor code.
72 // There are multiple interpretations of the next fields:
73 // IRP: {37k,432}<1,-1|1,-3>(8,-4,M:8,N:8,X:4,D:4,S:8,F:8,G:8,1,-173)+ {X=M:4:0^M:4:4^N:4:0^N:4:4}
74 // 1. interpretation: After the vendor code, the next byte is 4 bit VendorID parity and 4 bit Device and Subdevice
75 // The 5th byte is the function and the last (6.th) byte is xor of the three bytes before it.
76 // 0_______ 1_______ 2______ 3_______ 4_______ 5
77 // 01234567 89ABCDEF 01234567 01234567 01234567 01234567
78 // 01000000 00100100 Dev____ Sub_Dev_ Fun____ XOR( B2, B3, B4) - showing Panasonic vendor code 0x2002
79 // see: http://www.remotecentral.com/cgi-bin/mboard/rc-pronto/thread.cgi?26152
80 //
81 // 2. interpretation: LSB first, start bit + 16 VendorID + 4 VendorID parity + 4 Genre1 + 4 Genre2 + 10 Command + 2 ID + 8 Parity + stop bit
82 // see: https://www.mikrocontroller.net/articles/IRMP_-_english#KASEIKYO
83 // 32 bit raw data LSB is VendorID parity.
84 //
85 // We reduce it to: IRP: {37k,432}<1,-1|1,-3>(8,-4,V:16,X:4,D:4,S:8,F:8,(X^D^S^F):8,1,-173)+ {X=M:4:0^M:4:4^N:4:0^N:4:4}
86 // start bit + 16 VendorID + 4 VendorID parity + 12 Address + 8 Command + 8 Parity of VendorID parity, Address and Command + stop bit
87 //
88 #define KASEIKYO_VENDOR_ID_BITS 16
89 #define KASEIKYO_VENDOR_ID_PARITY_BITS 4
90 #define KASEIKYO_ADDRESS_BITS 12
91 #define KASEIKYO_COMMAND_BITS 8
92 #define KASEIKYO_PARITY_BITS 8
93 #define KASEIKYO_BITS (KASEIKYO_VENDOR_ID_BITS + KASEIKYO_VENDOR_ID_PARITY_BITS + KASEIKYO_ADDRESS_BITS + KASEIKYO_COMMAND_BITS + KASEIKYO_PARITY_BITS) // 48
94 #define KASEIKYO_UNIT 432 // 16 pulses of 37 kHz (432,432432) - Pronto 0x70 | 0x10
95 
96 #define KASEIKYO_HEADER_MARK (8 * KASEIKYO_UNIT) // 3456
97 #define KASEIKYO_HEADER_SPACE (4 * KASEIKYO_UNIT) // 1728
98 
99 #define KASEIKYO_BIT_MARK KASEIKYO_UNIT
100 #define KASEIKYO_ONE_SPACE (3 * KASEIKYO_UNIT) // 1296
101 #define KASEIKYO_ZERO_SPACE KASEIKYO_UNIT
102 
103 #define KASEIKYO_AVERAGE_DURATION 56000
104 #define KASEIKYO_REPEAT_PERIOD 130000
105 #define KASEIKYO_REPEAT_DISTANCE (KASEIKYO_REPEAT_PERIOD - KASEIKYO_AVERAGE_DURATION) // 74 ms
106 
107 #define PANASONIC_VENDOR_ID_CODE 0x2002
108 #define DENON_VENDOR_ID_CODE 0x3254
109 #define MITSUBISHI_VENDOR_ID_CODE 0xCB23
110 #define SHARP_VENDOR_ID_CODE 0x5AAA
111 #define JVC_VENDOR_ID_CODE 0x0103
112 
116 
117 /************************************
118  * Start of send and decode functions
119  ************************************/
120 
124 void IRsend::sendKaseikyo(uint16_t aAddress, uint8_t aCommand, int_fast8_t aNumberOfRepeats, uint16_t aVendorCode) {
125  // Set IR carrier frequency
126  enableIROut (KASEIKYO_KHZ); // 37 kHz
127 
128  // Vendor Parity
129  uint8_t tVendorParity = aVendorCode ^ (aVendorCode >> 8);
130  tVendorParity = (tVendorParity ^ (tVendorParity >> 4)) & 0xF;
131 
132 #if __INT_WIDTH__ < 32
133  LongUnion tSendValue;
134  // Compute parity
135  tSendValue.UWord.LowWord = (aAddress << KASEIKYO_VENDOR_ID_PARITY_BITS) | tVendorParity; // set low nibble to parity
136  tSendValue.UBytes[2] = aCommand;
137  tSendValue.UBytes[3] = aCommand ^ tSendValue.UBytes[0] ^ tSendValue.UBytes[1]; // Parity
138  IRRawDataType tRawKaseikyoData[2];
139  tRawKaseikyoData[0] = (uint32_t) tSendValue.UWord.LowWord << 16 | aVendorCode; // LSB of tRawKaseikyoData[0] is sent first
140  tRawKaseikyoData[1] = tSendValue.UWord.HighWord;
142 #else
143  LongLongUnion tSendValue;
144  tSendValue.UWords[0] = aVendorCode;
145  // Compute parity
146  tSendValue.UWords[1] = (aAddress << KASEIKYO_VENDOR_ID_PARITY_BITS) | tVendorParity; // set low nibble to parity
147  tSendValue.UBytes[4] = aCommand;
148  tSendValue.UBytes[5] = aCommand ^ tSendValue.UBytes[2] ^ tSendValue.UBytes[3]; // Parity
150 #endif
151 }
152 
156 void IRsend::sendPanasonic(uint16_t aAddress, uint8_t aCommand, int_fast8_t aNumberOfRepeats) {
158 }
159 
163 void IRsend::sendKaseikyo_Denon(uint16_t aAddress, uint8_t aCommand, int_fast8_t aNumberOfRepeats) {
165 }
166 
170 void IRsend::sendKaseikyo_Mitsubishi(uint16_t aAddress, uint8_t aCommand, int_fast8_t aNumberOfRepeats) {
172 }
173 
177 void IRsend::sendKaseikyo_Sharp(uint16_t aAddress, uint8_t aCommand, int_fast8_t aNumberOfRepeats) {
179 }
180 
184 void IRsend::sendKaseikyo_JVC(uint16_t aAddress, uint8_t aCommand, int_fast8_t aNumberOfRepeats) {
186 }
187 
188 /*
189  * Tested with my Panasonic DVD/TV remote
190  */
192 
193  decode_type_t tProtocol;
194  // Check we have enough data (96 + 4) 4 for initial gap, start bit mark and space + stop bit mark
195  if (decodedIRData.rawDataPtr->rawlen != ((2 * KASEIKYO_BITS) + 4)) {
196  IR_DEBUG_PRINT(F("Kaseikyo: "));
197  IR_DEBUG_PRINT(F("Data length="));
199  IR_DEBUG_PRINTLN(F(" is not 100"));
200  return false;
201  }
202 
204  return false;
205  }
206 
207  // decode first 16 Vendor ID bits
209 #if defined(LOCAL_DEBUG)
210  Serial.print(F("Kaseikyo: "));
211  Serial.println(F("Vendor ID decode failed"));
212 #endif
213  return false;
214  }
215 
216  uint16_t tVendorId = decodedIRData.decodedRawData;
217  if (tVendorId == PANASONIC_VENDOR_ID_CODE) {
218  tProtocol = PANASONIC;
219  } else if (tVendorId == SHARP_VENDOR_ID_CODE) {
220  tProtocol = KASEIKYO_SHARP;
221  } else if (tVendorId == DENON_VENDOR_ID_CODE) {
222  tProtocol = KASEIKYO_DENON;
223  } else if (tVendorId == JVC_VENDOR_ID_CODE) {
224  tProtocol = KASEIKYO_JVC;
225  } else if (tVendorId == MITSUBISHI_VENDOR_ID_CODE) {
226  tProtocol = KASEIKYO_MITSUBISHI;
227  } else {
228  tProtocol = KASEIKYO;
229  }
230 
231  // Vendor Parity
232  uint8_t tVendorParity = tVendorId ^ (tVendorId >> 8);
233  tVendorParity = (tVendorParity ^ (tVendorParity >> 4)) & 0xF;
234 
235  /*
236  * Decode next 32 bits, 8 VendorID parity parity + 12 address (device and subdevice) + 8 command + 8 parity
237  */
240  3 + (2 * KASEIKYO_VENDOR_ID_BITS))) {
241 #if defined(LOCAL_DEBUG)
242  Serial.print(F("Kaseikyo: "));
243  Serial.println(F("VendorID parity, address, command + parity decode failed"));
244 #endif
245  return false;
246  }
247 
248  // Success
249 // decodedIRData.flags = IRDATA_FLAGS_IS_LSB_FIRST; // Not required, since this is the start value
250  LongUnion tValue;
252 #if __INT_WIDTH__ >= 32
253  // workaround until complete refactoring for 64 bit
254  decodedIRData.decodedRawData = (decodedIRData.decodedRawData << 16) | tVendorId; // store all 48 bits in decodedRawData
255 #endif
256  decodedIRData.address = (tValue.UWord.LowWord >> KASEIKYO_VENDOR_ID_PARITY_BITS); // remove 4 bit vendor parity
258  uint8_t tParity = tValue.UByte.LowByte ^ tValue.UByte.MidLowByte ^ tValue.UByte.MidHighByte;
259 
260  if (tVendorParity != (tValue.UByte.LowByte & 0xF)) {
262 
263 #if defined(LOCAL_DEBUG)
264  Serial.print(F("Kaseikyo: "));
265  Serial.print(F("4 bit VendorID parity is not correct. expected=0x"));
266  Serial.print(tVendorParity, HEX);
267  Serial.print(F(" received=0x"));
268  Serial.print(decodedIRData.decodedRawData, HEX);
269  Serial.print(F(" VendorID=0x"));
270  Serial.println(tVendorId, HEX);
271 #endif
272  }
273 
274  if (tProtocol == KASEIKYO) {
276  decodedIRData.extra = tVendorId; // Store (unknown) vendor ID
277  }
278 
279  if (tValue.UByte.HighByte != tParity) {
281 
282 #if defined(LOCAL_DEBUG)
283  Serial.print(F("Kaseikyo: "));
284  Serial.print(F("8 bit Parity is not correct. expected=0x"));
285  Serial.print(tParity, HEX);
286  Serial.print(F(" received=0x"));
287  Serial.print(decodedIRData.decodedRawData >> KASEIKYO_COMMAND_BITS, HEX);
288  Serial.print(F(" address=0x"));
289  Serial.print(decodedIRData.address, HEX);
290  Serial.print(F(" command=0x"));
291  Serial.println(decodedIRData.command, HEX);
292 #endif
293  }
294 
296  decodedIRData.protocol = tProtocol;
297 
298  // check for repeat
300 
301  return true;
302 }
303 
304 /*
305  * Removed void IRsend::sendPanasonic(uint16_t aAddress, uint32_t aData)
306  * and bool IRrecv::decodePanasonicMSB(decode_results *aResults)
307  * since their implementations were wrong (wrong length), and nobody recognized it
308  */
309 
311 #if defined(LOCAL_DEBUG)
312 #undef LOCAL_DEBUG
313 #endif
314 #endif // _IR_KASEIKYO_HPP
IRData::address
uint16_t address
Decoded address, Distance protocol (tMarkTicksLong (if tMarkTicksLong == 0, then tMarkTicksShort) << ...
Definition: IRProtocol.h:117
LongLongUnion::UBytes
uint8_t UBytes[8]
Definition: LongUnion.h:135
LongUnion
Union to specify parts / manifestations of a 32 bit Long without casts and shifts.
Definition: LongUnion.h:57
KASEIKYO_DENON
@ KASEIKYO_DENON
Definition: IRProtocol.h:54
KASEIKYO_PARITY_BITS
#define KASEIKYO_PARITY_BITS
Definition: ir_Kaseikyo.hpp:92
IRData::numberOfBits
uint16_t numberOfBits
Number of bits received for data (address + command + parity) - to determine protocol length if diffe...
Definition: IRProtocol.h:120
IRsend::aNumberOfRepeats
void uint8_t int_fast8_t aNumberOfRepeats
Definition: IRremoteInt.h:474
MITSUBISHI_VENDOR_ID_CODE
#define MITSUBISHI_VENDOR_ID_CODE
Definition: ir_Kaseikyo.hpp:109
IRsend::sendKaseikyo_Sharp
void sendKaseikyo_Sharp(uint16_t aAddress, uint8_t aData, int_fast8_t aNumberOfRepeats)
Stub using Kaseikyo with SHARP_VENDOR_ID_CODE.
Definition: ir_Kaseikyo.hpp:177
KASEIKYO_SHARP
@ KASEIKYO_SHARP
Definition: IRProtocol.h:55
KASEIKYO_ADDRESS_BITS
#define KASEIKYO_ADDRESS_BITS
Definition: ir_Kaseikyo.hpp:90
MICROS_IN_ONE_MILLI
#define MICROS_IN_ONE_MILLI
Definition: IRremote.hpp:263
LongUnion::UByte
struct LongUnion::@4 UByte
KASEIKYO_JVC
@ KASEIKYO_JVC
Definition: IRProtocol.h:56
decode_type_t
decode_type_t
An enum consisting of all supported formats.
Definition: IRProtocol.h:40
KASEIKYO_BIT_MARK
#define KASEIKYO_BIT_MARK
Definition: ir_Kaseikyo.hpp:99
LongUnion::UBytes
uint8_t UBytes[4]
Definition: LongUnion.h:89
KASEIKYO_REPEAT_PERIOD
#define KASEIKYO_REPEAT_PERIOD
Definition: ir_Kaseikyo.hpp:104
IRsend::sendPulseDistanceWidth
void sendPulseDistanceWidth(PulseDistanceWidthProtocolConstants *aProtocolConstants, IRRawDataType aData, uint_fast8_t aNumberOfBits, int_fast8_t aNumberOfRepeats)
Sends PulseDistance frames and repeats.
Definition: IRSend.hpp:532
LongUnion::LowByte
uint8_t LowByte
Definition: LongUnion.h:59
LongUnion::HighByte
uint8_t HighByte
Definition: LongUnion.h:62
IRData::rawDataPtr
irparams_struct * rawDataPtr
Pointer of the raw timing data to be decoded. Mainly the OverflowFlag and the data buffer filled by r...
Definition: IRProtocol.h:126
IRData::decodedRawData
IRRawDataType decodedRawData
Up to 32/64 bit decoded raw data, to be used for send functions.
Definition: IRProtocol.h:122
IR_DEBUG_PRINT
#define IR_DEBUG_PRINT(...)
If DEBUG, print the arguments, otherwise do nothing.
Definition: IRremoteInt.h:133
LongUnion::LowWord
uint16_t LowWord
Definition: LongUnion.h:78
KASEIKYO_VENDOR_ID_BITS
#define KASEIKYO_VENDOR_ID_BITS
Definition: ir_Kaseikyo.hpp:88
irparams_struct::rawlen
uint_fast8_t rawlen
counter of entries in rawbuf
Definition: IRremoteInt.h:109
LongLongUnion
Union to specify parts / manifestations of a 64 bit LongLong without casts and shifts.
Definition: LongUnion.h:104
IRrecv::decodePulseDistanceWidthData
bool decodePulseDistanceWidthData(PulseDistanceWidthProtocolConstants *aProtocolConstants, uint_fast8_t aNumberOfBits, uint_fast8_t aStartOffset=3)
Decode pulse distance protocols for PulseDistanceWidthProtocolConstants.
Definition: IRReceive.hpp:768
PANASONIC_VENDOR_ID_CODE
#define PANASONIC_VENDOR_ID_CODE
Definition: ir_Kaseikyo.hpp:107
IRDATA_FLAGS_PARITY_FAILED
#define IRDATA_FLAGS_PARITY_FAILED
the current (autorepeat) frame violated parity check
Definition: IRProtocol.h:96
LongUnion::MidLowByte
uint8_t MidLowByte
Definition: LongUnion.h:60
PulseDistanceWidthProtocolConstants
Definition: IRProtocol.h:74
PANASONIC
@ PANASONIC
Definition: IRProtocol.h:52
LongUnion::HighWord
uint16_t HighWord
Definition: LongUnion.h:79
IRrecv::decodedIRData
IRData decodedIRData
Definition: IRremoteInt.h:305
IRDATA_FLAGS_EXTRA_INFO
#define IRDATA_FLAGS_EXTRA_INFO
There is extra info not contained in address and data (e.g. Kaseikyo unknown vendor ID,...
Definition: IRProtocol.h:98
IRsend::sendPulseDistanceWidthFromArray
void sendPulseDistanceWidthFromArray(uint_fast8_t aFrequencyKHz, unsigned int aHeaderMarkMicros, unsigned int aHeaderSpaceMicros, unsigned int aOneMarkMicros, unsigned int aOneSpaceMicros, unsigned int aZeroMarkMicros, unsigned int aZeroSpaceMicros, IRRawDataType *aDecodedRawDataArray, unsigned int aNumberOfBits, bool aMSBfirst, bool aSendStopBit, unsigned int aRepeatPeriodMillis, int_fast8_t aNumberOfRepeats)
Sends PulseDistance data from array For LSB First the LSB of array[0] is sent first then all bits unt...
Definition: IRSend.hpp:383
SEND_STOP_BIT
#define SEND_STOP_BIT
Definition: IRremoteInt.h:393
IRData::flags
uint8_t flags
See IRDATA_FLAGS_* definitions above.
Definition: IRProtocol.h:121
JVC_VENDOR_ID_CODE
#define JVC_VENDOR_ID_CODE
Definition: ir_Kaseikyo.hpp:111
PROTOCOL_IS_LSB_FIRST
#define PROTOCOL_IS_LSB_FIRST
Definition: IRProtocol.h:129
IRrecv::checkForRepeatSpaceAndSetFlag
void checkForRepeatSpaceAndSetFlag(unsigned int aMediumRepeatSpaceMicros)
Definition: IRReceive.hpp:962
IRrecv::checkHeader
bool checkHeader(PulseDistanceWidthProtocolConstants *aProtocolConstants)
Definition: IRReceive.hpp:943
IRsend::sendKaseikyo
void sendKaseikyo(uint16_t aAddress, uint8_t aData, int_fast8_t aNumberOfRepeats, uint16_t aVendorCode)
Address can be interpreted as sub-device << 8 + device.
Definition: ir_Kaseikyo.hpp:124
IRsend::sendKaseikyo_JVC
void sendKaseikyo_JVC(uint16_t aAddress, uint8_t aData, int_fast8_t aNumberOfRepeats)
Stub using Kaseikyo with JVC_VENDOR_ID_CODE.
Definition: ir_Kaseikyo.hpp:184
SHARP_VENDOR_ID_CODE
#define SHARP_VENDOR_ID_CODE
Definition: ir_Kaseikyo.hpp:110
IRData::command
uint16_t command
Decoded command, Distance protocol (tMarkTicksShort << 8) | tSpaceTicksShort.
Definition: IRProtocol.h:118
KASEIKYO_HEADER_SPACE
#define KASEIKYO_HEADER_SPACE
Definition: ir_Kaseikyo.hpp:97
KASEIKYO_COMMAND_BITS
#define KASEIKYO_COMMAND_BITS
Definition: ir_Kaseikyo.hpp:91
IRsend::sendPanasonic
void sendPanasonic(uint16_t aAddress, uint8_t aData, int_fast8_t aNumberOfRepeats)
Stub using Kaseikyo with PANASONIC_VENDOR_ID_CODE.
Definition: ir_Kaseikyo.hpp:156
IRRawDataType
uint32_t IRRawDataType
Definition: IRremoteInt.h:117
KASEIKYO_REPEAT_DISTANCE
#define KASEIKYO_REPEAT_DISTANCE
Definition: ir_Kaseikyo.hpp:105
LongUnion::ULong
uint32_t ULong
Definition: LongUnion.h:93
KASEIKYO_MITSUBISHI
@ KASEIKYO_MITSUBISHI
Definition: IRProtocol.h:57
KASEIKYO
@ KASEIKYO
Definition: IRProtocol.h:53
KASEIKYO_VENDOR_ID_PARITY_BITS
#define KASEIKYO_VENDOR_ID_PARITY_BITS
Definition: ir_Kaseikyo.hpp:89
IrSender
IRsend IrSender
Definition: IRSend.hpp:59
IRDATA_FLAGS_IS_LSB_FIRST
#define IRDATA_FLAGS_IS_LSB_FIRST
Definition: IRProtocol.h:101
KASEIKYO_KHZ
#define KASEIKYO_KHZ
Definition: IRProtocol.h:145
LongLongUnion::UWords
uint16_t UWords[4]
Definition: LongUnion.h:137
LongLongUnion::ULongLong
uint64_t ULongLong
Definition: LongUnion.h:139
IRData::extra
uint16_t extra
Contains upper 16 bit of Magiquest WandID, Kaseikyo unknown vendor ID and Distance protocol (HeaderMa...
Definition: IRProtocol.h:119
KaseikyoProtocolConstants
struct PulseDistanceWidthProtocolConstants KaseikyoProtocolConstants
Definition: ir_Kaseikyo.hpp:113
KASEIKYO_ONE_SPACE
#define KASEIKYO_ONE_SPACE
Definition: ir_Kaseikyo.hpp:100
IRsend::sendKaseikyo_Mitsubishi
void sendKaseikyo_Mitsubishi(uint16_t aAddress, uint8_t aData, int_fast8_t aNumberOfRepeats)
Stub using Kaseikyo with MITSUBISHI_VENDOR_ID_CODE.
Definition: ir_Kaseikyo.hpp:170
LongUnion::MidHighByte
uint8_t MidHighByte
Definition: LongUnion.h:61
KASEIKYO_HEADER_MARK
#define KASEIKYO_HEADER_MARK
Definition: ir_Kaseikyo.hpp:96
LongUnion::UWord
struct LongUnion::@6 UWord
IRrecv::decodeKaseikyo
bool decodeKaseikyo()
Definition: ir_Kaseikyo.hpp:191
IR_DEBUG_PRINTLN
#define IR_DEBUG_PRINTLN(...)
If DEBUG, print the arguments as a line, otherwise do nothing.
Definition: IRremoteInt.h:137
KASEIKYO_BITS
#define KASEIKYO_BITS
Definition: ir_Kaseikyo.hpp:93
IRData::protocol
decode_type_t protocol
UNKNOWN, NEC, SONY, RC5, PULSE_DISTANCE, ...
Definition: IRProtocol.h:116
KASEIKYO_ZERO_SPACE
#define KASEIKYO_ZERO_SPACE
Definition: ir_Kaseikyo.hpp:101
IRsend::aCommand
void uint8_t aCommand
Definition: IRremoteInt.h:474
IRsend::enableIROut
void enableIROut(uint_fast8_t aFrequencyKHz)
Enables IR output.
Definition: IRSend.hpp:961
IRsend::sendKaseikyo_Denon
void sendKaseikyo_Denon(uint16_t aAddress, uint8_t aData, int_fast8_t aNumberOfRepeats)
Stub using Kaseikyo with DENON_VENDOR_ID_CODE.
Definition: ir_Kaseikyo.hpp:163
DENON_VENDOR_ID_CODE
#define DENON_VENDOR_ID_CODE
Definition: ir_Kaseikyo.hpp:108