181 lines
7.3 KiB
C++
181 lines
7.3 KiB
C++
#include "IRremote.h"
|
|
|
|
//==============================================================================
|
|
// SSSS H H AAA RRRR PPPP
|
|
// S H H A A R R P P
|
|
// SSS HHHHH AAAAA RRRR PPPP
|
|
// S H H A A R R P
|
|
// SSSS H H A A R R P
|
|
//==============================================================================
|
|
|
|
// Sharp and DISH support by Todd Treece: http://unionbridge.org/design/ircommand
|
|
//
|
|
// The send function has the necessary repeat built in because of the need to
|
|
// invert the signal.
|
|
//
|
|
// Sharp protocol documentation:
|
|
// http://www.sbprojects.com/knowledge/ir/sharp.htm
|
|
//
|
|
// Here is the LIRC file I found that seems to match the remote codes from the
|
|
// oscilloscope:
|
|
// Sharp LCD TV:
|
|
// http://lirc.sourceforge.net/remotes/sharp/GA538WJSA
|
|
|
|
#define SHARP_BITS 15
|
|
#define SHARP_ONE_SPACE 1805
|
|
//#define SHARP_ONE_SPACE 1850
|
|
|
|
#define SHARP_ADDR_BITS 5
|
|
#define SHARP_DATA_BITS 8
|
|
#define SHARP_BIT_MARK_SEND 250
|
|
#define SHARP_BIT_MARK_RECV 150
|
|
|
|
#define SHARP_ZERO_SPACE 795
|
|
#define SHARP_GAP 600000
|
|
#define SHARP_REPEAT_SPACE 3000
|
|
|
|
#define SHARP_TOGGLE_MASK 0x3FF
|
|
|
|
//+=============================================================================
|
|
#if SEND_SHARP
|
|
void IRsend::sendSharpRaw(unsigned long data, int nbits) {
|
|
enableIROut(38);
|
|
|
|
// Sending codes in bursts of 3 (normal, inverted, normal) makes transmission
|
|
// much more reliable. That's the exact behavior of CD-S6470 remote control.
|
|
for (int n = 0; n < 3; n++) {
|
|
sendPulseDistanceWidthData(SHARP_BIT_MARK_SEND, SHARP_ONE_SPACE, SHARP_BIT_MARK_SEND, SHARP_ZERO_SPACE, data, nbits);
|
|
// for (unsigned long mask = 1UL << (nbits - 1); mask; mask >>= 1) {
|
|
// if (data & mask) {
|
|
// mark (SHARP_BIT_MARK_SEND);
|
|
// space(SHARP_ONE_SPACE);
|
|
// } else {
|
|
// mark (SHARP_BIT_MARK_SEND);
|
|
// space(SHARP_ZERO_SPACE);
|
|
// }
|
|
// }
|
|
|
|
mark(SHARP_BIT_MARK_SEND);
|
|
space(SHARP_ZERO_SPACE);
|
|
delay(40);
|
|
|
|
data = data ^ SHARP_TOGGLE_MASK;
|
|
}
|
|
|
|
space(0); // Always end with the LED off
|
|
}
|
|
#endif
|
|
|
|
//+=============================================================================
|
|
// Sharp send compatible with data obtained through decodeSharp()
|
|
// ^^^^^^^^^^^^^ FUNCTION MISSING!
|
|
//
|
|
#if SEND_SHARP
|
|
void IRsend::sendSharp(unsigned int address, unsigned int command) {
|
|
sendSharpRaw((address << 10) | (command << 2) | 2, SHARP_BITS);
|
|
/*
|
|
* Use this code instead of the line above to be code compatible to the decoded values from decodeSharp
|
|
*/
|
|
// //Change address to big-endian (five bits swap place)
|
|
// address = (address & 0x10) >> 4 | (address & 0x01) << 4 | (address & 0x08) >> 2 | (address & 0x02) << 2 | (address & 0x04) ;
|
|
// //Change command to big-endian (eight bit swap place)
|
|
// command = (command & 0xF0) >> 4 | (command & 0x0F) << 4;
|
|
// command = (command & 0xCC) >> 2 | (command & 0x33) << 2;
|
|
// command = (command & 0xAA) >> 1 | (command & 0x55) << 1;
|
|
// sendSharpRaw((address << 10) | (command << 2) | 0, SHARP_BITS);
|
|
}
|
|
|
|
#endif // SEND_SHARP
|
|
|
|
//+=============================================================================
|
|
// Sharp decode function written based on Sharp protocol documentation:
|
|
// http://www.sbprojects.com/knowledge/ir/sharp.htm
|
|
// Tesded on a DENON AVR-1804 reciever
|
|
|
|
#if DECODE_SHARP
|
|
bool IRrecv::decodeSharp() {
|
|
unsigned long addr = 0; // Somewhere to build our address
|
|
unsigned long data = 0; // Somewhere to build our data
|
|
unsigned long lastData = 0; // Somewhere to store last data
|
|
int offset = 1; //skip long space
|
|
int loops = 1; //number of bursts
|
|
|
|
// Check we have the right amount of data
|
|
// Either one burst or three where second is inverted
|
|
// The setting #define _GAP 5000 in IRremoteInt.h will give one burst and possibly three calls to this function
|
|
if (irparams.rawlen == (SHARP_BITS + 1) * 2)
|
|
loops = 1;
|
|
else if (irparams.rawlen == (SHARP_BITS + 1) * 2 * 3)
|
|
loops = 3;
|
|
else
|
|
return false;
|
|
|
|
// Check the first mark to see if it fits the SHARP_BIT_MARK_RECV length
|
|
if (!MATCH_MARK(results.rawbuf[offset], SHARP_BIT_MARK_RECV))
|
|
return false;
|
|
//check the first pause and see if it fits the SHARP_ONE_SPACE or SHARP_ZERO_SPACE length
|
|
if (!(MATCH_SPACE(results.rawbuf[offset + 1], SHARP_ONE_SPACE) || MATCH_SPACE(results.rawbuf[offset + 1], SHARP_ZERO_SPACE)))
|
|
return false;
|
|
|
|
// Read the bits in
|
|
for (int j = 0; j < loops; j++) {
|
|
data = 0;
|
|
addr = 0;
|
|
addr = decodePulseDistanceData(SHARP_ADDR_BITS, offset, SHARP_BIT_MARK_SEND, SHARP_ONE_SPACE, SHARP_ZERO_SPACE);
|
|
// for (int i = 0; i < SHARP_ADDR_BITS; i++) {
|
|
// // Each bit looks like: SHARP_BIT_MARK_RECV + SHARP_ONE_SPACE -> 1
|
|
// // or : SHARP_BIT_MARK_RECV + SHARP_ZERO_SPACE -> 0
|
|
// if (!MATCH_MARK(results.rawbuf[offset++], SHARP_BIT_MARK_RECV))
|
|
// return false;
|
|
// // IR data is big-endian, so we shuffle it in from the right:
|
|
// if (MATCH_SPACE(results.rawbuf[offset], SHARP_ONE_SPACE))
|
|
// addr += 1 << i;
|
|
// else if (MATCH_SPACE(results.rawbuf[offset], SHARP_ZERO_SPACE))
|
|
// addr = addr;
|
|
// else
|
|
// return false;
|
|
// offset++;
|
|
// }
|
|
data = decodePulseDistanceData( SHARP_DATA_BITS, offset + SHARP_ADDR_BITS, SHARP_BIT_MARK_SEND, SHARP_ONE_SPACE,
|
|
SHARP_ZERO_SPACE);
|
|
// for (int i = 0; i < SHARP_DATA_BITS; i++) {
|
|
// // Each bit looks like: SHARP_BIT_MARK_RECV + SHARP_ONE_SPACE -> 1
|
|
// // or : SHARP_BIT_MARK_RECV + SHARP_ZERO_SPACE -> 0
|
|
// if (!MATCH_MARK(results.rawbuf[offset++], SHARP_BIT_MARK_RECV))
|
|
// return false;
|
|
// // IR data is big-endian, so we shuffle it in from the right:
|
|
// if (MATCH_SPACE(results.rawbuf[offset], SHARP_ONE_SPACE))
|
|
// data += 1 << i;
|
|
// else if (MATCH_SPACE(results.rawbuf[offset], SHARP_ZERO_SPACE))
|
|
// data = data;
|
|
// else
|
|
// return false;
|
|
// offset++;
|
|
// //Serial.print(i);
|
|
// //Serial.print(":");
|
|
// //Serial.println(data, HEX);
|
|
// }
|
|
//skip exp bit (mark+pause), chk bit (mark+pause), mark and long pause before next burst
|
|
offset += 6;
|
|
|
|
//Check if last burst data is equal to this burst (lastData already inverted)
|
|
if (lastData != 0 && data != lastData)
|
|
return false;
|
|
//save current burst of data but invert (XOR) the last 10 bits (8 data bits + exp bit + chk bit)
|
|
lastData = data ^ 0xFF;
|
|
}
|
|
|
|
// Success
|
|
results.bits = SHARP_BITS;
|
|
results.value = data;
|
|
results.address = addr;
|
|
results.decode_type = SHARP;
|
|
return true;
|
|
}
|
|
bool IRrecv::decodeSharp(decode_results *aResults) {
|
|
bool aReturnValue = decodeSharp();
|
|
*aResults = results;
|
|
return aReturnValue;
|
|
}
|
|
#endif
|