mirror of https://github.com/arendst/Tasmota.git
1213 lines
32 KiB
C++
1213 lines
32 KiB
C++
/***************************************************
|
|
* IRremote for ESP8266
|
|
*
|
|
* Based on the IRremote library for Arduino by Ken Shirriff
|
|
* Version 0.11 August, 2009
|
|
* Copyright 2009 Ken Shirriff
|
|
* For details, see http://arcfn.com/2009/08/multi-protocol-infrared-remote-library.html
|
|
*
|
|
* Modified by Paul Stoffregen <paul@pjrc.com> to support other boards and timers
|
|
* Modified by Mitra Ardron <mitra@mitra.biz>
|
|
* Added Sanyo and Mitsubishi controllers
|
|
* Modified Sony to spot the repeat codes that some Sony's send
|
|
*
|
|
* Interrupt code based on NECIRrcv by Joe Knapp
|
|
* http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1210243556
|
|
* Also influenced by http://zovirl.com/2008/11/12/building-a-universal-remote-with-an-arduino/
|
|
*
|
|
* JVC and Panasonic protocol added by Kristian Lauszus (Thanks to zenwheel and other people at the original blog post)
|
|
* LG added by Darryl Smith (based on the JVC protocol)
|
|
* Whynter A/C ARC-110WD added by Francesco Meschia
|
|
*
|
|
* Updated by markszabo (https://github.com/markszabo/IRremoteESP8266) for sending IR code on ESP8266
|
|
* Updated by Sebastien Warin (http://sebastien.warin.fr) for receiving IR code on ESP8266
|
|
*
|
|
* GPL license, all text above must be included in any redistribution
|
|
****************************************************/
|
|
|
|
#include "IRremoteESP8266.h"
|
|
#include "IRremoteInt.h"
|
|
|
|
// These versions of MATCH, MATCH_MARK, and MATCH_SPACE are only for debugging.
|
|
// To use them, set DEBUG in IRremoteInt.h
|
|
// Normally macros are used for efficiency
|
|
#ifdef DEBUG
|
|
int MATCH(int measured, int desired) {
|
|
Serial.print("Testing: ");
|
|
Serial.print(TICKS_LOW(desired), DEC);
|
|
Serial.print(" <= ");
|
|
Serial.print(measured, DEC);
|
|
Serial.print(" <= ");
|
|
Serial.println(TICKS_HIGH(desired), DEC);
|
|
return measured >= TICKS_LOW(desired) && measured <= TICKS_HIGH(desired);
|
|
}
|
|
|
|
int MATCH_MARK(int measured_ticks, int desired_us) {
|
|
Serial.print("Testing mark ");
|
|
Serial.print(measured_ticks * USECPERTICK, DEC);
|
|
Serial.print(" vs ");
|
|
Serial.print(desired_us, DEC);
|
|
Serial.print(": ");
|
|
Serial.print(TICKS_LOW(desired_us + MARK_EXCESS), DEC);
|
|
Serial.print(" <= ");
|
|
Serial.print(measured_ticks, DEC);
|
|
Serial.print(" <= ");
|
|
Serial.println(TICKS_HIGH(desired_us + MARK_EXCESS), DEC);
|
|
return measured_ticks >= TICKS_LOW(desired_us + MARK_EXCESS) && measured_ticks <= TICKS_HIGH(desired_us + MARK_EXCESS);
|
|
}
|
|
|
|
int MATCH_SPACE(int measured_ticks, int desired_us) {
|
|
Serial.print("Testing space ");
|
|
Serial.print(measured_ticks * USECPERTICK, DEC);
|
|
Serial.print(" vs ");
|
|
Serial.print(desired_us, DEC);
|
|
Serial.print(": ");
|
|
Serial.print(TICKS_LOW(desired_us - MARK_EXCESS), DEC);
|
|
Serial.print(" <= ");
|
|
Serial.print(measured_ticks, DEC);
|
|
Serial.print(" <= ");
|
|
Serial.println(TICKS_HIGH(desired_us - MARK_EXCESS), DEC);
|
|
return measured_ticks >= TICKS_LOW(desired_us - MARK_EXCESS) && measured_ticks <= TICKS_HIGH(desired_us - MARK_EXCESS);
|
|
}
|
|
#else
|
|
int MATCH(int measured, int desired) {return measured >= TICKS_LOW(desired) && measured <= TICKS_HIGH(desired);}
|
|
int MATCH_MARK(int measured_ticks, int desired_us) {return MATCH(measured_ticks, (desired_us + MARK_EXCESS));}
|
|
int MATCH_SPACE(int measured_ticks, int desired_us) {return MATCH(measured_ticks, (desired_us - MARK_EXCESS));}
|
|
// Debugging versions are in IRremote.cpp
|
|
#endif
|
|
|
|
// IRsend -----------------------------------------------------------------------------------
|
|
|
|
IRsend::IRsend(int IRsendPin)
|
|
{
|
|
IRpin = IRsendPin;
|
|
}
|
|
|
|
void IRsend::begin()
|
|
{
|
|
pinMode(IRpin, OUTPUT);
|
|
}
|
|
|
|
void IRsend::sendNEC(unsigned long data, int nbits)
|
|
{
|
|
enableIROut(38);
|
|
mark(NEC_HDR_MARK);
|
|
space(NEC_HDR_SPACE);
|
|
for (int i = 0; i < nbits; i++) {
|
|
if (data & TOPBIT) {
|
|
mark(NEC_BIT_MARK);
|
|
space(NEC_ONE_SPACE);
|
|
}
|
|
else {
|
|
mark(NEC_BIT_MARK);
|
|
space(NEC_ZERO_SPACE);
|
|
}
|
|
data <<= 1;
|
|
}
|
|
mark(NEC_BIT_MARK);
|
|
space(0);
|
|
}
|
|
|
|
void IRsend::sendWhynter(unsigned long data, int nbits) {
|
|
enableIROut(38);
|
|
mark(WHYNTER_ZERO_MARK);
|
|
space(WHYNTER_ZERO_SPACE);
|
|
mark(WHYNTER_HDR_MARK);
|
|
space(WHYNTER_HDR_SPACE);
|
|
for (int i = 0; i < nbits; i++) {
|
|
if (data & TOPBIT) {
|
|
mark(WHYNTER_ONE_MARK);
|
|
space(WHYNTER_ONE_SPACE);
|
|
}
|
|
else {
|
|
mark(WHYNTER_ZERO_MARK);
|
|
space(WHYNTER_ZERO_SPACE);
|
|
}
|
|
data <<= 1;
|
|
}
|
|
mark(WHYNTER_ZERO_MARK);
|
|
space(WHYNTER_ZERO_SPACE);
|
|
}
|
|
|
|
void IRsend::sendSony(unsigned long data, int nbits) {
|
|
enableIROut(40);
|
|
mark(SONY_HDR_MARK);
|
|
space(SONY_HDR_SPACE);
|
|
data = data << (32 - nbits);
|
|
for (int i = 0; i < nbits; i++) {
|
|
if (data & TOPBIT) {
|
|
mark(SONY_ONE_MARK);
|
|
space(SONY_HDR_SPACE);
|
|
}
|
|
else {
|
|
mark(SONY_ZERO_MARK);
|
|
space(SONY_HDR_SPACE);
|
|
}
|
|
data <<= 1;
|
|
}
|
|
}
|
|
|
|
void IRsend::sendRaw(unsigned int buf[], int len, int hz)
|
|
{
|
|
enableIROut(hz);
|
|
for (int i = 0; i < len; i++) {
|
|
if (i & 1) {
|
|
space(buf[i]);
|
|
}
|
|
else {
|
|
mark(buf[i]);
|
|
}
|
|
}
|
|
space(0); // Just to be sure
|
|
}
|
|
|
|
// Note: first bit must be a one (start bit)
|
|
void IRsend::sendRC5(unsigned long data, int nbits)
|
|
{
|
|
enableIROut(36);
|
|
data = data << (32 - nbits);
|
|
mark(RC5_T1); // First start bit
|
|
space(RC5_T1); // Second start bit
|
|
mark(RC5_T1); // Second start bit
|
|
for (int i = 0; i < nbits; i++) {
|
|
if (data & TOPBIT) {
|
|
space(RC5_T1); // 1 is space, then mark
|
|
mark(RC5_T1);
|
|
}
|
|
else {
|
|
mark(RC5_T1);
|
|
space(RC5_T1);
|
|
}
|
|
data <<= 1;
|
|
}
|
|
space(0); // Turn off at end
|
|
}
|
|
|
|
// Caller needs to take care of flipping the toggle bit
|
|
void IRsend::sendRC6(unsigned long data, int nbits)
|
|
{
|
|
enableIROut(36);
|
|
data = data << (32 - nbits);
|
|
mark(RC6_HDR_MARK);
|
|
space(RC6_HDR_SPACE);
|
|
mark(RC6_T1); // start bit
|
|
space(RC6_T1);
|
|
int t;
|
|
for (int i = 0; i < nbits; i++) {
|
|
if (i == 3) {
|
|
// double-wide trailer bit
|
|
t = 2 * RC6_T1;
|
|
}
|
|
else {
|
|
t = RC6_T1;
|
|
}
|
|
if (data & TOPBIT) {
|
|
mark(t);
|
|
space(t);
|
|
}
|
|
else {
|
|
space(t);
|
|
mark(t);
|
|
}
|
|
|
|
data <<= 1;
|
|
}
|
|
space(0); // Turn off at end
|
|
}
|
|
void IRsend::sendPanasonic(unsigned int address, unsigned long data) {
|
|
enableIROut(35);
|
|
mark(PANASONIC_HDR_MARK);
|
|
space(PANASONIC_HDR_SPACE);
|
|
|
|
for(int i=0;i<16;i++)
|
|
{
|
|
mark(PANASONIC_BIT_MARK);
|
|
if (address & 0x8000) {
|
|
space(PANASONIC_ONE_SPACE);
|
|
} else {
|
|
space(PANASONIC_ZERO_SPACE);
|
|
}
|
|
address <<= 1;
|
|
}
|
|
for (int i=0; i < 32; i++) {
|
|
mark(PANASONIC_BIT_MARK);
|
|
if (data & TOPBIT) {
|
|
space(PANASONIC_ONE_SPACE);
|
|
} else {
|
|
space(PANASONIC_ZERO_SPACE);
|
|
}
|
|
data <<= 1;
|
|
}
|
|
mark(PANASONIC_BIT_MARK);
|
|
space(0);
|
|
}
|
|
void IRsend::sendJVC(unsigned long data, int nbits, int repeat)
|
|
{
|
|
enableIROut(38);
|
|
data = data << (32 - nbits);
|
|
if (!repeat){
|
|
mark(JVC_HDR_MARK);
|
|
space(JVC_HDR_SPACE);
|
|
}
|
|
for (int i = 0; i < nbits; i++) {
|
|
if (data & TOPBIT) {
|
|
mark(JVC_BIT_MARK);
|
|
space(JVC_ONE_SPACE);
|
|
}
|
|
else {
|
|
mark(JVC_BIT_MARK);
|
|
space(JVC_ZERO_SPACE);
|
|
}
|
|
data <<= 1;
|
|
}
|
|
mark(JVC_BIT_MARK);
|
|
space(0);
|
|
}
|
|
|
|
void IRsend::sendSAMSUNG(unsigned long data, int nbits)
|
|
{
|
|
enableIROut(38);
|
|
mark(SAMSUNG_HDR_MARK);
|
|
space(SAMSUNG_HDR_SPACE);
|
|
for (int i = 0; i < nbits; i++) {
|
|
if (data & TOPBIT) {
|
|
mark(SAMSUNG_BIT_MARK);
|
|
space(SAMSUNG_ONE_SPACE);
|
|
}
|
|
else {
|
|
mark(SAMSUNG_BIT_MARK);
|
|
space(SAMSUNG_ZERO_SPACE);
|
|
}
|
|
data <<= 1;
|
|
}
|
|
mark(SAMSUNG_BIT_MARK);
|
|
space(0);
|
|
}
|
|
|
|
void IRsend::mark(int time) {
|
|
// Sends an IR mark for the specified number of microseconds.
|
|
// The mark output is modulated at the PWM frequency.
|
|
long beginning = micros();
|
|
while(micros() - beginning < time){
|
|
digitalWrite(IRpin, HIGH);
|
|
delayMicroseconds(halfPeriodicTime);
|
|
digitalWrite(IRpin, LOW);
|
|
delayMicroseconds(halfPeriodicTime); //38 kHz -> T = 26.31 microsec (periodic time), half of it is 13
|
|
}
|
|
}
|
|
|
|
/* Leave pin off for time (given in microseconds) */
|
|
void IRsend::space(int time) {
|
|
// Sends an IR space for the specified number of microseconds.
|
|
// A space is no output, so the PWM output is disabled.
|
|
digitalWrite(IRpin, LOW);
|
|
if (time > 0) delayMicroseconds(time);
|
|
}
|
|
|
|
void IRsend::enableIROut(int khz) {
|
|
// Enables IR output. The khz value controls the modulation frequency in kilohertz.
|
|
halfPeriodicTime = 500/khz; // T = 1/f but we need T/2 in microsecond and f is in kHz
|
|
}
|
|
|
|
|
|
/* Sharp and DISH support by Todd Treece ( http://unionbridge.org/design/ircommand )
|
|
|
|
The Dish send function needs to be repeated 4 times, and the Sharp 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 are the LIRC files that I found that seem to match the remote codes
|
|
from the oscilloscope:
|
|
|
|
Sharp LCD TV:
|
|
http://lirc.sourceforge.net/remotes/sharp/GA538WJSA
|
|
|
|
DISH NETWORK (echostar 301):
|
|
http://lirc.sourceforge.net/remotes/echostar/301_501_3100_5100_58xx_59xx
|
|
|
|
For the DISH codes, only send the last for characters of the hex.
|
|
i.e. use 0x1C10 instead of 0x0000000000001C10 which is listed in the
|
|
linked LIRC file.
|
|
*/
|
|
|
|
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 behaviour of CD-S6470 remote control.
|
|
for (int n = 0; n < 3; n++) {
|
|
for (int i = 1 << (nbits-1); i > 0; i>>=1) {
|
|
if (data & i) {
|
|
mark(SHARP_BIT_MARK);
|
|
space(SHARP_ONE_SPACE);
|
|
}
|
|
else {
|
|
mark(SHARP_BIT_MARK);
|
|
space(SHARP_ZERO_SPACE);
|
|
}
|
|
}
|
|
|
|
mark(SHARP_BIT_MARK);
|
|
space(SHARP_ZERO_SPACE);
|
|
delay(40);
|
|
|
|
data = data ^ SHARP_TOGGLE_MASK;
|
|
}
|
|
}
|
|
|
|
// Sharp send compatible with data obtained through decodeSharp
|
|
void IRsend::sendSharp(unsigned int address, unsigned int command) {
|
|
sendSharpRaw((address << 10) | (command << 2) | 2, 15);
|
|
}
|
|
|
|
void IRsend::sendDISH(unsigned long data, int nbits) {
|
|
enableIROut(56);
|
|
mark(DISH_HDR_MARK);
|
|
space(DISH_HDR_SPACE);
|
|
for (int i = 0; i < nbits; i++) {
|
|
if (data & DISH_TOP_BIT) {
|
|
mark(DISH_BIT_MARK);
|
|
space(DISH_ONE_SPACE);
|
|
}
|
|
else {
|
|
mark(DISH_BIT_MARK);
|
|
space(DISH_ZERO_SPACE);
|
|
}
|
|
data <<= 1;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|
|
|
|
|
|
//IRRecv------------------------------------------------------
|
|
|
|
extern "C" {
|
|
#include "user_interface.h"
|
|
#include "gpio.h"
|
|
}
|
|
|
|
static ETSTimer timer;
|
|
volatile irparams_t irparams;
|
|
|
|
static void ICACHE_FLASH_ATTR read_timeout(void *arg) {
|
|
os_intr_lock();
|
|
if (irparams.rawlen) {
|
|
irparams.rcvstate = STATE_STOP;
|
|
}
|
|
os_intr_unlock();
|
|
}
|
|
|
|
static void ICACHE_FLASH_ATTR gpio_intr(void *arg) {
|
|
uint32_t gpio_status = GPIO_REG_READ(GPIO_STATUS_ADDRESS);
|
|
GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, gpio_status);
|
|
|
|
if (irparams.rcvstate == STATE_STOP) {
|
|
return;
|
|
}
|
|
static uint32_t start = 0;
|
|
uint32_t now = system_get_time();
|
|
if (irparams.rcvstate == STATE_IDLE) {
|
|
irparams.rcvstate = STATE_MARK;
|
|
}
|
|
else if (irparams.rawlen < RAWBUF) {
|
|
irparams.rawbuf[irparams.rawlen++] = (now - start) / USECPERTICK + 1;
|
|
}
|
|
start = now;
|
|
|
|
os_timer_disarm(&timer);
|
|
os_timer_arm(&timer, 15, 0);
|
|
}
|
|
|
|
IRrecv::IRrecv(int recvpin) {
|
|
irparams.recvpin = recvpin;
|
|
}
|
|
|
|
// initialization
|
|
void IRrecv::enableIRIn() {
|
|
|
|
// initialize state machine variables
|
|
irparams.rcvstate = STATE_IDLE;
|
|
irparams.rawlen = 0;
|
|
|
|
// set pin modes
|
|
//PIN_FUNC_SELECT(IR_IN_MUX, IR_IN_FUNC);
|
|
GPIO_DIS_OUTPUT(irparams.recvpin);
|
|
|
|
// Initialize timer
|
|
os_timer_disarm(&timer);
|
|
os_timer_setfn(&timer, (os_timer_func_t *)read_timeout, &timer);
|
|
|
|
// ESP Attach Interrupt
|
|
ETS_GPIO_INTR_DISABLE();
|
|
ETS_GPIO_INTR_ATTACH(gpio_intr, NULL);
|
|
gpio_pin_intr_state_set(GPIO_ID_PIN(irparams.recvpin), GPIO_PIN_INTR_ANYEDGE);
|
|
ETS_GPIO_INTR_ENABLE();
|
|
//ETS_INTR_UNLOCK();
|
|
|
|
//attachInterrupt(irparams.recvpin, readIR, CHANGE);
|
|
//irReadTimer.initializeUs(USECPERTICK, readIR).start();
|
|
//os_timer_arm_us(&irReadTimer, USECPERTICK, 1);
|
|
//ets_timer_arm_new(&irReadTimer, USECPERTICK, 1, 0);
|
|
}
|
|
|
|
void IRrecv::disableIRIn() {
|
|
//irReadTimer.stop();
|
|
//os_timer_disarm(&irReadTimer);
|
|
ETS_INTR_LOCK();
|
|
ETS_GPIO_INTR_DISABLE();
|
|
}
|
|
|
|
void IRrecv::resume() {
|
|
irparams.rcvstate = STATE_IDLE;
|
|
irparams.rawlen = 0;
|
|
}
|
|
|
|
// Decodes the received IR message
|
|
// Returns 0 if no data ready, 1 if data ready.
|
|
// Results of decoding are stored in results
|
|
int IRrecv::decode(decode_results *results) {
|
|
results->rawbuf = irparams.rawbuf;
|
|
results->rawlen = irparams.rawlen;
|
|
if (irparams.rcvstate != STATE_STOP) {
|
|
return ERR;
|
|
}
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting NEC decode");
|
|
#endif
|
|
if (decodeNEC(results)) {
|
|
return DECODED;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting Sony decode");
|
|
#endif
|
|
if (decodeSony(results)) {
|
|
return DECODED;
|
|
}
|
|
/*
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting Sanyo decode");
|
|
#endif
|
|
if (decodeSanyo(results)) {
|
|
return DECODED;
|
|
}*/
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting Mitsubishi decode");
|
|
#endif
|
|
if (decodeMitsubishi(results)) {
|
|
return DECODED;
|
|
}
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting RC5 decode");
|
|
#endif
|
|
if (decodeRC5(results)) {
|
|
return DECODED;
|
|
}
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting RC6 decode");
|
|
#endif
|
|
if (decodeRC6(results)) {
|
|
return DECODED;
|
|
}
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting Panasonic decode");
|
|
#endif
|
|
if (decodePanasonic(results)) {
|
|
return DECODED;
|
|
}
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting LG decode");
|
|
#endif
|
|
if (decodeLG(results)) {
|
|
return DECODED;
|
|
}
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting JVC decode");
|
|
#endif
|
|
if (decodeJVC(results)) {
|
|
return DECODED;
|
|
}
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting SAMSUNG decode");
|
|
#endif
|
|
if (decodeSAMSUNG(results)) {
|
|
return DECODED;
|
|
}
|
|
#ifdef DEBUG
|
|
Serial.println("Attempting Whynter decode");
|
|
#endif
|
|
if (decodeWhynter(results)) {
|
|
return DECODED;
|
|
}
|
|
// decodeHash returns a hash on any input.
|
|
// Thus, it needs to be last in the list.
|
|
// If you add any decodes, add them before this.
|
|
if (decodeHash(results)) {
|
|
return DECODED;
|
|
}
|
|
// Throw away and start over
|
|
resume();
|
|
return ERR;
|
|
}
|
|
|
|
// NECs have a repeat only 4 items long
|
|
long IRrecv::decodeNEC(decode_results *results) {
|
|
long data = 0;
|
|
int offset = 1; // Skip initial space
|
|
// Initial mark
|
|
if (!MATCH_MARK(results->rawbuf[offset], NEC_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
// Check for repeat
|
|
if (irparams.rawlen == 4 &&
|
|
MATCH_SPACE(results->rawbuf[offset], NEC_RPT_SPACE) &&
|
|
MATCH_MARK(results->rawbuf[offset+1], NEC_BIT_MARK)) {
|
|
results->bits = 0;
|
|
results->value = REPEAT;
|
|
results->decode_type = NEC;
|
|
return DECODED;
|
|
}
|
|
if (irparams.rawlen < 2 * NEC_BITS + 4) {
|
|
return ERR;
|
|
}
|
|
// Initial space
|
|
if (!MATCH_SPACE(results->rawbuf[offset], NEC_HDR_SPACE)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
for (int i = 0; i < NEC_BITS; i++) {
|
|
if (!MATCH_MARK(results->rawbuf[offset], NEC_BIT_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (MATCH_SPACE(results->rawbuf[offset], NEC_ONE_SPACE)) {
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (MATCH_SPACE(results->rawbuf[offset], NEC_ZERO_SPACE)) {
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
}
|
|
// Success
|
|
results->bits = NEC_BITS;
|
|
results->value = data;
|
|
results->decode_type = NEC;
|
|
return DECODED;
|
|
}
|
|
|
|
long IRrecv::decodeSony(decode_results *results) {
|
|
long data = 0;
|
|
if (irparams.rawlen < 2 * SONY_BITS + 2) {
|
|
return ERR;
|
|
}
|
|
int offset = 0; // Dont skip first space, check its size
|
|
|
|
/*
|
|
// Some Sony's deliver repeats fast after first
|
|
// unfortunately can't spot difference from of repeat from two fast clicks
|
|
if (results->rawbuf[offset] < SONY_DOUBLE_SPACE_USECS) {
|
|
// Serial.print("IR Gap found: ");
|
|
results->bits = 0;
|
|
results->value = REPEAT;
|
|
results->decode_type = SANYO;
|
|
return DECODED;
|
|
}*/
|
|
offset++;
|
|
|
|
// Initial mark
|
|
if (!MATCH_MARK(results->rawbuf[offset], SONY_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
|
|
while (offset + 1 < irparams.rawlen) {
|
|
if (!MATCH_SPACE(results->rawbuf[offset], SONY_HDR_SPACE)) {
|
|
break;
|
|
}
|
|
offset++;
|
|
if (MATCH_MARK(results->rawbuf[offset], SONY_ONE_MARK)) {
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (MATCH_MARK(results->rawbuf[offset], SONY_ZERO_MARK)) {
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
}
|
|
|
|
// Success
|
|
results->bits = (offset - 1) / 2;
|
|
if (results->bits < 12) {
|
|
results->bits = 0;
|
|
return ERR;
|
|
}
|
|
results->value = data;
|
|
results->decode_type = SONY;
|
|
return DECODED;
|
|
}
|
|
|
|
long IRrecv::decodeWhynter(decode_results *results) {
|
|
long data = 0;
|
|
|
|
if (irparams.rawlen < 2 * WHYNTER_BITS + 6) {
|
|
return ERR;
|
|
}
|
|
|
|
int offset = 1; // Skip first space
|
|
|
|
|
|
// sequence begins with a bit mark and a zero space
|
|
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (!MATCH_SPACE(results->rawbuf[offset], WHYNTER_ZERO_SPACE)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
|
|
// header mark and space
|
|
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (!MATCH_SPACE(results->rawbuf[offset], WHYNTER_HDR_SPACE)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
|
|
// data bits
|
|
for (int i = 0; i < WHYNTER_BITS; i++) {
|
|
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (MATCH_SPACE(results->rawbuf[offset], WHYNTER_ONE_SPACE)) {
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (MATCH_SPACE(results->rawbuf[offset],WHYNTER_ZERO_SPACE)) {
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
}
|
|
|
|
// trailing mark
|
|
if (!MATCH_MARK(results->rawbuf[offset], WHYNTER_BIT_MARK)) {
|
|
return ERR;
|
|
}
|
|
// Success
|
|
results->bits = WHYNTER_BITS;
|
|
results->value = data;
|
|
results->decode_type = WHYNTER;
|
|
return DECODED;
|
|
}
|
|
|
|
// I think this is a Sanyo decoder - serial = SA 8650B
|
|
// Looks like Sony except for timings, 48 chars of data and time/space different
|
|
long IRrecv::decodeSanyo(decode_results *results) {
|
|
long data = 0;
|
|
if (irparams.rawlen < 2 * SANYO_BITS + 2) {
|
|
return ERR;
|
|
}
|
|
int offset = 1; // Skip first space
|
|
|
|
|
|
// Initial space
|
|
/* Put this back in for debugging - note can't use #DEBUG as if Debug on we don't see the repeat cos of the delay
|
|
Serial.print("IR Gap: ");
|
|
Serial.println( results->rawbuf[offset]);
|
|
Serial.println( "test against:");
|
|
Serial.println(results->rawbuf[offset]);
|
|
*/
|
|
|
|
if (results->rawbuf[offset] < SANYO_DOUBLE_SPACE_USECS) {
|
|
// Serial.print("IR Gap found: ");
|
|
results->bits = 0;
|
|
results->value = REPEAT;
|
|
results->decode_type = SANYO;
|
|
return DECODED;
|
|
}
|
|
offset++;
|
|
|
|
// Initial mark
|
|
if (!MATCH_MARK(results->rawbuf[offset], SANYO_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
|
|
// Skip Second Mark
|
|
if (!MATCH_MARK(results->rawbuf[offset], SANYO_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
|
|
while (offset + 1 < irparams.rawlen) {
|
|
if (!MATCH_SPACE(results->rawbuf[offset], SANYO_HDR_SPACE)) {
|
|
break;
|
|
}
|
|
offset++;
|
|
if (MATCH_MARK(results->rawbuf[offset], SANYO_ONE_MARK)) {
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (MATCH_MARK(results->rawbuf[offset], SANYO_ZERO_MARK)) {
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
}
|
|
|
|
// Success
|
|
results->bits = (offset - 1) / 2;
|
|
if (results->bits < 12) {
|
|
results->bits = 0;
|
|
return ERR;
|
|
}
|
|
results->value = data;
|
|
results->decode_type = SANYO;
|
|
return DECODED;
|
|
}
|
|
|
|
// Looks like Sony except for timings, 48 chars of data and time/space different
|
|
long IRrecv::decodeMitsubishi(decode_results *results) {
|
|
// Serial.print("?!? decoding Mitsubishi:");Serial.print(irparams.rawlen); Serial.print(" want "); Serial.println( 2 * MITSUBISHI_BITS + 2);
|
|
long data = 0;
|
|
if (irparams.rawlen < 2 * MITSUBISHI_BITS + 2) {
|
|
return ERR;
|
|
}
|
|
int offset = 1; // Skip first space
|
|
// Initial space
|
|
/* Put this back in for debugging - note can't use #DEBUG as if Debug on we don't see the repeat cos of the delay
|
|
Serial.print("IR Gap: ");
|
|
Serial.println( results->rawbuf[offset]);
|
|
Serial.println( "test against:");
|
|
Serial.println(results->rawbuf[offset]);
|
|
*/
|
|
/* Not seeing double keys from Mitsubishi
|
|
if (results->rawbuf[offset] < MITSUBISHI_DOUBLE_SPACE_USECS) {
|
|
// Serial.print("IR Gap found: ");
|
|
results->bits = 0;
|
|
results->value = REPEAT;
|
|
results->decode_type = MITSUBISHI;
|
|
return DECODED;
|
|
}
|
|
*/
|
|
|
|
offset++;
|
|
|
|
// Typical
|
|
// 14200 7 41 7 42 7 42 7 17 7 17 7 18 7 41 7 18 7 17 7 17 7 18 7 41 8 17 7 17 7 18 7 17 7
|
|
|
|
// Initial Space
|
|
if (!MATCH_MARK(results->rawbuf[offset], MITSUBISHI_HDR_SPACE)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
while (offset + 1 < irparams.rawlen) {
|
|
if (MATCH_MARK(results->rawbuf[offset], MITSUBISHI_ONE_MARK)) {
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (MATCH_MARK(results->rawbuf[offset], MITSUBISHI_ZERO_MARK)) {
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
// Serial.println("A"); Serial.println(offset); Serial.println(results->rawbuf[offset]);
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (!MATCH_SPACE(results->rawbuf[offset], MITSUBISHI_HDR_SPACE)) {
|
|
// Serial.println("B"); Serial.println(offset); Serial.println(results->rawbuf[offset]);
|
|
break;
|
|
}
|
|
offset++;
|
|
}
|
|
|
|
// Success
|
|
results->bits = (offset - 1) / 2;
|
|
if (results->bits < MITSUBISHI_BITS) {
|
|
results->bits = 0;
|
|
return ERR;
|
|
}
|
|
results->value = data;
|
|
results->decode_type = MITSUBISHI;
|
|
return DECODED;
|
|
}
|
|
|
|
// Gets one undecoded level at a time from the raw buffer.
|
|
// The RC5/6 decoding is easier if the data is broken into time intervals.
|
|
// E.g. if the buffer has MARK for 2 time intervals and SPACE for 1,
|
|
// successive calls to getRClevel will return MARK, MARK, SPACE.
|
|
// offset and used are updated to keep track of the current position.
|
|
// t1 is the time interval for a single bit in microseconds.
|
|
// Returns -1 for error (measured time interval is not a multiple of t1).
|
|
int IRrecv::getRClevel(decode_results *results, int *offset, int *used, int t1) {
|
|
if (*offset >= results->rawlen) {
|
|
// After end of recorded buffer, assume SPACE.
|
|
return SPACE;
|
|
}
|
|
int width = results->rawbuf[*offset];
|
|
int val = ((*offset) % 2) ? MARK : SPACE;
|
|
int correction = (val == MARK) ? MARK_EXCESS : - MARK_EXCESS;
|
|
|
|
int avail;
|
|
if (MATCH(width, t1 + correction)) {
|
|
avail = 1;
|
|
}
|
|
else if (MATCH(width, 2*t1 + correction)) {
|
|
avail = 2;
|
|
}
|
|
else if (MATCH(width, 3*t1 + correction)) {
|
|
avail = 3;
|
|
}
|
|
else {
|
|
return -1;
|
|
}
|
|
|
|
(*used)++;
|
|
if (*used >= avail) {
|
|
*used = 0;
|
|
(*offset)++;
|
|
}
|
|
#ifdef DEBUG
|
|
if (val == MARK) {
|
|
Serial.println("MARK");
|
|
}
|
|
else {
|
|
Serial.println("SPACE");
|
|
}
|
|
#endif
|
|
return val;
|
|
}
|
|
|
|
long IRrecv::decodeRC5(decode_results *results) {
|
|
if (irparams.rawlen < MIN_RC5_SAMPLES + 2) {
|
|
return ERR;
|
|
}
|
|
int offset = 1; // Skip gap space
|
|
long data = 0;
|
|
int used = 0;
|
|
// Get start bits
|
|
if (getRClevel(results, &offset, &used, RC5_T1) != MARK) return ERR;
|
|
if (getRClevel(results, &offset, &used, RC5_T1) != SPACE) return ERR;
|
|
if (getRClevel(results, &offset, &used, RC5_T1) != MARK) return ERR;
|
|
int nbits;
|
|
for (nbits = 0; offset < irparams.rawlen; nbits++) {
|
|
int levelA = getRClevel(results, &offset, &used, RC5_T1);
|
|
int levelB = getRClevel(results, &offset, &used, RC5_T1);
|
|
if (levelA == SPACE && levelB == MARK) {
|
|
// 1 bit
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (levelA == MARK && levelB == SPACE) {
|
|
// zero bit
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
return ERR;
|
|
}
|
|
}
|
|
|
|
// Success
|
|
results->bits = nbits;
|
|
results->value = data;
|
|
results->decode_type = RC5;
|
|
return DECODED;
|
|
}
|
|
|
|
long IRrecv::decodeRC6(decode_results *results) {
|
|
if (results->rawlen < MIN_RC6_SAMPLES) {
|
|
return ERR;
|
|
}
|
|
int offset = 1; // Skip first space
|
|
// Initial mark
|
|
if (!MATCH_MARK(results->rawbuf[offset], RC6_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (!MATCH_SPACE(results->rawbuf[offset], RC6_HDR_SPACE)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
long data = 0;
|
|
int used = 0;
|
|
// Get start bit (1)
|
|
if (getRClevel(results, &offset, &used, RC6_T1) != MARK) return ERR;
|
|
if (getRClevel(results, &offset, &used, RC6_T1) != SPACE) return ERR;
|
|
int nbits;
|
|
for (nbits = 0; offset < results->rawlen; nbits++) {
|
|
int levelA, levelB; // Next two levels
|
|
levelA = getRClevel(results, &offset, &used, RC6_T1);
|
|
if (nbits == 3) {
|
|
// T bit is double wide; make sure second half matches
|
|
if (levelA != getRClevel(results, &offset, &used, RC6_T1)) return ERR;
|
|
}
|
|
levelB = getRClevel(results, &offset, &used, RC6_T1);
|
|
if (nbits == 3) {
|
|
// T bit is double wide; make sure second half matches
|
|
if (levelB != getRClevel(results, &offset, &used, RC6_T1)) return ERR;
|
|
}
|
|
if (levelA == MARK && levelB == SPACE) { // reversed compared to RC5
|
|
// 1 bit
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (levelA == SPACE && levelB == MARK) {
|
|
// zero bit
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
return ERR; // Error
|
|
}
|
|
}
|
|
// Success
|
|
results->bits = nbits;
|
|
results->value = data;
|
|
results->decode_type = RC6;
|
|
return DECODED;
|
|
}
|
|
|
|
long IRrecv::decodePanasonic(decode_results *results) {
|
|
unsigned long long data = 0;
|
|
int offset = 1; // Dont skip first space
|
|
/*if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;*/
|
|
if (!MATCH_MARK(results->rawbuf[offset], PANASONIC_HDR_SPACE)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
// decode address
|
|
for (int i = 0; i < PANASONIC_BITS; i++) {
|
|
if (!MATCH(results->rawbuf[offset++], PANASONIC_BIT_MARK)) {
|
|
return ERR;
|
|
}
|
|
if (MATCH(results->rawbuf[offset],PANASONIC_ONE_SPACE)) {
|
|
data = (data << 1) | 1;
|
|
} else if (MATCH(results->rawbuf[offset],PANASONIC_ZERO_SPACE)) {
|
|
data <<= 1;
|
|
} else {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
}
|
|
results->value = (unsigned long)data;
|
|
results->panasonicAddress = (unsigned int)(data >> 32);
|
|
results->decode_type = PANASONIC;
|
|
results->bits = PANASONIC_BITS;
|
|
return DECODED;
|
|
}
|
|
|
|
long IRrecv::decodeLG(decode_results *results) {
|
|
long data = 0;
|
|
int offset = 1; // Skip first space
|
|
|
|
// Initial mark
|
|
if (!MATCH_MARK(results->rawbuf[offset], LG_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (irparams.rawlen < 2 * LG_BITS + 1 ) {
|
|
return ERR;
|
|
}
|
|
// Initial space
|
|
if (!MATCH_SPACE(results->rawbuf[offset], LG_HDR_SPACE)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
for (int i = 0; i < LG_BITS; i++) {
|
|
if (!MATCH_MARK(results->rawbuf[offset], LG_BIT_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (MATCH_SPACE(results->rawbuf[offset], LG_ONE_SPACE)) {
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (MATCH_SPACE(results->rawbuf[offset], LG_ZERO_SPACE)) {
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
}
|
|
//Stop bit
|
|
if (!MATCH_MARK(results->rawbuf[offset], LG_BIT_MARK)){
|
|
return ERR;
|
|
}
|
|
// Success
|
|
results->bits = LG_BITS;
|
|
results->value = data;
|
|
results->decode_type = LG;
|
|
return DECODED;
|
|
}
|
|
|
|
long IRrecv::decodeJVC(decode_results *results) {
|
|
long data = 0;
|
|
int offset = 1; // Skip first space
|
|
// Check for repeat
|
|
if (irparams.rawlen - 1 == 33 &&
|
|
MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK) &&
|
|
MATCH_MARK(results->rawbuf[irparams.rawlen-1], JVC_BIT_MARK)) {
|
|
results->bits = 0;
|
|
results->value = REPEAT;
|
|
results->decode_type = JVC;
|
|
return DECODED;
|
|
}
|
|
// Initial mark
|
|
if (!MATCH_MARK(results->rawbuf[offset], JVC_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (irparams.rawlen < 2 * JVC_BITS + 1 ) {
|
|
return ERR;
|
|
}
|
|
// Initial space
|
|
if (!MATCH_SPACE(results->rawbuf[offset], JVC_HDR_SPACE)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
for (int i = 0; i < JVC_BITS; i++) {
|
|
if (!MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (MATCH_SPACE(results->rawbuf[offset], JVC_ONE_SPACE)) {
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (MATCH_SPACE(results->rawbuf[offset], JVC_ZERO_SPACE)) {
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
}
|
|
//Stop bit
|
|
if (!MATCH_MARK(results->rawbuf[offset], JVC_BIT_MARK)){
|
|
return ERR;
|
|
}
|
|
// Success
|
|
results->bits = JVC_BITS;
|
|
results->value = data;
|
|
results->decode_type = JVC;
|
|
return DECODED;
|
|
}
|
|
|
|
// SAMSUNGs have a repeat only 4 items long
|
|
long IRrecv::decodeSAMSUNG(decode_results *results) {
|
|
long data = 0;
|
|
int offset = 0; // Dont skip first space
|
|
// Initial mark
|
|
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_HDR_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
// Check for repeat
|
|
if (irparams.rawlen == 4 &&
|
|
MATCH_SPACE(results->rawbuf[offset], SAMSUNG_RPT_SPACE) &&
|
|
MATCH_MARK(results->rawbuf[offset+1], SAMSUNG_BIT_MARK)) {
|
|
results->bits = 0;
|
|
results->value = REPEAT;
|
|
results->decode_type = SAMSUNG;
|
|
return DECODED;
|
|
}
|
|
if (irparams.rawlen < 2 * SAMSUNG_BITS + 2) {
|
|
return ERR;
|
|
}
|
|
// Initial space
|
|
if (!MATCH_SPACE(results->rawbuf[offset], SAMSUNG_HDR_SPACE)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
for (int i = 0; i < SAMSUNG_BITS; i++) {
|
|
if (!MATCH_MARK(results->rawbuf[offset], SAMSUNG_BIT_MARK)) {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ONE_SPACE)) {
|
|
data = (data << 1) | 1;
|
|
}
|
|
else if (MATCH_SPACE(results->rawbuf[offset], SAMSUNG_ZERO_SPACE)) {
|
|
data <<= 1;
|
|
}
|
|
else {
|
|
return ERR;
|
|
}
|
|
offset++;
|
|
}
|
|
// Success
|
|
results->bits = SAMSUNG_BITS;
|
|
results->value = data;
|
|
results->decode_type = SAMSUNG;
|
|
return DECODED;
|
|
}
|
|
|
|
/* -----------------------------------------------------------------------
|
|
* hashdecode - decode an arbitrary IR code.
|
|
* Instead of decoding using a standard encoding scheme
|
|
* (e.g. Sony, NEC, RC5), the code is hashed to a 32-bit value.
|
|
*
|
|
* The algorithm: look at the sequence of MARK signals, and see if each one
|
|
* is shorter (0), the same length (1), or longer (2) than the previous.
|
|
* Do the same with the SPACE signals. Hszh the resulting sequence of 0's,
|
|
* 1's, and 2's to a 32-bit value. This will give a unique value for each
|
|
* different code (probably), for most code systems.
|
|
*
|
|
* http://arcfn.com/2010/01/using-arbitrary-remotes-with-arduino.html
|
|
*/
|
|
|
|
// Compare two tick values, returning 0 if newval is shorter,
|
|
// 1 if newval is equal, and 2 if newval is longer
|
|
// Use a tolerance of 20%
|
|
int IRrecv::compare(unsigned int oldval, unsigned int newval) {
|
|
if (newval < oldval * .8) {
|
|
return 0;
|
|
}
|
|
else if (oldval < newval * .8) {
|
|
return 2;
|
|
}
|
|
else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// Use FNV hash algorithm: http://isthe.com/chongo/tech/comp/fnv/#FNV-param
|
|
#define FNV_PRIME_32 16777619
|
|
#define FNV_BASIS_32 2166136261
|
|
|
|
/* Converts the raw code values into a 32-bit hash code.
|
|
* Hopefully this code is unique for each button.
|
|
* This isn't a "real" decoding, just an arbitrary value.
|
|
*/
|
|
long IRrecv::decodeHash(decode_results *results) {
|
|
// Require at least 6 samples to prevent triggering on noise
|
|
if (results->rawlen < 6) {
|
|
return ERR;
|
|
}
|
|
long hash = FNV_BASIS_32;
|
|
for (int i = 1; i+2 < results->rawlen; i++) {
|
|
int value = compare(results->rawbuf[i], results->rawbuf[i+2]);
|
|
// Add value into the hash
|
|
hash = (hash * FNV_PRIME_32) ^ value;
|
|
}
|
|
results->value = hash;
|
|
results->bits = 32;
|
|
results->decode_type = UNKNOWN;
|
|
return DECODED;
|
|
}
|
|
|
|
// ---------------------------------------------------------------
|