-// Configuration paramters
-#define IR_LED 4 // GPIO the IR LED is connected to/controlled by. GPIO 4 = D2.
-#define HTTP_PORT 80 // The port the HTTP server is listening on.
+// Configuration parameters
+// GPIO the IR LED is connected to/controlled by. GPIO 4 = D2.
+#define IR_LED 4
+// define IR_LED 3 // For an ESP-01 we suggest you use RX/GPIO3/Pin 7.
+//
+// GPIO the IR RX module is connected to/controlled by. GPIO 14 = D5.
+// Comment this out to disable receiving/decoding IR messages entirely.
+#define IR_RX 14
+const uint16_t kHttpPort = 80; // The TCP port the HTTP server is listening on.
+// Name of the device you want in mDNS.
+// NOTE: Changing this will change the MQTT path too unless you override it
+// via MQTTprefix below.
+#define HOSTNAME "ir_server"
+
+// We obtain our network config via DHCP by default but allow an easy way to
+// use a static IP config.
+#define USE_STATIC_IP false // Change to 'true' if you don't want to use DHCP.
+#if USE_STATIC_IP
+const IPAddress kIPAddress = IPAddress(10, 0, 1, 78);
+const IPAddress kGateway = IPAddress(10, 0, 1, 1);
+const IPAddress kSubnetMask = IPAddress(255, 255, 255, 0);
+#endif // USE_STATIC_IP
#ifdef MQTT_ENABLE
// Address of your MQTT server.
#define MQTT_SERVER "10.20.0.253" // <=- CHANGE ME
-#define MQTT_PORT 1883 // Default port used by MQTT servers.
+const uint16_t kMqttPort = 1883; // Default port used by MQTT servers.
// Set if your MQTT server requires a Username & Password to connect.
const char* mqtt_user = "";
const char* mqtt_password = "";
-#define MQTT_RECONNECT_TIME 5000 // Delay(ms) between reconnect tries.
+const uint32_t kMqttReconnectTime = 5000; // Delay(ms) between reconnect tries.
-#define MQTTprefix "ir_server"
+#define MQTTprefix HOSTNAME // Change this if you want the MQTT topic to be
+ // independent of the hostname.
#define MQTTack MQTTprefix "/sent" // Topic we send back acknowledgements on
#define MQTTcommand MQTTprefix "/send" // Topic we get new commands from.
+#define MQTTrecv MQTTprefix "/received" // Topic we send received IRs to.
#endif // MQTT_ENABLE
// HTML arguments we will parse for IR code information.
@@ -147,27 +192,71 @@ const char* mqtt_password = "";
#define argData "code"
#define argBits "bits"
#define argRepeat "repeats"
-#define DEBUG True
+// Let's use a larger than normal buffer so we can handle AirCon remote codes.
+const uint16_t kCaptureBufferSize = 1024;
+#if DECODE_AC
+// Some A/C units have gaps in their protocols of ~40ms. e.g. Kelvinator
+// A value this large may swallow repeats of some protocols
+const uint8_t kCaptureTimeout = 50;
+#else // DECODE_AC
+// Suits most messages, while not swallowing many repeats.
+const uint8_t kCaptureTimeout = 15;
+#endif // DECODE_AC
+// Ignore unknown messages with <10 pulses
+const uint16_t kMinUnknownSize = 20;
+
+#define _MY_VERSION_ "v0.7.0"
+
+// Disable debug output if any of the IR pins are on the TX (D1) pin.
+#if (IR_LED != 1 && IR_RX != 1)
+#undef DEBUG
+#define DEBUG true // Change to 'false' to disable all serial output.
+#else
+#undef DEBUG
+#define DEBUG false
+#endif
+// NOTE: Make sure you set your Serial Monitor to the same speed.
+#define BAUD_RATE 115200 // Serial port Baud rate.
// Globals
-ESP8266WebServer server(HTTP_PORT);
+ESP8266WebServer server(kHttpPort);
IRsend irsend = IRsend(IR_LED);
+#ifdef IR_RX
+IRrecv irrecv(IR_RX, kCaptureBufferSize, kCaptureTimeout, true);
+decode_results capture; // Somewhere to store inbound IR messages.
+#endif // IR_RX
MDNSResponder mdns;
WiFiClient espClient;
WiFiManager wifiManager;
uint16_t *codeArray;
-uint32_t lastReconnectAttempt = 0; // MQTT last attemps reconnection number
+uint32_t lastReconnectAttempt = 0; // MQTT last attempt reconnection number
bool boot = true;
-bool ir_lock = false; // Primative locking for gating the IR LED.
+bool ir_lock = false; // Primitive locking for gating the IR LED.
+uint32_t sendReqCounter = 0;
+bool lastSendSucceeded = false; // Store the success status of the last send.
+uint32_t lastSendTime = 0;
+int8_t offset; // The calculated period offset for this chip and library.
#ifdef MQTT_ENABLE
+String lastMqttCmd = "None";
+uint32_t lastMqttCmdTime = 0;
+uint32_t lastConnectedTime = 0;
+uint32_t lastDisconnectedTime = 0;
+uint32_t mqttDisconnectCounter = 0;
+bool wasConnected = true;
+#ifdef IR_RX
+String lastIrReceived = "None";
+uint32_t lastIrReceivedTime = 0;
+uint32_t irRecvCounter = 0;
+#endif // IR_RX
+
+
// MQTT client parameters
void callback(char* topic, byte* payload, unsigned int length);
-PubSubClient mqtt_client(MQTT_SERVER, MQTT_PORT, callback, espClient);
+PubSubClient mqtt_client(MQTT_SERVER, kMqttPort, callback, espClient);
// Create a unique MQTT client id.
-const char* mqtt_clientid = String(MQTTprefix +
- String(ESP.getChipId(), HEX)).c_str();
+String mqtt_clientid = MQTTprefix + String(ESP.getChipId(), HEX);
#endif // MQTT_ENABLE
// Debug messages get sent to the serial port.
@@ -178,6 +267,50 @@ void debug(String str) {
#endif // DEBUG
}
+String timeSince(uint32_t const start) {
+ if (start == 0)
+ return "Never";
+ uint32_t diff = 0;
+ uint32_t now = millis();
+ if (start < now)
+ diff = now - start;
+ else
+ diff = UINT32_MAX - start + now;
+ diff /= 1000; // Convert to seconds.
+ if (diff == 0) return "Now";
+
+ // Note: millis() can only count up to 45 days, so uint8_t is safe.
+ uint8_t days = diff / (60 * 60 * 24);
+ uint8_t hours = (diff / (60 * 60)) % 24;
+ uint8_t minutes = (diff / 60) % 60;
+ uint8_t seconds = diff % 60;
+
+ String result = "";
+ if (days)
+ result += String(days) + " day";
+ if (days > 1) result += "s";
+ if (hours)
+ result += " " + String(hours) + " hour";
+ if (hours > 1) result += "s";
+ if (minutes)
+ result += " " + String(minutes) + " minute";
+ if (minutes > 1) result += "s";
+ if (seconds)
+ result += " " + String(seconds) + " second";
+ if (seconds > 1) result += "s";
+ result.trim();
+ return result + " ago";
+}
+
+// Quick and dirty check for any unsafe chars in a string
+// that may cause HTML shenanigans. e.g. An XSS.
+bool hasUnsafeHTMLChars(String input) {
+ static char unsafe[] = "';!-\"<>=&{}()";
+ for (uint8_t i = 0; unsafe[i]; i++)
+ if (input.indexOf(unsafe[i]) != -1) return true;
+ return false;
+}
+
// Root web page with example usage etc.
void handleRoot() {
server.send(200, "text/html",
@@ -185,13 +318,43 @@ void handleRoot() {
""
"ESP8266 IR MQTT Server
"
"
"
- "Connection details
"
- "IP address: " + WiFi.localIP().toString() + "
"
+ "Information
"
+ "IP address: " + WiFi.localIP().toString() + "
"
+ "Booted: " + timeSince(1) + "
" +
+ "Version: " _MY_VERSION_ "
"
+ "Period Offset: " + String(offset) + "us
"
+ "IR Lib Version: " _IRREMOTEESP8266_VERSION_ "
"
+ "ESP8266 Core Version: " + ESP.getCoreVersion() + "
"
+ "IR Send GPIO: " + String(IR_LED) + "
"
+ "Total send requests: " + String(sendReqCounter) + "
"
+ "Last message sent: " + String(lastSendSucceeded ? "Ok" : "FAILED") +
+ " (" + timeSince(lastSendTime) + ")
"
+#ifdef IR_RX
+ "IR Recv GPIO: " + String(IR_RX) + "
"
+ "Total IR Received: " + String(irRecvCounter) + "
"
+ "Last IR Received: " + lastIrReceived +
+ " (" + timeSince(lastIrReceivedTime) + ")
"
+#endif // IR_RX
+ "
"
#ifdef MQTT_ENABLE
- "MQTT server: " MQTT_SERVER ":" + String(MQTT_PORT) + " ("+
- (mqtt_client.connected() ? "Connected" : "Disconnected") + ")
"
+ "
MQTT Information
"
+ "Server: " MQTT_SERVER ":" + String(kMqttPort) + " (" +
+ (mqtt_client.connected() ? "Connected " + timeSince(lastDisconnectedTime)
+ : "Disconnected " + timeSince(lastConnectedTime)) +
+ ")
"
+ "Disconnections: " + String(mqttDisconnectCounter - 1) + "
"
+ "Client id: " + mqtt_clientid + "
"
"Command topic: " MQTTcommand "
"
- "Acknowledgements topic: " MQTTack "
"
+ "Acknowledgements topic: " MQTTack "
"
+#ifdef IR_RX
+ "IR Received topic: " MQTTrecv "
"
+#endif // IR_RX
+ "Last MQTT command seen: " +
+ // lastMqttCmd is unescaped untrusted input.
+ // Avoid any possible HTML/XSS when displaying it.
+ (hasUnsafeHTMLChars(lastMqttCmd) ?
+ "Contains unsafe HTML characters" : lastMqttCmd) +
+ " (" + timeSince(lastMqttCmdTime) + ")"
#endif // MQTT_ENABLE
"
"
"Hardcoded examples
"
@@ -222,15 +385,24 @@ void handleRoot() {
"Type: "
""
" Repeats: "
@@ -305,11 +479,32 @@ void handleRoot() {
" "
""
"
"
- "Send a Kelvinator A/C IR message
"
+ "
Send an Air Conditioner IR message
"
"
"
"
"
@@ -340,26 +535,245 @@ void handleReset() {
delay(1000);
}
-// Parse a Kelvinator A/C Hex String/code and send it.
-void parseStringAndSendKelv(const String str) {
- // str should be a 32 digit hexidecimal string.
- uint8_t offset = 0;
- uint8_t codeArray[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+// Parse an Air Conditioner A/C Hex String/code and send it.
+// Args:
+// irType: Nr. of the protocol we need to send.
+// str: A hexadecimal string containing the state to be sent.
+// Returns:
+// bool: Successfully sent or not.
+bool parseStringAndSendAirCon(const uint16_t irType, const String str) {
+ uint8_t strOffset = 0;
+ uint8_t state[kStateSizeMax] = {0}; // All array elements are set to 0.
+ uint16_t stateSize = 0;
+
if (str.startsWith("0x") || str.startsWith("0X"))
- offset = 2;
- for (int i = 0; i < 32; i++) {
- unsigned char c = tolower(str[i + offset]);
- uint8_t entry = 0;
+ strOffset = 2;
+ // Calculate how many hexadecimal characters there are.
+ uint16_t inputLength = str.length() - strOffset;
+ if (inputLength == 0) {
+ debug("Zero length AirCon code encountered. Ignored.");
+ return false; // No input. Abort.
+ }
+
+ switch (irType) { // Get the correct state size for the protocol.
+ case KELVINATOR:
+ stateSize = kKelvinatorStateLength;
+ break;
+ case TOSHIBA_AC:
+ stateSize = kToshibaACStateLength;
+ break;
+ case DAIKIN:
+ stateSize = kDaikinStateLength;
+ break;
+ case ELECTRA_AC:
+ stateSize = kElectraAcStateLength;
+ break;
+ case MITSUBISHI_AC:
+ stateSize = kMitsubishiACStateLength;
+ break;
+ case PANASONIC_AC:
+ stateSize = kPanasonicAcStateLength;
+ break;
+ case TROTEC:
+ stateSize = kTrotecStateLength;
+ break;
+ case ARGO:
+ stateSize = kArgoStateLength;
+ break;
+ case GREE:
+ stateSize = kGreeStateLength;
+ break;
+ case FUJITSU_AC:
+ // Fujitsu has four distinct & different size states, so make a best guess
+ // which one we are being presented with based on the number of
+ // hexadecimal digits provided. i.e. Zero-pad if you need to to get
+ // the correct length/byte size.
+ stateSize = inputLength / 2; // Every two hex chars is a byte.
+ // Use at least the minimum size.
+ stateSize = std::max(stateSize,
+ (uint16_t) (kFujitsuAcStateLengthShort - 1));
+ // If we think it isn't a "short" message.
+ if (stateSize > kFujitsuAcStateLengthShort)
+ // Then it has to be at least the smaller version of the "normal" size.
+ stateSize = std::max(stateSize, (uint16_t) (kFujitsuAcStateLength - 1));
+ // Lastly, it should never exceed the maximum "normal" size.
+ stateSize = std::min(stateSize, kFujitsuAcStateLength);
+ break;
+ case HAIER_AC:
+ stateSize = kHaierACStateLength;
+ break;
+ case HAIER_AC_YRW02:
+ stateSize = kHaierACYRW02StateLength;
+ break;
+ case HITACHI_AC:
+ stateSize = kHitachiAcStateLength;
+ break;
+ case HITACHI_AC1:
+ stateSize = kHitachiAc1StateLength;
+ break;
+ case HITACHI_AC2:
+ stateSize = kHitachiAc2StateLength;
+ break;
+ case WHIRLPOOL_AC:
+ stateSize = kWhirlpoolAcStateLength;
+ break;
+ case SAMSUNG_AC:
+ // Samsung has two distinct & different size states, so make a best guess
+ // which one we are being presented with based on the number of
+ // hexadecimal digits provided. i.e. Zero-pad if you need to to get
+ // the correct length/byte size.
+ stateSize = inputLength / 2; // Every two hex chars is a byte.
+ // Use at least the minimum size.
+ stateSize = std::max(stateSize, (uint16_t) (kSamsungAcStateLength));
+ // If we think it isn't a "normal" message.
+ if (stateSize > kSamsungAcStateLength)
+ // Then it probably the extended size.
+ stateSize = std::max(stateSize,
+ (uint16_t) (kSamsungAcExtendedStateLength));
+ // Lastly, it should never exceed the maximum "extended" size.
+ stateSize = std::min(stateSize, kSamsungAcExtendedStateLength);
+ break;
+ case MWM:
+ // MWM has variable size states, so make a best guess
+ // which one we are being presented with based on the number of
+ // hexadecimal digits provided. i.e. Zero-pad if you need to to get
+ // the correct length/byte size.
+ stateSize = inputLength / 2; // Every two hex chars is a byte.
+ // Use at least the minimum size.
+ stateSize = std::max(stateSize, (uint16_t) 3);
+ // Cap the maximum size.
+ stateSize = std::min(stateSize, kStateSizeMax);
+ break;
+ default: // Not a protocol we expected. Abort.
+ debug("Unexpected AirCon protocol detected. Ignoring.");
+ return false;
+ }
+ if (inputLength > stateSize * 2) {
+ debug("AirCon code to large for the given protocol.");
+ return false;
+ }
+
+ // Ptr to the least significant byte of the resulting state for this protocol.
+ uint8_t *statePtr = &state[stateSize - 1];
+
+ // Convert the string into a state array of the correct length.
+ for (uint16_t i = 0; i < inputLength; i++) {
+ // Grab the next least sigificant hexadecimal digit from the string.
+ uint8_t c = tolower(str[inputLength + strOffset - i - 1]);
if (isxdigit(c)) {
if (isdigit(c))
- codeArray[i / 2] += c - '0';
+ c -= '0';
else
- codeArray[i / 2] += c - 'a' + 10;
+ c = c - 'a' + 10;
+ } else {
+ debug("Aborting! Non-hexadecimal char found in AirCon state: " + str);
+ return false;
+ }
+ if (i % 2 == 1) { // Odd: Upper half of the byte.
+ *statePtr += (c << 4);
+ statePtr--; // Advance up to the next least significant byte of state.
+ } else { // Even: Lower half of the byte.
+ *statePtr = c;
}
- if (i % 2 == 0)
- codeArray[i / 2] <<= 4;
}
- irsend.sendKelvinator(reinterpret_cast(codeArray));
+
+ // Make the appropriate call for the protocol type.
+ switch (irType) {
+#if SEND_KELVINATOR
+ case KELVINATOR:
+ irsend.sendKelvinator(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_TOSHIBA_AC
+ case TOSHIBA_AC:
+ irsend.sendToshibaAC(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_DAIKIN
+ case DAIKIN:
+ irsend.sendDaikin(reinterpret_cast(state));
+ break;
+#endif
+#if MITSUBISHI_AC
+ case MITSUBISHI_AC:
+ irsend.sendMitsubishiAC(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_TROTEC
+ case TROTEC:
+ irsend.sendTrotec(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_ARGO
+ case ARGO:
+ irsend.sendArgo(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_GREE
+ case GREE:
+ irsend.sendGree(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_FUJITSU_AC
+ case FUJITSU_AC:
+ irsend.sendFujitsuAC(reinterpret_cast(state), stateSize);
+ break;
+#endif
+#if SEND_HAIER_AC
+ case HAIER_AC:
+ irsend.sendHaierAC(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_HAIER_AC_YRW02
+ case HAIER_AC_YRW02:
+ irsend.sendHaierACYRW02(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_HITACHI_AC
+ case HITACHI_AC:
+ irsend.sendHitachiAC(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_HITACHI_AC1
+ case HITACHI_AC1:
+ irsend.sendHitachiAC1(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_HITACHI_AC2
+ case HITACHI_AC2:
+ irsend.sendHitachiAC2(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_WHIRLPOOL_AC
+ case WHIRLPOOL_AC:
+ irsend.sendWhirlpoolAC(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_SAMSUNG_AC
+ case SAMSUNG_AC:
+ irsend.sendSamsungAC(reinterpret_cast(state), stateSize);
+ break;
+#endif
+#if SEND_ELECTRA_AC
+ case ELECTRA_AC:
+ irsend.sendElectraAC(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_PANASONIC_AC
+ case PANASONIC_AC:
+ irsend.sendPanasonicAC(reinterpret_cast(state));
+ break;
+#endif
+#if SEND_MWM_
+ case MWM:
+ irsend.sendMWM(reinterpret_cast(state), stateSize);
+ break;
+#endif
+ default:
+ debug("Unexpected AirCon type in send request. Not sent.");
+ return false;
+ }
+ return true; // We were successful as far as we can tell.
}
// Count how many values are in the String.
@@ -399,6 +813,7 @@ uint16_t * newCodeArray(const uint16_t size) {
return result;
}
+#if SEND_GLOBALCACHE
// Parse a GlobalCache String/code and send it.
// Args:
// str: A GlobalCache formatted String of comma separated numbers.
@@ -407,7 +822,9 @@ uint16_t * newCodeArray(const uint16_t size) {
// 20,20,20,20,20,20,20,20,20,20,20,20,20,63,20,20,20,63,20,63,20,
// 63,20,63,20,63,20,63,20,1798"
// Note: The leading "1:1,1," of normal GC codes should be removed.
-void parseStringAndSendGC(const String str) {
+// Returns:
+// bool: Successfully sent or not.
+bool parseStringAndSendGC(const String str) {
uint16_t count;
uint16_t *code_array;
String tmp_str;
@@ -437,22 +854,29 @@ void parseStringAndSendGC(const String str) {
irsend.sendGC(code_array, count); // All done. Send it.
free(code_array); // Free up the memory allocated.
+ if (count > 0)
+ return true; // We sent something.
+ return false; // We probably didn't.
}
+#endif // SEND_GLOBALCACHE
+#if SEND_PRONTO
// Parse a Pronto Hex String/code and send it.
// Args:
-// str: A comma-separated String of nr. of repeats, then hexidecimal numbers.
+// str: A comma-separated String of nr. of repeats, then hexadecimal numbers.
// e.g. "R1,0000,0067,0000,0015,0060,0018,0018,0018,0030,0018,0030,0018,
// 0030,0018,0018,0018,0030,0018,0018,0018,0018,0018,0030,0018,
// 0018,0018,0030,0018,0030,0018,0030,0018,0018,0018,0018,0018,
// 0030,0018,0018,0018,0018,0018,0030,0018,0018,03f6"
// or
// "0000,0067,0000,0015,0060,0018". i.e. without the Repeat value
-// Requires at least PRONTO_MIN_LENGTH comma-separated values.
+// Requires at least kProntoMinLength comma-separated values.
// sendPronto() only supports raw pronto code types, thus so does this.
// repeats: Nr. of times the message is to be repeated.
// This value is ignored if an embeddd repeat is found in str.
-void parseStringAndSendPronto(const String str, uint16_t repeats) {
+// Returns:
+// bool: Successfully sent or not.
+bool parseStringAndSendPronto(const String str, uint16_t repeats) {
uint16_t count;
uint16_t *code_array;
int16_t index = -1;
@@ -470,8 +894,8 @@ void parseStringAndSendPronto(const String str, uint16_t repeats) {
count--; // We don't count the repeats value as part of the code array.
}
- // We need at least PRONTO_MIN_LENGTH values for the code part.
- if (count < PRONTO_MIN_LENGTH) return;
+ // We need at least kProntoMinLength values for the code part.
+ if (count < kProntoMinLength) return false;
// Now we know how many there are, allocate the memory to store them all.
code_array = newCodeArray(count);
@@ -481,7 +905,7 @@ void parseStringAndSendPronto(const String str, uint16_t repeats) {
count = 0;
do {
index = str.indexOf(',', start_from);
- // Convert the hexidecimal value string to an unsigned integer.
+ // Convert the hexadecimal value string to an unsigned integer.
code_array[count] = strtoul(str.substring(start_from, index).c_str(),
NULL, 16);
start_from = index + 1;
@@ -490,15 +914,22 @@ void parseStringAndSendPronto(const String str, uint16_t repeats) {
irsend.sendPronto(code_array, count, repeats); // All done. Send it.
free(code_array); // Free up the memory allocated.
+ if (count > 0)
+ return true; // We sent something.
+ return false; // We probably didn't.
}
+#endif // SEND_PRONTO
-// Parse a IRremote Raw Hex String/code and send it.
+#if SEND_RAW
+// Parse an IRremote Raw Hex String/code and send it.
// Args:
// str: A comma-separated String containing the freq and raw IR data.
// e.g. "38000,9000,4500,600,1450,600,900,650,1500,..."
// Requires at least two comma-separated values.
// First value is the transmission frequency in Hz or kHz.
-void parseStringAndSendRaw(const String str) {
+// Returns:
+// bool: Successfully sent or not.
+bool parseStringAndSendRaw(const String str) {
uint16_t count;
uint16_t freq = 38000; // Default to 38kHz.
uint16_t *raw_array;
@@ -508,7 +939,7 @@ void parseStringAndSendRaw(const String str) {
// We expect the frequency as the first comma separated value, so we need at
// least two values. If not, bail out.
- if (count < 2) return;
+ if (count < 2) return false;
count--; // We don't count the frequency value as part of the raw array.
// Now we know how many there are, allocate the memory to store them all.
@@ -530,7 +961,11 @@ void parseStringAndSendRaw(const String str) {
irsend.sendRaw(raw_array, count, freq); // All done. Send it.
free(raw_array); // Free up the memory allocated.
+ if (count > 0)
+ return true; // We sent something.
+ return false; // We probably didn't.
}
+#endif // SEND_RAW
// Parse the URL args to find the IR code.
void handleIr() {
@@ -553,7 +988,8 @@ void handleIr() {
repeat = atoi(server.arg(i).c_str());
}
debug("New code received via HTTP");
- sendIRCode(ir_type, data, data_str.c_str(), nbits, repeat);
+ lastSendSucceeded = sendIRCode(ir_type, data, data_str.c_str(), nbits,
+ repeat);
handleRoot();
}
@@ -576,6 +1012,10 @@ void setup_wifi() {
// We start by connecting to a WiFi network
wifiManager.setTimeout(300); // Time out after 5 mins.
+#if USE_STATIC_IP
+ // Use a static IP config rather than the one supplied via DHCP.
+ wifiManager.setSTAStaticIPConfig(kIPAddress, kGateway, kSubnetMask);
+#endif // USE_STATIC_IP
if (!wifiManager.autoConnect()) {
debug("Wifi failed to connect and hit timeout.");
delay(3000);
@@ -584,14 +1024,27 @@ void setup_wifi() {
delay(5000);
}
- debug("WiFi connected. IP address: " + WiFi.localIP());
+ debug("WiFi connected. IP address: " + WiFi.localIP().toString());
}
void setup(void) {
irsend.begin();
+ offset = irsend.calibrate();
+#if IR_RX
+#if DECODE_HASH
+ // Ignore messages with less than minimum on or off pulses.
+ irrecv.setUnknownThreshold(kMinUnknownSize);
+#endif // DECODE_HASH
+ irrecv.enableIRIn(); // Start the receiver
+#endif // IR_RX
#ifdef DEBUG
- Serial.begin(115200);
+ // Use SERIAL_TX_ONLY so that the RX pin can be freed up for GPIO/IR use.
+ Serial.begin(BAUD_RATE, SERIAL_8N1, SERIAL_TX_ONLY);
+ while (!Serial) // Wait for the serial connection to be establised.
+ delay(50);
+ Serial.println();
+ debug("IRMQTTServer " _MY_VERSION_" has booted.");
#endif // DEBUG
setup_wifi();
@@ -601,7 +1054,7 @@ void setup(void) {
lastReconnectAttempt = 0;
- if (mdns.begin(MQTTprefix, WiFi.localIP())) {
+ if (mdns.begin(HOSTNAME, WiFi.localIP())) {
debug("MDNS responder started");
}
@@ -667,12 +1120,13 @@ bool reconnect() {
while (!mqtt_client.connected() && tries <= 3) {
int connected = false;
// Attempt to connect
- debug("Attempting MQTT connection to " MQTT_SERVER ":" + String(MQTT_PORT) +
+ debug("Attempting MQTT connection to " MQTT_SERVER ":" + String(kMqttPort) +
"... ");
if (mqtt_user && mqtt_password)
- connected = mqtt_client.connect(mqtt_clientid, mqtt_user, mqtt_password);
+ connected = mqtt_client.connect(mqtt_clientid.c_str(), mqtt_user,
+ mqtt_password);
else
- connected = mqtt_client.connect(mqtt_clientid);
+ connected = mqtt_client.connect(mqtt_clientid.c_str());
if (connected) {
// Once connected, publish an announcement...
mqtt_client.publish(MQTTack, "Connected");
@@ -692,32 +1146,57 @@ bool reconnect() {
#endif // MQTT_ENABLE
void loop(void) {
- server.handleClient();
+ server.handleClient(); // Handle any web activity
#ifdef MQTT_ENABLE
+ uint32_t now = millis();
// MQTT client connection management
if (!mqtt_client.connected()) {
- uint32_t now = millis();
- // Reconnect if it's longer than MQTT_RECONNECT_TIME since we last tried.
- if (now - lastReconnectAttempt > MQTT_RECONNECT_TIME) {
+ if (wasConnected) {
+ lastDisconnectedTime = now;
+ wasConnected = false;
+ mqttDisconnectCounter++;
+ }
+ // Reconnect if it's longer than kMqttReconnectTime since we last tried.
+ if (now - lastReconnectAttempt > kMqttReconnectTime) {
lastReconnectAttempt = now;
debug("client mqtt not connected, trying to connect");
// Attempt to reconnect
if (reconnect()) {
lastReconnectAttempt = 0;
+ wasConnected = true;
if (boot) {
mqtt_client.publish(MQTTack, "IR Server just booted");
boot = false;
} else {
- mqtt_client.publish(MQTTack, "IR Server just (re)connected to MQTT");
+ String text = "IR Server just (re)connected to MQTT. "
+ "Lost connection about " + timeSince(lastConnectedTime);
+ mqtt_client.publish(MQTTack, text.c_str());
}
+ lastConnectedTime = now;
+ debug("successful client mqtt connection");
}
}
} else {
+ lastConnectedTime = now;
// MQTT loop
mqtt_client.loop();
}
#endif // MQTT_ENABLE
+#ifdef IR_RX
+ // Check if an IR code has been received via the IR RX module.
+ if (irrecv.decode(&capture)) {
+ lastIrReceivedTime = millis();
+ lastIrReceived = String(capture.decode_type) + "," +
+ resultToHexidecimal(&capture);
+ // If it isn't an AC code, add the bits.
+ if (!hasACState(capture.decode_type))
+ lastIrReceived += "," + String(capture.bits);
+ mqtt_client.publish(MQTTrecv, lastIrReceived.c_str());
+ irRecvCounter++;
+ debug("Incoming IR message sent to MQTT: " + lastIrReceived);
+ }
+#endif // IR_RX
delay(100);
}
@@ -749,149 +1228,291 @@ uint64_t getUInt64fromHex(char const *str) {
// code_str: The unparsed code to be sent. Used by complex protocol encodings.
// bits: Nr. of bits in the protocol. 0 means use the protocol's default.
// repeat: Nr. of times the message is to be repeated. (Not all protcols.)
-void sendIRCode(int const ir_type, uint64_t const code, char const * code_str,
+// Returns:
+// bool: Successfully sent or not.
+bool sendIRCode(int const ir_type, uint64_t const code, char const * code_str,
uint16_t bits, uint16_t repeat) {
// Create a pseudo-lock so we don't try to send two codes at the same time.
while (ir_lock)
delay(20);
ir_lock = true;
+ bool success = true; // Assume success.
+
// send the IR message.
switch (ir_type) {
+#if SEND_RC5
case RC5: // 1
if (bits == 0)
- bits = RC5_BITS;
+ bits = kRC5Bits;
irsend.sendRC5(code, bits, repeat);
break;
+#endif
+#if SEND_RC6
case RC6: // 2
if (bits == 0)
- bits = RC6_MODE0_BITS;
+ bits = kRC6Mode0Bits;
irsend.sendRC6(code, bits, repeat);
break;
+#endif
+#if SEND_NEC
case NEC: // 3
if (bits == 0)
- bits = NEC_BITS;
+ bits = kNECBits;
irsend.sendNEC(code, bits, repeat);
break;
+#endif
+#if SEND_SONY
case SONY: // 4
if (bits == 0)
- bits = SONY_12_BITS;
- repeat = std::max(repeat, (uint16_t) SONY_MIN_REPEAT);
+ bits = kSony12Bits;
+ repeat = std::max(repeat, kSonyMinRepeat);
irsend.sendSony(code, bits, repeat);
break;
+#endif
+#if SEND_PANASONIC
case PANASONIC: // 5
if (bits == 0)
- bits = PANASONIC_BITS;
+ bits = kPanasonicBits;
irsend.sendPanasonic64(code, bits, repeat);
break;
+#endif
+#if SEND_JVC
case JVC: // 6
if (bits == 0)
- bits = JVC_BITS;
+ bits = kJvcBits;
irsend.sendJVC(code, bits, repeat);
break;
+#endif
+#if SEND_SAMSUNG
case SAMSUNG: // 7
if (bits == 0)
- bits = SAMSUNG_BITS;
+ bits = kSamsungBits;
irsend.sendSAMSUNG(code, bits, repeat);
break;
+#endif
+#if SEND_WHYNTER
case WHYNTER: // 8
if (bits == 0)
- bits = WHYNTER_BITS;
+ bits = kWhynterBits;
irsend.sendWhynter(code, bits, repeat);
break;
+#endif
+#if SEND_AIWA_RC_T501
case AIWA_RC_T501: // 9
if (bits == 0)
- bits = AIWA_RC_T501_BITS;
- repeat = std::max(repeat, (uint16_t) AIWA_RC_T501_MIN_REPEAT);
+ bits = kAiwaRcT501Bits;
+ repeat = std::max(repeat, kAiwaRcT501MinRepeats);
irsend.sendAiwaRCT501(code, bits, repeat);
break;
+#endif
+#if SEND_LG
case LG: // 10
if (bits == 0)
- bits = LG_BITS;
+ bits = kLgBits;
irsend.sendLG(code, bits, repeat);
break;
+#endif
+#if SEND_MITSUBISHI
case MITSUBISHI: // 12
if (bits == 0)
- bits = MITSUBISHI_BITS;
- repeat = std::max(repeat, (uint16_t) MITSUBISHI_MIN_REPEAT);
+ bits = kMitsubishiBits;
+ repeat = std::max(repeat, kMitsubishiMinRepeat);
irsend.sendMitsubishi(code, bits, repeat);
break;
+#endif
+#if SEND_DISH
case DISH: // 13
if (bits == 0)
- bits = DISH_BITS;
- repeat = std::max(repeat, (uint16_t) DISH_MIN_REPEAT);
+ bits = kDishBits;
+ repeat = std::max(repeat, kDishMinRepeat);
irsend.sendDISH(code, bits, repeat);
break;
+#endif
+#if SEND_SHARP
case SHARP: // 14
if (bits == 0)
- bits = SHARP_BITS;
+ bits = kSharpBits;
irsend.sendSharpRaw(code, bits, repeat);
break;
+#endif
+#if SEND_COOLIX
case COOLIX: // 15
if (bits == 0)
- bits = COOLIX_BITS;
+ bits = kCoolixBits;
irsend.sendCOOLIX(code, bits, repeat);
break;
+#endif
+ case DAIKIN: // 16
+ case KELVINATOR: // 18
+ case MITSUBISHI_AC: // 20
+ case GREE: // 24
+ case ARGO: // 27
+ case TROTEC: // 28
+ case TOSHIBA_AC: // 32
+ case FUJITSU_AC: // 33
+ case HAIER_AC: // 38
+ case HAIER_AC_YRW02: // 44
+ case HITACHI_AC: // 40
+ case HITACHI_AC1: // 41
+ case HITACHI_AC2: // 42
+ case WHIRLPOOL_AC: // 45
+ case SAMSUNG_AC: // 46
+ case ELECTRA_AC: // 48
+ case PANASONIC_AC: // 49
+ case MWM: // 52
+ success = parseStringAndSendAirCon(ir_type, code_str);
+ break;
+#if SEND_DENON
case DENON: // 17
if (bits == 0)
bits = DENON_BITS;
irsend.sendDenon(code, bits, repeat);
break;
- case KELVINATOR: // 18
- parseStringAndSendKelv(code_str);
- break;
+#endif
+#if SEND_SHERWOOD
case SHERWOOD: // 19
if (bits == 0)
- bits = SHERWOOD_BITS;
- repeat = std::max(repeat, (uint16_t) SHERWOOD_MIN_REPEAT);
+ bits = kSherwoodBits;
+ repeat = std::max(repeat, kSherwoodMinRepeat);
irsend.sendSherwood(code, bits, repeat);
break;
+#endif
+#if SEND_RCMM
case RCMM: // 21
if (bits == 0)
- bits == RCMM_BITS;
+ bits = kRCMMBits;
irsend.sendRCMM(code, bits, repeat);
break;
+#endif
+#if SEND_SANYO
case SANYO_LC7461: // 22
if (bits == 0)
- bits = SANYO_LC7461_BITS;
+ bits = kSanyoLC7461Bits;
irsend.sendSanyoLC7461(code, bits, repeat);
break;
+#endif
+#if SEND_RC5
case RC5X: // 23
if (bits == 0)
- bits = RC5X_BITS;
+ bits = kRC5XBits;
irsend.sendRC5(code, bits, repeat);
+ break;
+#endif
+#if SEND_PRONTO
case PRONTO: // 25
- parseStringAndSendPronto(code_str, repeat);
+ success = parseStringAndSendPronto(code_str, repeat);
break;
+#endif
+#if SEND_NIKAI
case NIKAI: // 29
if (bits == 0)
- bits = NIKAI_BITS;
+ bits = kNikaiBits;
irsend.sendNikai(code, bits, repeat);
break;
+#endif
+#if SEND_RAW
case RAW: // 30
- parseStringAndSendRaw(code_str);
+ success = parseStringAndSendRaw(code_str);
break;
+#endif
+#if SEND_GLOBALCACHE
case GLOBALCACHE: // 31
- parseStringAndSendGC(code_str);
+ success = parseStringAndSendGC(code_str);
break;
- }
+#endif
+#if SEND_MIDEA
+ case MIDEA: // 34
+ if (bits == 0)
+ bits = kMideaBits;
+ irsend.sendMidea(code, bits, repeat);
+ break;
+#endif
+#if SEND_MAGIQUEST
+ case MAGIQUEST: // 35
+ if (bits == 0)
+ bits = kMagiquestBits;
+ irsend.sendMagiQuest(code, bits, repeat);
+ break;
+#endif
+#if SEND_LASERTAG
+ case LASERTAG: // 36
+ if (bits == 0)
+ bits = kLasertagBits;
+ irsend.sendLasertag(code, bits, repeat);
+ break;
+#endif
+#if SEND_CARRIER_AC
+ case CARRIER_AC: // 37
+ if (bits == 0)
+ bits = kCarrierAcBits;
+ irsend.sendCarrierAC(code, bits, repeat);
+ break;
+#endif
+#if SEND_MITSUBISHI2
+ case MITSUBISHI2: // 39
+ if (bits == 0)
+ bits = kMitsubishiBits;
+ repeat = std::max(repeat, kMitsubishiMinRepeat);
+ irsend.sendMitsubishi2(code, bits, repeat);
+ break;
+#endif
+#if SEND_GICABLE
+ case GICABLE: // 43
+ if (bits == 0)
+ bits = kGicableBits;
+ repeat = std::max(repeat, kGicableMinRepeat);
+ irsend.sendGICable(code, bits, repeat);
+ break;
+#endif
+#if SEND_LUTRON
+ case LUTRON: // 47
+ if (bits == 0)
+ bits = kLutronBits;
+ irsend.sendLutron(code, bits, repeat);
+ break;
+#endif
+#if SEND_PIONEER
+ case PIONEER: // 50
+ if (bits == 0)
+ bits = kPioneerBits;
+ irsend.sendPioneer(code, bits, repeat);
+ break;
+#endif
+#if SEND_LG
+ case LG2: // 51
+ if (bits == 0)
+ bits = kLgBits;
+ irsend.sendLG2(code, bits, repeat);
+ break;
+#endif
+ default:
+ // If we got here, we didn't know how to send it.
+ success = false;
+ }
+ lastSendTime = millis();
// Release the lock.
ir_lock = false;
- // Indicate that we sent the message.
- debug("Sent the IR message.");
+ // Indicate that we sent the message or not.
+ if (success) {
+ sendReqCounter++;
+ debug("Sent the IR message:");
+ } else {
+ debug("Failed to send IR Message:");
+ }
debug("Type: " + String(ir_type));
- switch (ir_type) {
- case KELVINATOR:
- case PRONTO:
- case RAW:
- case GLOBALCACHE:
- debug("Code: ");
- debug(code_str);
- debug("Repeats: " + String(repeat));
- // Confirm what we were asked to send was sent.
+ // For "long" codes we basically repeat what we got.
+ if (hasACState((decode_type_t) ir_type) ||
+ ir_type == PRONTO ||
+ ir_type == RAW ||
+ ir_type == GLOBALCACHE) {
+ debug("Code: ");
+ debug(code_str);
+ // Confirm what we were asked to send was sent.
#ifdef MQTT_ENABLE
+ if (success) {
if (ir_type == PRONTO && repeat > 0)
mqtt_client.publish(MQTTack, (String(ir_type) + ",R" +
String(repeat) + "," +
@@ -899,20 +1520,21 @@ void sendIRCode(int const ir_type, uint64_t const code, char const * code_str,
else
mqtt_client.publish(MQTTack, (String(ir_type) + "," +
String(code_str)).c_str());
+ }
#endif // MQTT_ENABLE
- break;
- default:
- debug("Code: 0x" + uint64ToString(code, 16));
- debug("Bits: " + String(bits));
- debug("Repeats: " + String(repeat));
-
+ } else { // For "short" codes, we break it down a bit more before we report.
+ debug("Code: 0x" + uint64ToString(code, 16));
+ debug("Bits: " + String(bits));
+ debug("Repeats: " + String(repeat));
#ifdef MQTT_ENABLE
+ if (success)
mqtt_client.publish(MQTTack, (String(ir_type) + "," +
uint64ToString(code, 16)
+ "," + String(bits) + "," +
String(repeat)).c_str());
#endif // MQTT_ENABLE
}
+ return success;
}
#ifdef MQTT_ENABLE
@@ -924,9 +1546,12 @@ void receivingMQTT(String const topic_name, String const callback_str) {
debug("Receiving data by MQTT topic " + topic_name);
- // Make a copy of the callback string as strtok destorys it.
+ // Make a copy of the callback string as strtok destroys it.
char* callback_c_str = strdup(callback_str.c_str());
debug("MQTT Payload (raw): " + callback_str);
+ // Save the message as the last command seen (global).
+ lastMqttCmd = callback_str;
+ lastMqttCmdTime = millis();
// Get the numeric protocol type.
int ir_type = strtoul(strtok_r(callback_c_str, ",", &tok_ptr), NULL, 10);
@@ -952,9 +1577,10 @@ void receivingMQTT(String const topic_name, String const callback_str) {
// send received MQTT value by IR signal
- sendIRCode(ir_type, code,
- callback_str.substring(callback_str.indexOf(",") + 1).c_str(),
- nbits, repeat);
+ lastSendSucceeded = sendIRCode(
+ ir_type, code,
+ callback_str.substring(callback_str.indexOf(",") + 1).c_str(),
+ nbits, repeat);
}
// Callback function, when the gateway receive an MQTT value on the topics
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRMQTTServer/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/IRMQTTServer/platformio.ini
similarity index 96%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRMQTTServer/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRMQTTServer/platformio.ini
index c87e5696236b..27b44ddca5fd 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/IRMQTTServer/platformio.ini
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/IRMQTTServer/platformio.ini
@@ -7,7 +7,7 @@ build_flags = -DMQTT_MAX_PACKET_SIZE=512
lib_deps_builtin =
lib_deps_external =
PubSubClient
- WifiManager@0.12
+ WifiManager@0.14
[env:nodemcuv2]
platform = espressif8266
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRServer/IRServer.ino b/lib/IRremoteESP8266-2.5.2.03/examples/IRServer/IRServer.ino
similarity index 88%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRServer/IRServer.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRServer/IRServer.ino
index 82f2e7dd7205..b378d3bd582c 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/IRServer/IRServer.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/IRServer/IRServer.ino
@@ -3,7 +3,8 @@
* Version 0.2 June, 2017
* Copyright 2015 Mark Szabo
*
- * An IR LED circuit *MUST* be connected to ESP8266 pin 4 (D2).
+ * An IR LED circuit *MUST* be connected to the ESP8266 on a pin
+ * as specified by kIrLed below.
*
* TL;DR: The IR LED needs to be driven by a transistor for a good result.
*
@@ -35,13 +36,15 @@
#include
#include
-const char* ssid = ".....";
-const char* password = ".....";
+const char* kSsid = ".....";
+const char* kPassword = ".....";
MDNSResponder mdns;
ESP8266WebServer server(80);
-IRsend irsend(4); // An IR LED is controlled by GPIO pin 4 (D2)
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+
+IRsend irsend(kIrLed); // Set the GPIO to be used to sending the message.
void handleRoot() {
server.send(200, "text/html",
@@ -61,7 +64,9 @@ void handleIr() {
for (uint8_t i = 0; i < server.args(); i++) {
if (server.argName(i) == "code") {
uint32_t code = strtoul(server.arg(i).c_str(), NULL, 10);
+#if SEND_NEC
irsend.sendNEC(code, 32);
+#endif // SEND_NEC
}
}
handleRoot();
@@ -85,7 +90,7 @@ void setup(void) {
irsend.begin();
Serial.begin(115200);
- WiFi.begin(ssid, password);
+ WiFi.begin(kSsid, kPassword);
Serial.println("");
// Wait for connection
@@ -95,9 +100,9 @@ void setup(void) {
}
Serial.println("");
Serial.print("Connected to ");
- Serial.println(ssid);
+ Serial.println(kSsid);
Serial.print("IP address: ");
- Serial.println(WiFi.localIP());
+ Serial.println(WiFi.localIP().toString());
if (mdns.begin("esp8266", WiFi.localIP())) {
Serial.println("MDNS responder started");
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRServer/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/IRServer/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRServer/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRServer/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDemo/IRrecvDemo.ino b/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDemo/IRrecvDemo.ino
similarity index 66%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDemo/IRrecvDemo.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDemo/IRrecvDemo.ino
index ae9ed66f9f43..09babe4febe0 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDemo/IRrecvDemo.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDemo/IRrecvDemo.ino
@@ -1,6 +1,9 @@
/*
* IRremoteESP8266: IRrecvDemo - demonstrates receiving IR codes with IRrecv
- * An IR detector/demodulator must be connected to the input RECV_PIN.
+ * This is very simple teaching code to show you how to use the library.
+ * If you are trying to decode your Infra-Red remote(s) for later replay,
+ * use the IRrecvDumpV2.ino example code instead of this.
+ * An IR detector/demodulator must be connected to the input kRecvPin.
* Copyright 2009 Ken Shirriff, http://arcfn.com
* Example circuit diagram:
* https://github.com/markszabo/IRremoteESP8266/wiki#ir-receiving
@@ -22,15 +25,20 @@
// An IR detector/demodulator is connected to GPIO pin 14(D5 on a NodeMCU
// board).
-uint16_t RECV_PIN = 14;
+const uint16_t kRecvPin = 14;
-IRrecv irrecv(RECV_PIN);
+IRrecv irrecv(kRecvPin);
decode_results results;
void setup() {
Serial.begin(115200);
irrecv.enableIRIn(); // Start the receiver
+ while (!Serial) // Wait for the serial connection to be establised.
+ delay(50);
+ Serial.println();
+ Serial.print("IRrecvDemo is now running and waiting for IR message on Pin ");
+ Serial.println(kRecvPin);
}
void loop() {
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDemo/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDemo/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDemo/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDemo/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDump/IRrecvDump.ino b/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDump/IRrecvDump.ino
similarity index 96%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDump/IRrecvDump.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDump/IRrecvDump.ino
index 85644969550d..34f10dc83fe8 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDump/IRrecvDump.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDump/IRrecvDump.ino
@@ -86,10 +86,10 @@ void dump(decode_results *results) {
if (i % 100 == 0)
yield(); // Preemptive yield every 100th entry to feed the WDT.
if (i & 1) {
- Serial.print(results->rawbuf[i] * RAWTICK, DEC);
+ Serial.print(results->rawbuf[i] * kRawTick, DEC);
} else {
Serial.print(", ");
- Serial.print((uint32_t) results->rawbuf[i] * RAWTICK, DEC);
+ Serial.print((uint32_t) results->rawbuf[i] * kRawTick, DEC);
}
}
Serial.println("};");
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDump/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDump/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDump/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDump/platformio.ini
diff --git a/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDumpV2/IRrecvDumpV2.ino b/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDumpV2/IRrecvDumpV2.ino
new file mode 100644
index 000000000000..d72e0814ce45
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDumpV2/IRrecvDumpV2.ino
@@ -0,0 +1,262 @@
+/*
+ * IRremoteESP8266: IRrecvDumpV2 - dump details of IR codes with IRrecv
+ * An IR detector/demodulator must be connected to the input kRecvPin.
+ *
+ * Copyright 2009 Ken Shirriff, http://arcfn.com
+ * Copyright 2017 David Conran
+ *
+ * Example circuit diagram:
+ * https://github.com/markszabo/IRremoteESP8266/wiki#ir-receiving
+ *
+ * Changes:
+ * Version 0.4 July, 2018
+ * - Minor improvements and more A/C unit support.
+ * Version 0.3 November, 2017
+ * - Support for A/C decoding for some protcols.
+ * Version 0.2 April, 2017
+ * - Decode from a copy of the data so we can start capturing faster thus
+ * reduce the likelihood of miscaptures.
+ * Based on Ken Shirriff's IrsendDemo Version 0.1 July, 2009,
+ */
+
+#ifndef UNIT_TEST
+#include
+#endif
+#include
+#include
+#include
+// The following are only needed for extended decoding of A/C Messages
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+// ==================== start of TUNEABLE PARAMETERS ====================
+// An IR detector/demodulator is connected to GPIO pin 14
+// e.g. D5 on a NodeMCU board.
+const uint16_t kRecvPin = 14;
+
+// The Serial connection baud rate.
+// i.e. Status message will be sent to the PC at this baud rate.
+// Try to avoid slow speeds like 9600, as you will miss messages and
+// cause other problems. 115200 (or faster) is recommended.
+// NOTE: Make sure you set your Serial Monitor to the same speed.
+const uint32_t kBaudRate = 115200;
+
+// As this program is a special purpose capture/decoder, let us use a larger
+// than normal buffer so we can handle Air Conditioner remote codes.
+const uint16_t kCaptureBufferSize = 1024;
+
+// kTimeout is the Nr. of milli-Seconds of no-more-data before we consider a
+// message ended.
+// This parameter is an interesting trade-off. The longer the timeout, the more
+// complex a message it can capture. e.g. Some device protocols will send
+// multiple message packets in quick succession, like Air Conditioner remotes.
+// Air Coniditioner protocols often have a considerable gap (20-40+ms) between
+// packets.
+// The downside of a large timeout value is a lot of less complex protocols
+// send multiple messages when the remote's button is held down. The gap between
+// them is often also around 20+ms. This can result in the raw data be 2-3+
+// times larger than needed as it has captured 2-3+ messages in a single
+// capture. Setting a low timeout value can resolve this.
+// So, choosing the best kTimeout value for your use particular case is
+// quite nuanced. Good luck and happy hunting.
+// NOTE: Don't exceed kMaxTimeoutMs. Typically 130ms.
+#if DECODE_AC
+// Some A/C units have gaps in their protocols of ~40ms. e.g. Kelvinator
+// A value this large may swallow repeats of some protocols
+const uint8_t kTimeout = 50;
+#else // DECODE_AC
+// Suits most messages, while not swallowing many repeats.
+const uint8_t kTimeout = 15;
+#endif // DECODE_AC
+// Alternatives:
+// const uint8_t kTimeout = 90;
+// Suits messages with big gaps like XMP-1 & some aircon units, but can
+// accidentally swallow repeated messages in the rawData[] output.
+//
+// const uint8_t kTimeout = kMaxTimeoutMs;
+// This will set it to our currently allowed maximum.
+// Values this high are problematic because it is roughly the typical boundary
+// where most messages repeat.
+// e.g. It will stop decoding a message and start sending it to serial at
+// precisely the time when the next message is likely to be transmitted,
+// and may miss it.
+
+// Set the smallest sized "UNKNOWN" message packets we actually care about.
+// This value helps reduce the false-positive detection rate of IR background
+// noise as real messages. The chances of background IR noise getting detected
+// as a message increases with the length of the kTimeout value. (See above)
+// The downside of setting this message too large is you can miss some valid
+// short messages for protocols that this library doesn't yet decode.
+//
+// Set higher if you get lots of random short UNKNOWN messages when nothing
+// should be sending a message.
+// Set lower if you are sure your setup is working, but it doesn't see messages
+// from your device. (e.g. Other IR remotes work.)
+// NOTE: Set this value very high to effectively turn off UNKNOWN detection.
+const uint16_t kMinUnknownSize = 12;
+// ==================== end of TUNEABLE PARAMETERS ====================
+
+// Use turn on the save buffer feature for more complete capture coverage.
+IRrecv irrecv(kRecvPin, kCaptureBufferSize, kTimeout, true);
+
+decode_results results; // Somewhere to store the results
+
+// Display the human readable state of an A/C message if we can.
+void dumpACInfo(decode_results *results) {
+ String description = "";
+#if DECODE_DAIKIN
+ if (results->decode_type == DAIKIN) {
+ IRDaikinESP ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_DAIKIN
+#if DECODE_FUJITSU_AC
+ if (results->decode_type == FUJITSU_AC) {
+ IRFujitsuAC ac(0);
+ ac.setRaw(results->state, results->bits / 8);
+ description = ac.toString();
+ }
+#endif // DECODE_FUJITSU_AC
+#if DECODE_KELVINATOR
+ if (results->decode_type == KELVINATOR) {
+ IRKelvinatorAC ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_KELVINATOR
+#if DECODE_MITSUBISHI_AC
+ if (results->decode_type == MITSUBISHI_AC) {
+ IRMitsubishiAC ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_MITSUBISHI_AC
+#if DECODE_TOSHIBA_AC
+ if (results->decode_type == TOSHIBA_AC) {
+ IRToshibaAC ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_TOSHIBA_AC
+#if DECODE_GREE
+ if (results->decode_type == GREE) {
+ IRGreeAC ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_GREE
+#if DECODE_MIDEA
+ if (results->decode_type == MIDEA) {
+ IRMideaAC ac(0);
+ ac.setRaw(results->value); // Midea uses value instead of state.
+ description = ac.toString();
+ }
+#endif // DECODE_MIDEA
+#if DECODE_HAIER_AC
+ if (results->decode_type == HAIER_AC) {
+ IRHaierAC ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_HAIER_AC
+#if DECODE_HAIER_AC_YRW02
+ if (results->decode_type == HAIER_AC_YRW02) {
+ IRHaierACYRW02 ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_HAIER_AC_YRW02
+#if DECODE_SAMSUNG_AC
+ if (results->decode_type == SAMSUNG_AC) {
+ IRSamsungAc ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_SAMSUNG_AC
+#if DECODE_COOLIX
+ if (results->decode_type == COOLIX) {
+ IRCoolixAC ac(0);
+ ac.setRaw(results->value); // Coolix uses value instead of state.
+ description = ac.toString();
+ }
+#endif // DECODE_COOLIX
+#if DECODE_PANASONIC_AC
+ if (results->decode_type == PANASONIC_AC &&
+ results->bits > kPanasonicAcShortBits) {
+ IRPanasonicAc ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_PANASONIC_AC
+#if DECODE_HITACHI_AC
+ if (results->decode_type == HITACHI_AC) {
+ IRHitachiAc ac(0);
+ ac.setRaw(results->state);
+ description = ac.toString();
+ }
+#endif // DECODE_HITACHI_AC
+ // If we got a human-readable description of the message, display it.
+ if (description != "") Serial.println("Mesg Desc.: " + description);
+}
+
+// The section of code run only once at start-up.
+void setup() {
+ Serial.begin(kBaudRate, SERIAL_8N1, SERIAL_TX_ONLY);
+ while (!Serial) // Wait for the serial connection to be establised.
+ delay(50);
+ Serial.println();
+ Serial.print("IRrecvDumpV2 is now running and waiting for IR input on Pin ");
+ Serial.println(kRecvPin);
+
+#if DECODE_HASH
+ // Ignore messages with less than minimum on or off pulses.
+ irrecv.setUnknownThreshold(kMinUnknownSize);
+#endif // DECODE_HASH
+ irrecv.enableIRIn(); // Start the receiver
+}
+
+// The repeating section of the code
+//
+void loop() {
+ // Check if the IR code has been received.
+ if (irrecv.decode(&results)) {
+ // Display a crude timestamp.
+ uint32_t now = millis();
+ Serial.printf("Timestamp : %06u.%03u\n", now / 1000, now % 1000);
+ if (results.overflow)
+ Serial.printf(
+ "WARNING: IR code is too big for buffer (>= %d). "
+ "This result shouldn't be trusted until this is resolved. "
+ "Edit & increase kCaptureBufferSize.\n",
+ kCaptureBufferSize);
+ // Display the basic output of what we found.
+ Serial.print(resultToHumanReadableBasic(&results));
+ dumpACInfo(&results); // Display any extra A/C info if we have it.
+ yield(); // Feed the WDT as the text output can take a while to print.
+
+ // Display the library version the message was captured with.
+ Serial.print("Library : v");
+ Serial.println(_IRREMOTEESP8266_VERSION_);
+ Serial.println();
+
+ // Output RAW timing info of the result.
+ Serial.println(resultToTimingInfo(&results));
+ yield(); // Feed the WDT (again)
+
+ // Output the results as source code
+ Serial.println(resultToSourceCode(&results));
+ Serial.println(""); // Blank line between entries
+ yield(); // Feed the WDT (again)
+ }
+}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDumpV2/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDumpV2/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRrecvDumpV2/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRrecvDumpV2/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRsendDemo/IRsendDemo.ino b/lib/IRremoteESP8266-2.5.2.03/examples/IRsendDemo/IRsendDemo.ino
similarity index 87%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRsendDemo/IRsendDemo.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRsendDemo/IRsendDemo.ino
index 1a688cba382c..892016b3eec1 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/IRsendDemo/IRsendDemo.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/IRsendDemo/IRsendDemo.ino
@@ -4,7 +4,8 @@
* Based on Ken Shirriff's IrsendDemo Version 0.1 July, 2009,
* Copyright 2009 Ken Shirriff, http://arcfn.com
*
- * An IR LED circuit *MUST* be connected to ESP8266 pin 4 (D2).
+ * An IR LED circuit *MUST* be connected to the ESP8266 on a pin
+ * as specified by kIrLed below.
*
* TL;DR: The IR LED needs to be driven by a transistor for a good result.
*
@@ -33,7 +34,9 @@
#include
#include
-IRsend irsend(4); // An IR LED is controlled by GPIO pin 4 (D2)
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+
+IRsend irsend(kIrLed); // Set the GPIO to be used to sending the message.
// Example of data captured by IRrecvDumpV2.ino
uint16_t rawData[67] = {9000, 4500, 650, 550, 650, 1650, 600, 550, 650, 550,
@@ -50,13 +53,19 @@ void setup() {
}
void loop() {
+#if SEND_NEC
Serial.println("NEC");
irsend.sendNEC(0x00FFE01FUL, 32);
+#endif // SEND_NEC
delay(2000);
+#if SEND_SONY
Serial.println("Sony");
irsend.sendSony(0xa90, 12, 2);
+#endif // SEND_SONY
delay(2000);
+#if SEND_RAW
Serial.println("a rawData capture from IRrecvDumpV2");
irsend.sendRaw(rawData, 67, 38); // Send a raw data capture at 38kHz.
+#endif // SEND_RAW
delay(2000);
}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRsendDemo/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/IRsendDemo/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRsendDemo/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRsendDemo/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRsendProntoDemo/IRsendProntoDemo.ino b/lib/IRremoteESP8266-2.5.2.03/examples/IRsendProntoDemo/IRsendProntoDemo.ino
similarity index 93%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRsendProntoDemo/IRsendProntoDemo.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRsendProntoDemo/IRsendProntoDemo.ino
index 0a7a014a76d1..3bef2179e042 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/IRsendProntoDemo/IRsendProntoDemo.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/IRsendProntoDemo/IRsendProntoDemo.ino
@@ -6,7 +6,7 @@
* Version 1.0 June, 2017
*
* An IR LED circuit *MUST* be connected to ESP8266 pin 4 (D2), unless you
- * change the irsend() value below.
+ * change the kIrLed value below.
*
* TL;DR: The IR LED needs to be driven by a transistor for a good result.
*
@@ -35,7 +35,9 @@
#include
#include
-IRsend irsend(4); // An IR LED is controlled by GPIO pin 4 (D2)
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+
+IRsend irsend(kIrLed); // Set the GPIO to be used to sending the message.
// Panasonic Plasma TV Descrete code (Power On).
// Acquired from:
@@ -96,10 +98,15 @@ void setup() {
}
void loop() {
+#if SEND_PRONTO
Serial.println("Sending a Samsung TV 'on' command.");
irsend.sendPronto(samsungProntoCode, 72);
delay(2000);
Serial.println("Sending a Panasonic Plasma TV 'on' command.");
irsend.sendPronto(panasonicProntoCode, 104);
delay(2000);
+#else // SEND_PRONTO
+ Serial.println("Can't send because SEND_PRONTO has been disabled.");
+ delay(10000);
+#endif // SEND_PRONTO
}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/IRsendProntoDemo/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/IRsendProntoDemo/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/IRsendProntoDemo/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/IRsendProntoDemo/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/JVCPanasonicSendDemo/JVCPanasonicSendDemo.ino b/lib/IRremoteESP8266-2.5.2.03/examples/JVCPanasonicSendDemo/JVCPanasonicSendDemo.ino
similarity index 64%
rename from lib/IRremoteESP8266-2.2.1.02/examples/JVCPanasonicSendDemo/JVCPanasonicSendDemo.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/JVCPanasonicSendDemo/JVCPanasonicSendDemo.ino
index 9c7068000a79..ee2422915b68 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/JVCPanasonicSendDemo/JVCPanasonicSendDemo.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/JVCPanasonicSendDemo/JVCPanasonicSendDemo.ino
@@ -4,7 +4,8 @@
* Based on Ken Shirriff's IrsendDemo Version 0.1 July, 2009, Copyright 2009 Ken Shirriff, http://arcfn.com
* JVC and Panasonic protocol added by Kristian Lauszus (Thanks to zenwheel and other people at the original blog post)
*
- * An IR LED circuit *MUST* be connected to ESP8266 pin 4 (D2).
+ * An IR LED circuit *MUST* be connected to the ESP8266 on a pin
+ * as specified by kIrLed below.
*
* TL;DR: The IR LED needs to be driven by a transistor for a good result.
*
@@ -33,12 +34,13 @@
#include
#include
-#define PanasonicAddress 0x4004 // Panasonic address (Pre data)
-#define PanasonicPower 0x100BCBD // Panasonic Power button
+const uint16_t kPanasonicAddress = 0x4004; // Panasonic address (Pre data)
+const uint32_t kPanasonicPower = 0x100BCBD; // Panasonic Power button
+const uint16_t kJVCPower = 0xC5E8;
-#define JVCPower 0xC5E8
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
-IRsend irsend(4); // An IR LED is controlled by GPIO pin 4 (D2)
+IRsend irsend(kIrLed); // Set the GPIO to be used to sending the message.
void setup() {
irsend.begin();
@@ -46,11 +48,16 @@ void setup() {
void loop() {
// This should turn your TV on and off
- irsend.sendPanasonic(PanasonicAddress, PanasonicPower);
+#if SEND_PANASONIC
+ irsend.sendPanasonic(kPanasonicAddress, kPanasonicPower);
+#else // SEND_PANASONIC
+ Serial.println("Can't send because SEND_PANASONIC has been disabled.");
+#endif // SEND_PANASONIC
- irsend.sendJVC(JVCPower, 16, 0); // hex value, 16 bits, no repeat
- // see http://www.sbprojects.com/knowledge/ir/jvc.php for information
- delayMicroseconds(50);
- irsend.sendJVC(JVCPower, 16, 1); // hex value, 16 bits, repeat
- delayMicroseconds(50);
+#if SEND_JVC
+ irsend.sendJVC(kJVCPower, 16, 1); // hex value, 16 bits, single repeat
+#else // SEND_JVC
+ Serial.println("Can't send because SEND_JVC has been disabled.");
+#endif // SEND_JVC
+ delay(10000); // Wait 10 seconds before we repeat everything.
}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/JVCPanasonicSendDemo/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/JVCPanasonicSendDemo/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/JVCPanasonicSendDemo/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/JVCPanasonicSendDemo/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/LGACSend/LGACSend.ino b/lib/IRremoteESP8266-2.5.2.03/examples/LGACSend/LGACSend.ino
similarity index 95%
rename from lib/IRremoteESP8266-2.2.1.02/examples/LGACSend/LGACSend.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/LGACSend/LGACSend.ino
index 7cced0c88d5f..9139983c9145 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/LGACSend/LGACSend.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/LGACSend/LGACSend.ino
@@ -45,7 +45,11 @@ void Ac_Send_Code(uint32_t code) {
Serial.print(" : ");
Serial.println(code, HEX);
+#if SEND_LG
irsend.sendLG(code, 28);
+#else // SEND_LG
+ Serial.println("Can't send because SEND_LG has been disabled.");
+#endif // SEND_LG
}
void Ac_Activate(unsigned int temperature, unsigned int air_flow,
@@ -60,9 +64,9 @@ void Ac_Activate(unsigned int temperature, unsigned int air_flow,
else
ac_msbits4 = 0; // cooling
unsigned int ac_msbits5 = (temperature < 15) ? 0 : temperature - 15;
- unsigned int ac_msbits6;
+ unsigned int ac_msbits6 = 0;
- if (0 <= air_flow && air_flow <= 2) {
+ if (air_flow <= 2) {
if (kAc_Type == 0)
ac_msbits6 = kAc_Flow_Tower[air_flow];
else
@@ -128,7 +132,7 @@ void setup() {
}
void loop() {
- char b;
+ char b = ' ';
Serial.println("# a : mode or temp b : air_flow, temp, swing, clean,"
" cooling/heating");
Serial.println("# 0 : off 0");
@@ -158,7 +162,7 @@ void loop() {
default:
Serial.println("b="); // Prompt User for input
while (Serial.available() == 0) {}
- char b = Serial.read();
+ b = Serial.read();
}
/*
@@ -171,8 +175,8 @@ void loop() {
# 4 : air_flow 0 ~ 3 : flow
# + : temp + 1
# - : temp - 1
- # c : cooling
- # h : heating
+ # c : cooling
+ # h : heating
# m : change cooling to air clean, air clean to cooling
*/
Serial.print("a : ");
@@ -194,7 +198,7 @@ void loop() {
Ac_Change_Air_Swing(1);
break;
case '3': // 1 : clean on, power on
- if (b == '0' | b == '1')
+ if (b == '0' || b == '1')
Ac_Air_Clean(b);
break;
case '4':
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnArgoAC/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/LGACSend/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnArgoAC/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/LGACSend/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnArgoAC/TurnOnArgoAC.ino b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnArgoAC/TurnOnArgoAC.ino
similarity index 72%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnArgoAC/TurnOnArgoAC.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnArgoAC/TurnOnArgoAC.ino
index a2e450ac5637..3993d11510b0 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnArgoAC/TurnOnArgoAC.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnArgoAC/TurnOnArgoAC.ino
@@ -1,5 +1,6 @@
-/* Copyright 2017 crankyoldgit
-* An IR LED circuit *MUST* be connected to ESP8266 pin 4 (D2).
+/* Copyright 2017, 2018 crankyoldgit
+* An IR LED circuit *MUST* be connected to the ESP8266 on a pin
+* as specified by kIrLed below.
*
* TL;DR: The IR LED needs to be driven by a transistor for a good result.
*
@@ -29,10 +30,11 @@
#include
#include
-IRArgoAC argoir(4); // An IR LED is controlled by GPIO pin 4 (D2)
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+IRArgoAC ac(kIrLed); // Set the GPIO to be used to sending the message.
void setup() {
- argoir.begin();
+ ac.begin();
Serial.begin(115200);
}
@@ -40,13 +42,17 @@ void loop() {
Serial.println("Sending...");
// Set up what we want to send. See ir_Argo.cpp for all the options.
- argoir.setPower(true);
- argoir.setFan(ARGO_FAN_1);
- argoir.setCoolMode(ARGO_COOL_AUTO);
- argoir.setTemp(25);
+ ac.setPower(true);
+ ac.setFan(kArgoFan1);
+ ac.setCoolMode(kArgoCoolAuto);
+ ac.setTemp(25);
+#if SEND_ARGO
// Now send the IR signal.
- argoir.send();
+ ac.send();
+#else // SEND_ARGO
+ Serial.println("Can't send because SEND_ARGO has been disabled.");
+#endif // SEND_ARGO
delay(5000);
}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnDaikinAC/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnArgoAC/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnDaikinAC/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnArgoAC/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnDaikinAC/TurnOnDaikinAC.ino b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnDaikinAC/TurnOnDaikinAC.ino
similarity index 64%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnDaikinAC/TurnOnDaikinAC.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnDaikinAC/TurnOnDaikinAC.ino
index eb5cda5e7e29..b3ab757de458 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnDaikinAC/TurnOnDaikinAC.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnDaikinAC/TurnOnDaikinAC.ino
@@ -1,6 +1,7 @@
-/* Copyright 2016 sillyfrog
+/* Copyright 2017 sillyfrog
*
-* An IR LED circuit *MUST* be connected to ESP8266 pin 4 (D2).
+* An IR LED circuit *MUST* be connected to the ESP8266 on a pin
+* as specified by kIrLed below.
*
* TL;DR: The IR LED needs to be driven by a transistor for a good result.
*
@@ -30,10 +31,11 @@
#include
#include
-IRDaikinESP dakinir(D2); // An IR LED is controlled by GPIO pin 4 (D2)
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+IRDaikinESP ac(kIrLed); // Set the GPIO to be used to sending the message
void setup() {
- dakinir.begin();
+ ac.begin();
Serial.begin(115200);
}
@@ -42,15 +44,26 @@ void loop() {
Serial.println("Sending...");
// Set up what we want to send. See ir_Daikin.cpp for all the options.
- dakinir.on();
- dakinir.setFan(1);
- dakinir.setMode(DAIKIN_COOL);
- dakinir.setTemp(25);
- dakinir.setSwingVertical(0);
- dakinir.setSwingHorizontal(0);
+ ac.on();
+ ac.setFan(1);
+ ac.setMode(kDaikinCool);
+ ac.setTemp(25);
+ ac.setSwingVertical(false);
+ ac.setSwingHorizontal(false);
+
+ // Set the current time to 1:33PM (13:33)
+ // Time works in minutes past midnight
+ ac.setCurrentTime(13 * 60 + 33);
+ // Turn off about 1 hour later at 2:30PM (14:30)
+ ac.enableOffTimer(14 * 60 + 30);
+
+ // Display what we are going to send.
+ Serial.println(ac.toString());
// Now send the IR signal.
- dakinir.send();
+#if SEND_DAIKIN
+ ac.send();
+#endif // SEND_DAIKIN
- delay(5000);
+ delay(15000);
}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnFujitsuAC/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnDaikinAC/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnFujitsuAC/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnDaikinAC/platformio.ini
diff --git a/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnFujitsuAC/TurnOnFujitsuAC.ino b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnFujitsuAC/TurnOnFujitsuAC.ino
new file mode 100644
index 000000000000..823a3f485617
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnFujitsuAC/TurnOnFujitsuAC.ino
@@ -0,0 +1,50 @@
+// Copyright 2017 Jonny Graham, 2018 David Conran
+#ifndef UNIT_TEST
+#include
+#endif
+#include
+#include
+#include
+
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+IRFujitsuAC ac(kIrLed);
+
+void printState() {
+ // Display the settings.
+ Serial.println("Fujitsu A/C remote is in the following state:");
+ Serial.printf(" %s\n", ac.toString().c_str());
+ // Display the encoded IR sequence.
+ unsigned char* ir_code = ac.getRaw();
+ Serial.print("IR Code: 0x");
+ for (uint8_t i = 0; i < ac.getStateLength(); i++)
+ Serial.printf("%02X", ir_code[i]);
+ Serial.println();
+}
+
+void setup() {
+ ac.begin();
+ Serial.begin(115200);
+ delay(200);
+
+ // Set up what we want to send. See ir_Fujitsu.cpp for all the options.
+ Serial.println("Default state of the remote.");
+ printState();
+ Serial.println("Setting desired state for A/C.");
+ ac.setCmd(kFujitsuAcCmdTurnOn);
+ ac.setSwing(kFujitsuAcSwingBoth);
+ ac.setMode(kFujitsuAcModeCool);
+ ac.setFanSpeed(kFujitsuAcFanHigh);
+ ac.setTemp(24); // 24C
+}
+
+void loop() {
+ // Now send the IR signal.
+ Serial.println("Sending IR command to A/C ...");
+#if SEND_FUJITSU_AC
+ ac.send();
+#else // SEND_FUJITSU_AC
+ Serial.println("Can't send because SEND_FUJITSU_AC has been disabled.");
+#endif // SEND_FUJITSU_AC
+ printState();
+ delay(5000);
+}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnKelvinatorAC/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnFujitsuAC/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnKelvinatorAC/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnFujitsuAC/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnKelvinatorAC/TurnOnKelvinatorAC.ino b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnKelvinatorAC/TurnOnKelvinatorAC.ino
similarity index 63%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnKelvinatorAC/TurnOnKelvinatorAC.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnKelvinatorAC/TurnOnKelvinatorAC.ino
index 393ba28ff768..b9b700741483 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnKelvinatorAC/TurnOnKelvinatorAC.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnKelvinatorAC/TurnOnKelvinatorAC.ino
@@ -1,6 +1,7 @@
-/* Copyright 2016 David Conran
+/* Copyright 2016, 2018 David Conran
*
-* An IR LED circuit *MUST* be connected to ESP8266 pin 4 (D2).
+* An IR LED circuit *MUST* be connected to the ESP8266 on a pin
+* as specified by kIrLed below.
*
* TL;DR: The IR LED needs to be driven by a transistor for a good result.
*
@@ -29,29 +30,23 @@
#include
#include
-IRKelvinatorAC kelvir(D2); // An IR LED is controlled by GPIO pin 4 (D2)
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+IRKelvinatorAC ac(kIrLed); // Set the GPIO to be used for sending messages.
void printState() {
// Display the settings.
Serial.println("Kelvinator A/C remote is in the following state:");
- Serial.printf(" Basic\n Power: %d, Mode: %d, Temp: %dC, Fan Speed: %d\n",
- kelvir.getPower(), kelvir.getMode(), kelvir.getTemp(),
- kelvir.getFan());
- Serial.printf(" Options\n X-Fan: %d, Light: %d, Ion Filter: %d\n",
- kelvir.getXFan(), kelvir.getLight(), kelvir.getIonFilter());
- Serial.printf(" Swing (V): %d, Swing (H): %d, Turbo: %d, Quiet: %d\n",
- kelvir.getSwingVertical(), kelvir.getSwingHorizontal(),
- kelvir.getTurbo(), kelvir.getQuiet());
+ Serial.printf(" %s\n", ac.toString().c_str());
// Display the encoded IR sequence.
- unsigned char* ir_code = kelvir.getRaw();
+ unsigned char* ir_code = ac.getRaw();
Serial.print("IR Code: 0x");
- for (uint8_t i = 0; i < KELVINATOR_STATE_LENGTH; i++)
+ for (uint8_t i = 0; i < kKelvinatorStateLength; i++)
Serial.printf("%02X", ir_code[i]);
Serial.println();
}
void setup() {
- kelvir.begin();
+ ac.begin();
Serial.begin(115200);
delay(200);
@@ -60,21 +55,23 @@ void setup() {
Serial.println("Default state of the remote.");
printState();
Serial.println("Setting desired state for A/C.");
- kelvir.on();
- kelvir.setFan(1);
- kelvir.setMode(KELVINATOR_COOL);
- kelvir.setTemp(26);
- kelvir.setSwingVertical(false);
- kelvir.setSwingHorizontal(true);
- kelvir.setXFan(true);
- kelvir.setIonFilter(false);
- kelvir.setLight(true);
+ ac.on();
+ ac.setFan(1);
+ ac.setMode(kKelvinatorCool);
+ ac.setTemp(26);
+ ac.setSwingVertical(false);
+ ac.setSwingHorizontal(true);
+ ac.setXFan(true);
+ ac.setIonFilter(false);
+ ac.setLight(true);
}
void loop() {
// Now send the IR signal.
+#if SEND_KELVINATOR
Serial.println("Sending IR command to A/C ...");
- kelvir.send();
+ ac.send();
+#endif // SEND_KELVINATOR
printState();
delay(5000);
}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnMitsubishiAC/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnKelvinatorAC/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnMitsubishiAC/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnKelvinatorAC/platformio.ini
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnMitsubishiAC/TurnOnMitsubishiAC.ino b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnMitsubishiAC/TurnOnMitsubishiAC.ino
similarity index 72%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnMitsubishiAC/TurnOnMitsubishiAC.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnMitsubishiAC/TurnOnMitsubishiAC.ino
index 1ea9b0d31193..e719af68e62a 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnMitsubishiAC/TurnOnMitsubishiAC.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnMitsubishiAC/TurnOnMitsubishiAC.ino
@@ -1,6 +1,7 @@
-/* Copyright 2017 David Conran
+/* Copyright 2017, 2018 David Conran
*
-* An IR LED circuit *MUST* be connected to ESP8266 pin 4 (D2).
+* An IR LED circuit *MUST* be connected to the ESP8266 on a pin
+* as specified by kIrLed below.
*
* TL;DR: The IR LED needs to be driven by a transistor for a good result.
*
@@ -29,25 +30,23 @@
#include
#include
-IRMitsubishiAC mitsubir(D2); // An IR LED is controlled by GPIO pin 4 (D2)
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+IRMitsubishiAC ac(kIrLed); // Set the GPIO used for sending messages.
void printState() {
// Display the settings.
Serial.println("Mitsubishi A/C remote is in the following state:");
- Serial.printf(" Power: %d, Mode: %d, Temp: %dC, Fan Speed: %d," \
- " Vane Mode: %d\n",
- mitsubir.getPower(), mitsubir.getMode(), mitsubir.getTemp(),
- mitsubir.getFan(), mitsubir.getVane());
+ Serial.printf(" %s\n", ac.toString().c_str());
// Display the encoded IR sequence.
- unsigned char* ir_code = mitsubir.getRaw();
+ unsigned char* ir_code = ac.getRaw();
Serial.print("IR Code: 0x");
- for (uint8_t i = 0; i < MITSUBISHI_AC_STATE_LENGTH; i++)
+ for (uint8_t i = 0; i < kMitsubishiACStateLength; i++)
Serial.printf("%02X", ir_code[i]);
Serial.println();
}
void setup() {
- mitsubir.begin();
+ ac.begin();
Serial.begin(115200);
delay(200);
@@ -55,17 +54,19 @@ void setup() {
Serial.println("Default state of the remote.");
printState();
Serial.println("Setting desired state for A/C.");
- mitsubir.on();
- mitsubir.setFan(1);
- mitsubir.setMode(MITSUBISHI_AC_COOL);
- mitsubir.setTemp(26);
- mitsubir.setVane(MITSUBISHI_AC_VANE_AUTO);
+ ac.on();
+ ac.setFan(1);
+ ac.setMode(kMitsubishiAcCool);
+ ac.setTemp(26);
+ ac.setVane(kMitsubishiAcVaneAuto);
}
void loop() {
// Now send the IR signal.
+#if SEND_MITSUBISHI_AC
Serial.println("Sending IR command to A/C ...");
- mitsubir.send();
+ ac.send();
+#endif // SEND_MITSUBISHI_AC
printState();
delay(5000);
}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnTrotecAC/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnMitsubishiAC/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnTrotecAC/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnMitsubishiAC/platformio.ini
diff --git a/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnToshibaAC/TurnOnToshibaAC.ino b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnToshibaAC/TurnOnToshibaAC.ino
new file mode 100644
index 000000000000..d78178098e30
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnToshibaAC/TurnOnToshibaAC.ino
@@ -0,0 +1,71 @@
+/* Copyright 2017, 2018 David Conran
+*
+* An IR LED circuit *MUST* be connected to the ESP8266 on a pin
+* as specified by kIrLed below.
+*
+* TL;DR: The IR LED needs to be driven by a transistor for a good result.
+*
+* Suggested circuit:
+* https://github.com/markszabo/IRremoteESP8266/wiki#ir-sending
+*
+* Common mistakes & tips:
+* * Don't just connect the IR LED directly to the pin, it won't
+* have enough current to drive the IR LED effectively.
+* * Make sure you have the IR LED polarity correct.
+* See: https://learn.sparkfun.com/tutorials/polarity/diode-and-led-polarity
+* * Typical digital camera/phones can be used to see if the IR LED is flashed.
+* Replace the IR LED with a normal LED if you don't have a digital camera
+* when debugging.
+* * Avoid using the following pins unless you really know what you are doing:
+* * Pin 0/D3: Can interfere with the boot/program mode & support circuits.
+* * Pin 1/TX/TXD0: Any serial transmissions from the ESP8266 will interfere.
+* * Pin 3/RX/RXD0: Any serial transmissions to the ESP8266 will interfere.
+* * ESP-01 modules are tricky. We suggest you use a module with more GPIOs
+* for your first time. e.g. ESP-12 etc.
+*/
+#ifndef UNIT_TEST
+#include
+#endif
+#include
+#include
+#include
+
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+IRToshibaAC ac(kIrLed); // Set the GPIO to be used for sending messages.
+
+void printState() {
+ // Display the settings.
+ Serial.println("Toshiba A/C remote is in the following state:");
+ Serial.printf(" %s\n", ac.toString().c_str());
+ // Display the encoded IR sequence.
+ unsigned char* ir_code = ac.getRaw();
+ Serial.print("IR Code: 0x");
+ for (uint8_t i = 0; i < kToshibaACStateLength; i++)
+ Serial.printf("%02X", ir_code[i]);
+ Serial.println();
+}
+
+void setup() {
+ ac.begin();
+ Serial.begin(115200);
+ delay(200);
+
+ // Set up what we want to send. See ir_Toshiba.cpp for all the options.
+ Serial.println("Default state of the remote.");
+ printState();
+ Serial.println("Setting desired state for A/C.");
+ ac.on();
+ ac.setFan(1);
+ ac.setMode(kToshibaAcCool);
+ ac.setTemp(26);
+}
+
+void loop() {
+ // Now send the IR signal.
+#if SEND_TOSHIBA_AC
+ Serial.println("Sending IR command to A/C ...");
+ ac.send();
+#endif // SEND_TOSHIBA_AC
+ printState();
+ delay(5000);
+}
diff --git a/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnToshibaAC/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnToshibaAC/platformio.ini
new file mode 100644
index 000000000000..eeb8d1f2eb93
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnToshibaAC/platformio.ini
@@ -0,0 +1,17 @@
+[platformio]
+lib_extra_dirs = ../../
+src_dir=.
+
+[common]
+build_flags =
+lib_deps_builtin =
+lib_deps_external =
+
+[env:nodemcuv2]
+platform = espressif8266
+framework = arduino
+board = nodemcuv2
+build_flags = ${common.build_flags}
+lib_deps =
+ ${common.lib_deps_builtin}
+ ${common.lib_deps_external}
diff --git a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnTrotecAC/TurnOnTrotecAC.ino b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnTrotecAC/TurnOnTrotecAC.ino
similarity index 74%
rename from lib/IRremoteESP8266-2.2.1.02/examples/TurnOnTrotecAC/TurnOnTrotecAC.ino
rename to lib/IRremoteESP8266-2.5.2.03/examples/TurnOnTrotecAC/TurnOnTrotecAC.ino
index 2476ff557af9..b7881eead1e6 100644
--- a/lib/IRremoteESP8266-2.2.1.02/examples/TurnOnTrotecAC/TurnOnTrotecAC.ino
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnTrotecAC/TurnOnTrotecAC.ino
@@ -1,5 +1,6 @@
/* Copyright 2017 stufisher
-* An IR LED circuit *MUST* be connected to ESP8266 pin 4 (D2).
+* An IR LED circuit *MUST* be connected to the ESP8266 on a pin
+* as specified by kIrLed below.
*
* TL;DR: The IR LED needs to be driven by a transistor for a good result.
*
@@ -29,10 +30,11 @@
#include
#include
-IRTrotecESP trotecir(D2); // An IR LED is controlled by GPIO pin 4 (D2)
+const uint16_t kIrLed = 4; // ESP8266 GPIO pin to use. Recommended: 4 (D2).
+IRTrotecESP ac(kIrLed); // Set the GPIO to be used for sending messages.
void setup() {
- trotecir.begin();
+ ac.begin();
Serial.begin(115200);
}
@@ -40,13 +42,17 @@ void loop() {
Serial.println("Sending...");
// Set up what we want to send. See ir_Trotec.cpp for all the options.
- trotecir.setPower(true);
- trotecir.setSpeed(TROTEC_FAN_LOW);
- trotecir.setMode(TROTEC_COOL);
- trotecir.setTemp(25);
+ ac.setPower(true);
+ ac.setSpeed(kTrotecFanLow);
+ ac.setMode(kTrotecCool);
+ ac.setTemp(25);
// Now send the IR signal.
- trotecir.send();
+#if SEND_TROTEC
+ ac.send();
+#else // SEND_TROTEC
+ Serial.println("Can't send because SEND_TROTEC has been disabled.");
+#endif // SEND_TROTEC
delay(5000);
}
diff --git a/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnTrotecAC/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnTrotecAC/platformio.ini
new file mode 100644
index 000000000000..eeb8d1f2eb93
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/examples/TurnOnTrotecAC/platformio.ini
@@ -0,0 +1,17 @@
+[platformio]
+lib_extra_dirs = ../../
+src_dir=.
+
+[common]
+build_flags =
+lib_deps_builtin =
+lib_deps_external =
+
+[env:nodemcuv2]
+platform = espressif8266
+framework = arduino
+board = nodemcuv2
+build_flags = ${common.build_flags}
+lib_deps =
+ ${common.lib_deps_builtin}
+ ${common.lib_deps_external}
diff --git a/lib/IRremoteESP8266-2.5.2.03/keywords.txt b/lib/IRremoteESP8266-2.5.2.03/keywords.txt
new file mode 100644
index 000000000000..ac3f43fe1809
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/keywords.txt
@@ -0,0 +1,1645 @@
+#########################################
+# Syntax Coloring Map For IRremoteESP8266
+#########################################
+
+################################################
+# WARNING: Do NOT edit this file directly.
+# It is generated by 'tools/mkkeywords'
+# e.g. tools/mkkeywords > keywords.txt
+################################################
+
+#######################################################
+# The Arduino IDE requires the use of a tab separator
+# between the name and identifier. Without this tab the
+# keyword is not highlighted.
+#
+# Reference: https://github.com/arduino/Arduino/wiki/Arduino-IDE-1.5:-Library-specification#keywords
+#######################################################
+
+#######################################
+# Datatypes & Classes (KEYWORD1)
+#######################################
+
+IRArgoAC KEYWORD1
+IRCoolixAC KEYWORD1
+IRDaikinESP KEYWORD1
+IRFujitsuAC KEYWORD1
+IRGreeAC KEYWORD1
+IRHaierAC KEYWORD1
+IRHaierACYRW02 KEYWORD1
+IRKelvinatorAC KEYWORD1
+IRMideaAC KEYWORD1
+IRMitsubishiAC KEYWORD1
+IRPanasonicAc KEYWORD1
+IRSamsungAc KEYWORD1
+IRToshibaAC KEYWORD1
+IRTrotecESP KEYWORD1
+IRrecv KEYWORD1
+IRsend KEYWORD1
+IRtimer KEYWORD1
+decode_results KEYWORD1
+ir_params_t KEYWORD1
+match_result_t KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+_delayMicroseconds KEYWORD2
+add KEYWORD2
+addbit KEYWORD2
+begin KEYWORD2
+buildFromState KEYWORD2
+buildState KEYWORD2
+calcBlockChecksum KEYWORD2
+calcChecksum KEYWORD2
+calcLGChecksum KEYWORD2
+calcUSecPeriod KEYWORD2
+calculateChecksum KEYWORD2
+calibrate KEYWORD2
+cancelOffTimer KEYWORD2
+cancelOnTimer KEYWORD2
+cancelTimers KEYWORD2
+checkheader KEYWORD2
+checksum KEYWORD2
+clearBit KEYWORD2
+clearSensorTemp KEYWORD2
+compare KEYWORD2
+copyIrParams KEYWORD2
+decode KEYWORD2
+decodeAiwaRCT501 KEYWORD2
+decodeCOOLIX KEYWORD2
+decodeCarrierAC KEYWORD2
+decodeDISH KEYWORD2
+decodeDaikin KEYWORD2
+decodeDenon KEYWORD2
+decodeElectraAC KEYWORD2
+decodeFujitsuAC KEYWORD2
+decodeGICable KEYWORD2
+decodeGree KEYWORD2
+decodeHaierAC KEYWORD2
+decodeHaierACYRW02 KEYWORD2
+decodeHash KEYWORD2
+decodeHitachiAC KEYWORD2
+decodeJVC KEYWORD2
+decodeKelvinator KEYWORD2
+decodeLG KEYWORD2
+decodeLasertag KEYWORD2
+decodeLutron KEYWORD2
+decodeMWM KEYWORD2
+decodeMagiQuest KEYWORD2
+decodeMidea KEYWORD2
+decodeMitsubishi KEYWORD2
+decodeMitsubishi2 KEYWORD2
+decodeMitsubishiAC KEYWORD2
+decodeNEC KEYWORD2
+decodeNikai KEYWORD2
+decodePanasonic KEYWORD2
+decodePanasonicAC KEYWORD2
+decodePioneer KEYWORD2
+decodeRC5 KEYWORD2
+decodeRC6 KEYWORD2
+decodeRCMM KEYWORD2
+decodeSAMSUNG KEYWORD2
+decodeSamsungAC KEYWORD2
+decodeSanyo KEYWORD2
+decodeSanyoLC7461 KEYWORD2
+decodeSharp KEYWORD2
+decodeSony KEYWORD2
+decodeToshibaAC KEYWORD2
+decodeWhirlpoolAC KEYWORD2
+decodeWhynter KEYWORD2
+disableIRIn KEYWORD2
+disableOffTimer KEYWORD2
+disableOnTimer KEYWORD2
+elapsed KEYWORD2
+enableIRIn KEYWORD2
+enableIROut KEYWORD2
+enableOffTimer KEYWORD2
+enableOnTimer KEYWORD2
+encodeJVC KEYWORD2
+encodeLG KEYWORD2
+encodeMagiQuest KEYWORD2
+encodeNEC KEYWORD2
+encodePanasonic KEYWORD2
+encodePioneer KEYWORD2
+encodeRC5 KEYWORD2
+encodeRC5X KEYWORD2
+encodeRC6 KEYWORD2
+encodeSAMSUNG KEYWORD2
+encodeSanyoLC7461 KEYWORD2
+encodeSharp KEYWORD2
+encodeSony KEYWORD2
+encodeTime KEYWORD2
+fixChecksum KEYWORD2
+fixup KEYWORD2
+getBeep KEYWORD2
+getBit KEYWORD2
+getBufSize KEYWORD2
+getButton KEYWORD2
+getClean KEYWORD2
+getClock KEYWORD2
+getCmd KEYWORD2
+getCommand KEYWORD2
+getCoolMode KEYWORD2
+getCorrectedRawLength KEYWORD2
+getCurrTime KEYWORD2
+getCurrentTime KEYWORD2
+getEcono KEYWORD2
+getEye KEYWORD2
+getFan KEYWORD2
+getFanSpeed KEYWORD2
+getFlap KEYWORD2
+getHealth KEYWORD2
+getHeatMode KEYWORD2
+getIonFilter KEYWORD2
+getLed KEYWORD2
+getLight KEYWORD2
+getMax KEYWORD2
+getMode KEYWORD2
+getMold KEYWORD2
+getNight KEYWORD2
+getOffTime KEYWORD2
+getOffTimer KEYWORD2
+getOffTimerEnabled KEYWORD2
+getOnTime KEYWORD2
+getOnTimer KEYWORD2
+getOnTimerEnabled KEYWORD2
+getPower KEYWORD2
+getPowerful KEYWORD2
+getQuiet KEYWORD2
+getRClevel KEYWORD2
+getRaw KEYWORD2
+getSensor KEYWORD2
+getSensorTemp KEYWORD2
+getSleep KEYWORD2
+getSpeed KEYWORD2
+getStartClock KEYWORD2
+getStateLength KEYWORD2
+getStopClock KEYWORD2
+getSwing KEYWORD2
+getSwingHorizontal KEYWORD2
+getSwingVertical KEYWORD2
+getSwingVerticalAuto KEYWORD2
+getSwingVerticalPosition KEYWORD2
+getTemp KEYWORD2
+getTempRaw KEYWORD2
+getTime KEYWORD2
+getTimer KEYWORD2
+getTurbo KEYWORD2
+getVane KEYWORD2
+getXFan KEYWORD2
+getZoneFollow KEYWORD2
+getiFeel KEYWORD2
+hasACState KEYWORD2
+invertBits KEYWORD2
+isOffTimerEnabled KEYWORD2
+isOnTimerEnabled KEYWORD2
+ledOff KEYWORD2
+ledOn KEYWORD2
+mark KEYWORD2
+match KEYWORD2
+matchAtLeast KEYWORD2
+matchData KEYWORD2
+matchMark KEYWORD2
+matchSpace KEYWORD2
+off KEYWORD2
+on KEYWORD2
+printState KEYWORD2
+readbits KEYWORD2
+renderTime KEYWORD2
+reset KEYWORD2
+resultToHexidecimal KEYWORD2
+resultToHumanReadableBasic KEYWORD2
+resultToSourceCode KEYWORD2
+resultToTimingInfo KEYWORD2
+resume KEYWORD2
+reverseBits KEYWORD2
+send KEYWORD2
+sendAiwaRCT501 KEYWORD2
+sendArgo KEYWORD2
+sendCOOLIX KEYWORD2
+sendCarrierAC KEYWORD2
+sendDISH KEYWORD2
+sendDaikin KEYWORD2
+sendData KEYWORD2
+sendDenon KEYWORD2
+sendElectraAC KEYWORD2
+sendExtended KEYWORD2
+sendFujitsuAC KEYWORD2
+sendGC KEYWORD2
+sendGICable KEYWORD2
+sendGeneric KEYWORD2
+sendGree KEYWORD2
+sendHaierAC KEYWORD2
+sendHaierACYRW02 KEYWORD2
+sendHitachiAC KEYWORD2
+sendHitachiAC1 KEYWORD2
+sendHitachiAC2 KEYWORD2
+sendJVC KEYWORD2
+sendKelvinator KEYWORD2
+sendLG KEYWORD2
+sendLG2 KEYWORD2
+sendLasertag KEYWORD2
+sendLutron KEYWORD2
+sendMWM KEYWORD2
+sendMagiQuest KEYWORD2
+sendMidea KEYWORD2
+sendMitsubishi KEYWORD2
+sendMitsubishi2 KEYWORD2
+sendMitsubishiAC KEYWORD2
+sendNEC KEYWORD2
+sendNikai KEYWORD2
+sendPanasonic KEYWORD2
+sendPanasonic64 KEYWORD2
+sendPanasonicAC KEYWORD2
+sendPioneer KEYWORD2
+sendPronto KEYWORD2
+sendRC5 KEYWORD2
+sendRC6 KEYWORD2
+sendRCMM KEYWORD2
+sendRaw KEYWORD2
+sendSAMSUNG KEYWORD2
+sendSamsungAC KEYWORD2
+sendSanyoLC7461 KEYWORD2
+sendSharp KEYWORD2
+sendSharpRaw KEYWORD2
+sendSherwood KEYWORD2
+sendSony KEYWORD2
+sendToshibaAC KEYWORD2
+sendTrotec KEYWORD2
+sendWhirlpoolAC KEYWORD2
+sendWhynter KEYWORD2
+serialPrintUint64 KEYWORD2
+setBeep KEYWORD2
+setBit KEYWORD2
+setButton KEYWORD2
+setClean KEYWORD2
+setClock KEYWORD2
+setCmd KEYWORD2
+setCommand KEYWORD2
+setCoolMode KEYWORD2
+setCurrTime KEYWORD2
+setCurrentTime KEYWORD2
+setEcono KEYWORD2
+setEye KEYWORD2
+setFan KEYWORD2
+setFanSpeed KEYWORD2
+setFlap KEYWORD2
+setHealth KEYWORD2
+setHeatMode KEYWORD2
+setIonFilter KEYWORD2
+setLed KEYWORD2
+setLight KEYWORD2
+setMax KEYWORD2
+setMode KEYWORD2
+setModel KEYWORD2
+setMold KEYWORD2
+setNight KEYWORD2
+setOffTimer KEYWORD2
+setOnTimer KEYWORD2
+setPower KEYWORD2
+setPowerful KEYWORD2
+setQuiet KEYWORD2
+setRaw KEYWORD2
+setRoomTemp KEYWORD2
+setSensor KEYWORD2
+setSensorTemp KEYWORD2
+setSensorTempRaw KEYWORD2
+setSleep KEYWORD2
+setSpeed KEYWORD2
+setStartClock KEYWORD2
+setStopClock KEYWORD2
+setSwing KEYWORD2
+setSwingHorizontal KEYWORD2
+setSwingVertical KEYWORD2
+setTemp KEYWORD2
+setTempRaw KEYWORD2
+setTime KEYWORD2
+setTimer KEYWORD2
+setTurbo KEYWORD2
+setUnknownThreshold KEYWORD2
+setVane KEYWORD2
+setXFan KEYWORD2
+setZoneFollow KEYWORD2
+setiFeel KEYWORD2
+space KEYWORD2
+stateReset KEYWORD2
+stepHoriz KEYWORD2
+stepVert KEYWORD2
+sumBytes KEYWORD2
+ticksHigh KEYWORD2
+ticksLow KEYWORD2
+timeToString KEYWORD2
+toString KEYWORD2
+toggleRC5 KEYWORD2
+toggleRC6 KEYWORD2
+typeToString KEYWORD2
+uint64ToString KEYWORD2
+validChecksum KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+AIWA_RC_T501 LITERAL1
+AIWA_RC_T501_BITS LITERAL1
+ALLOW_DELAY_CALLS LITERAL1
+ARDB1 LITERAL1
+ARGO LITERAL1
+ARGO_COMMAND_LENGTH LITERAL1
+ARGO_COOL_AUTO LITERAL1
+ARGO_COOL_OFF LITERAL1
+ARGO_COOL_ON LITERAL1
+ARGO_COOl_HUM LITERAL1
+ARGO_FAN_1 LITERAL1
+ARGO_FAN_2 LITERAL1
+ARGO_FAN_3 LITERAL1
+ARGO_FAN_AUTO LITERAL1
+ARGO_FLAP_1 LITERAL1
+ARGO_FLAP_2 LITERAL1
+ARGO_FLAP_3 LITERAL1
+ARGO_FLAP_4 LITERAL1
+ARGO_FLAP_5 LITERAL1
+ARGO_FLAP_6 LITERAL1
+ARGO_FLAP_AUTO LITERAL1
+ARGO_FLAP_FULL LITERAL1
+ARGO_HEAT_AUTO LITERAL1
+ARGO_HEAT_BLINK LITERAL1
+ARGO_HEAT_ON LITERAL1
+ARGO_MAX_TEMP LITERAL1
+ARGO_MIN_TEMP LITERAL1
+ARRAH2E LITERAL1
+CARRIER_AC LITERAL1
+CARRIER_AC_BITS LITERAL1
+COOLIX LITERAL1
+COOLIX_BITS LITERAL1
+DAIKIN LITERAL1
+DAIKIN_AUTO LITERAL1
+DAIKIN_COMMAND_LENGTH LITERAL1
+DAIKIN_COOL LITERAL1
+DAIKIN_DEBUG LITERAL1
+DAIKIN_DRY LITERAL1
+DAIKIN_FAN LITERAL1
+DAIKIN_FAN_AUTO LITERAL1
+DAIKIN_FAN_MAX LITERAL1
+DAIKIN_FAN_MIN LITERAL1
+DAIKIN_FAN_QUIET LITERAL1
+DAIKIN_HEAT LITERAL1
+DAIKIN_MAX_TEMP LITERAL1
+DAIKIN_MIN_TEMP LITERAL1
+DECODE_AC LITERAL1
+DECODE_AIWA_RC_T501 LITERAL1
+DECODE_ARGO LITERAL1
+DECODE_CARRIER_AC LITERAL1
+DECODE_COOLIX LITERAL1
+DECODE_DAIKIN LITERAL1
+DECODE_DENON LITERAL1
+DECODE_DISH LITERAL1
+DECODE_ELECTRA_AC LITERAL1
+DECODE_FUJITSU_AC LITERAL1
+DECODE_GICABLE LITERAL1
+DECODE_GLOBALCACHE LITERAL1
+DECODE_GREE LITERAL1
+DECODE_HAIER_AC LITERAL1
+DECODE_HAIER_AC_YRW02 LITERAL1
+DECODE_HASH LITERAL1
+DECODE_HITACHI_AC LITERAL1
+DECODE_HITACHI_AC1 LITERAL1
+DECODE_HITACHI_AC2 LITERAL1
+DECODE_JVC LITERAL1
+DECODE_KELVINATOR LITERAL1
+DECODE_LASERTAG LITERAL1
+DECODE_LG LITERAL1
+DECODE_LUTRON LITERAL1
+DECODE_MAGIQUEST LITERAL1
+DECODE_MIDEA LITERAL1
+DECODE_MITSUBISHI LITERAL1
+DECODE_MITSUBISHI2 LITERAL1
+DECODE_MITSUBISHI_AC LITERAL1
+DECODE_MWM LITERAL1
+DECODE_NEC LITERAL1
+DECODE_NIKAI LITERAL1
+DECODE_PANASONIC LITERAL1
+DECODE_PANASONIC_AC LITERAL1
+DECODE_PIONEER LITERAL1
+DECODE_PRONTO LITERAL1
+DECODE_RC5 LITERAL1
+DECODE_RC6 LITERAL1
+DECODE_RCMM LITERAL1
+DECODE_SAMSUNG LITERAL1
+DECODE_SAMSUNG_AC LITERAL1
+DECODE_SANYO LITERAL1
+DECODE_SHARP LITERAL1
+DECODE_SHERWOOD LITERAL1
+DECODE_SONY LITERAL1
+DECODE_TOSHIBA_AC LITERAL1
+DECODE_TROTEC LITERAL1
+DECODE_WHIRLPOOL_AC LITERAL1
+DECODE_WHYNTER LITERAL1
+DENON LITERAL1
+DENON_48_BITS LITERAL1
+DENON_BITS LITERAL1
+DENON_LEGACY_BITS LITERAL1
+DISH LITERAL1
+DISH_BITS LITERAL1
+ELECTRA_AC LITERAL1
+FUJITSU_AC LITERAL1
+FUJITSU_AC_BITS LITERAL1
+FUJITSU_AC_CMD_STAY_ON LITERAL1
+FUJITSU_AC_CMD_STEP_HORIZ LITERAL1
+FUJITSU_AC_CMD_STEP_VERT LITERAL1
+FUJITSU_AC_CMD_TURN_OFF LITERAL1
+FUJITSU_AC_CMD_TURN_ON LITERAL1
+FUJITSU_AC_FAN_AUTO LITERAL1
+FUJITSU_AC_FAN_HIGH LITERAL1
+FUJITSU_AC_FAN_LOW LITERAL1
+FUJITSU_AC_FAN_MED LITERAL1
+FUJITSU_AC_FAN_QUIET LITERAL1
+FUJITSU_AC_MAX_TEMP LITERAL1
+FUJITSU_AC_MIN_BITS LITERAL1
+FUJITSU_AC_MIN_REPEAT LITERAL1
+FUJITSU_AC_MIN_TEMP LITERAL1
+FUJITSU_AC_MODE_AUTO LITERAL1
+FUJITSU_AC_MODE_COOL LITERAL1
+FUJITSU_AC_MODE_DRY LITERAL1
+FUJITSU_AC_MODE_FAN LITERAL1
+FUJITSU_AC_MODE_HEAT LITERAL1
+FUJITSU_AC_STATE_LENGTH LITERAL1
+FUJITSU_AC_STATE_LENGTH_SHORT LITERAL1
+FUJITSU_AC_SWING_BOTH LITERAL1
+FUJITSU_AC_SWING_HORIZ LITERAL1
+FUJITSU_AC_SWING_OFF LITERAL1
+FUJITSU_AC_SWING_VERT LITERAL1
+GICABLE LITERAL1
+GICABLE_BITS LITERAL1
+GLOBALCACHE LITERAL1
+GREE LITERAL1
+GREE_AUTO LITERAL1
+GREE_COOL LITERAL1
+GREE_DRY LITERAL1
+GREE_FAN LITERAL1
+GREE_FAN_MAX LITERAL1
+GREE_HEAT LITERAL1
+GREE_MAX_TEMP LITERAL1
+GREE_MIN_TEMP LITERAL1
+GREE_STATE_LENGTH LITERAL1
+GREE_SWING_AUTO LITERAL1
+GREE_SWING_DOWN LITERAL1
+GREE_SWING_DOWN_AUTO LITERAL1
+GREE_SWING_LAST_POS LITERAL1
+GREE_SWING_MIDDLE LITERAL1
+GREE_SWING_MIDDLE_AUTO LITERAL1
+GREE_SWING_MIDDLE_DOWN LITERAL1
+GREE_SWING_MIDDLE_UP LITERAL1
+GREE_SWING_UP LITERAL1
+GREE_SWING_UP_AUTO LITERAL1
+HAIER_AC LITERAL1
+HAIER_AC_AUTO LITERAL1
+HAIER_AC_CMD_FAN LITERAL1
+HAIER_AC_CMD_HEALTH LITERAL1
+HAIER_AC_CMD_MODE LITERAL1
+HAIER_AC_CMD_OFF LITERAL1
+HAIER_AC_CMD_ON LITERAL1
+HAIER_AC_CMD_SLEEP LITERAL1
+HAIER_AC_CMD_SWING LITERAL1
+HAIER_AC_CMD_TEMP_DOWN LITERAL1
+HAIER_AC_CMD_TEMP_UP LITERAL1
+HAIER_AC_CMD_TIMER_CANCEL LITERAL1
+HAIER_AC_CMD_TIMER_SET LITERAL1
+HAIER_AC_COOL LITERAL1
+HAIER_AC_DEF_TEMP LITERAL1
+HAIER_AC_DRY LITERAL1
+HAIER_AC_FAN LITERAL1
+HAIER_AC_FAN_AUTO LITERAL1
+HAIER_AC_FAN_HIGH LITERAL1
+HAIER_AC_FAN_LOW LITERAL1
+HAIER_AC_FAN_MED LITERAL1
+HAIER_AC_HEAT LITERAL1
+HAIER_AC_MAX_TEMP LITERAL1
+HAIER_AC_MIN_TEMP LITERAL1
+HAIER_AC_STATE_LENGTH LITERAL1
+HAIER_AC_SWING_CHG LITERAL1
+HAIER_AC_SWING_DOWN LITERAL1
+HAIER_AC_SWING_OFF LITERAL1
+HAIER_AC_SWING_UP LITERAL1
+HAIER_AC_YRW02 LITERAL1
+HAIER_AC_YRW02_AUTO LITERAL1
+HAIER_AC_YRW02_BUTTON_FAN LITERAL1
+HAIER_AC_YRW02_BUTTON_HEALTH LITERAL1
+HAIER_AC_YRW02_BUTTON_MODE LITERAL1
+HAIER_AC_YRW02_BUTTON_POWER LITERAL1
+HAIER_AC_YRW02_BUTTON_SLEEP LITERAL1
+HAIER_AC_YRW02_BUTTON_SWING LITERAL1
+HAIER_AC_YRW02_BUTTON_TEMP_DOWN LITERAL1
+HAIER_AC_YRW02_BUTTON_TEMP_UP LITERAL1
+HAIER_AC_YRW02_BUTTON_TURBO LITERAL1
+HAIER_AC_YRW02_COOL LITERAL1
+HAIER_AC_YRW02_DRY LITERAL1
+HAIER_AC_YRW02_FAN LITERAL1
+HAIER_AC_YRW02_FAN_AUTO LITERAL1
+HAIER_AC_YRW02_FAN_HIGH LITERAL1
+HAIER_AC_YRW02_FAN_LOW LITERAL1
+HAIER_AC_YRW02_FAN_MED LITERAL1
+HAIER_AC_YRW02_HEAT LITERAL1
+HAIER_AC_YRW02_STATE_LENGTH LITERAL1
+HAIER_AC_YRW02_SWING_AUTO LITERAL1
+HAIER_AC_YRW02_SWING_BOTTOM LITERAL1
+HAIER_AC_YRW02_SWING_DOWN LITERAL1
+HAIER_AC_YRW02_SWING_MIDDLE LITERAL1
+HAIER_AC_YRW02_SWING_OFF LITERAL1
+HAIER_AC_YRW02_SWING_TOP LITERAL1
+HAIER_AC_YRW02_TURBO_HIGH LITERAL1
+HAIER_AC_YRW02_TURBO_LOW LITERAL1
+HAIER_AC_YRW02_TURBO_OFF LITERAL1
+HIGH LITERAL1
+HITACHI_AC LITERAL1
+HITACHI_AC1 LITERAL1
+HITACHI_AC1_BITS LITERAL1
+HITACHI_AC1_STATE_LENGTH LITERAL1
+HITACHI_AC2 LITERAL1
+HITACHI_AC2_BITS LITERAL1
+HITACHI_AC2_STATE_LENGTH LITERAL1
+HITACHI_AC_BITS LITERAL1
+HITACHI_AC_STATE_LENGTH LITERAL1
+ICACHE_RAM_ATTR LITERAL1
+JVC LITERAL1
+JVC_BITS LITERAL1
+KELVINATOR LITERAL1
+KELVINATOR_AUTO LITERAL1
+KELVINATOR_AUTO_TEMP LITERAL1
+KELVINATOR_BASIC_FAN_MAX LITERAL1
+KELVINATOR_COOL LITERAL1
+KELVINATOR_DRY LITERAL1
+KELVINATOR_FAN LITERAL1
+KELVINATOR_FAN_AUTO LITERAL1
+KELVINATOR_FAN_MAX LITERAL1
+KELVINATOR_HEAT LITERAL1
+KELVINATOR_MAX_TEMP LITERAL1
+KELVINATOR_MIN_TEMP LITERAL1
+KELVINATOR_STATE_LENGTH LITERAL1
+LASERTAG LITERAL1
+LASERTAG_BITS LITERAL1
+LG LITERAL1
+LG2 LITERAL1
+LG32_BITS LITERAL1
+LG_BITS LITERAL1
+LOW LITERAL1
+LUTRON LITERAL1
+MAGIQUEST LITERAL1
+MAGIQUEST_BITS LITERAL1
+MIDEA LITERAL1
+MIDEA_AC_AUTO LITERAL1
+MIDEA_AC_COOL LITERAL1
+MIDEA_AC_DRY LITERAL1
+MIDEA_AC_FAN LITERAL1
+MIDEA_AC_FAN_AUTO LITERAL1
+MIDEA_AC_FAN_HI LITERAL1
+MIDEA_AC_FAN_LOW LITERAL1
+MIDEA_AC_FAN_MED LITERAL1
+MIDEA_AC_HEAT LITERAL1
+MIDEA_AC_MAX_TEMP_C LITERAL1
+MIDEA_AC_MAX_TEMP_F LITERAL1
+MIDEA_AC_MIN_TEMP_C LITERAL1
+MIDEA_AC_MIN_TEMP_F LITERAL1
+MIDEA_AC_POWER LITERAL1
+MIDEA_AC_SLEEP LITERAL1
+MIDEA_BITS LITERAL1
+MITSUBISHI LITERAL1
+MITSUBISHI2 LITERAL1
+MITSUBISHI_AC LITERAL1
+MITSUBISHI_AC_AUTO LITERAL1
+MITSUBISHI_AC_COOL LITERAL1
+MITSUBISHI_AC_DRY LITERAL1
+MITSUBISHI_AC_FAN_AUTO LITERAL1
+MITSUBISHI_AC_FAN_MAX LITERAL1
+MITSUBISHI_AC_FAN_REAL_MAX LITERAL1
+MITSUBISHI_AC_FAN_SILENT LITERAL1
+MITSUBISHI_AC_HEAT LITERAL1
+MITSUBISHI_AC_MAX_TEMP LITERAL1
+MITSUBISHI_AC_MIN_TEMP LITERAL1
+MITSUBISHI_AC_POWER LITERAL1
+MITSUBISHI_AC_STATE_LENGTH LITERAL1
+MITSUBISHI_AC_VANE_AUTO LITERAL1
+MITSUBISHI_AC_VANE_AUTO_MOVE LITERAL1
+MITSUBISHI_BITS LITERAL1
+MWM LITERAL1
+NEC LITERAL1
+NEC_BITS LITERAL1
+NEC_LIKE LITERAL1
+NIKAI LITERAL1
+NIKAI_BITS LITERAL1
+ONCE LITERAL1
+PANASONIC LITERAL1
+PANASONIC_AC LITERAL1
+PANASONIC_BITS LITERAL1
+PIONEER LITERAL1
+PRONTO LITERAL1
+RAW LITERAL1
+RAWTICK LITERAL1
+RC5 LITERAL1
+RC5X LITERAL1
+RC5X_BITS LITERAL1
+RC5_BITS LITERAL1
+RC6 LITERAL1
+RC6_36_BITS LITERAL1
+RC6_MODE0_BITS LITERAL1
+RCMM LITERAL1
+RCMM_BITS LITERAL1
+SAMSUNG LITERAL1
+SAMSUNG_AC LITERAL1
+SAMSUNG_BITS LITERAL1
+SANYO LITERAL1
+SANYO_LC7461 LITERAL1
+SANYO_LC7461_BITS LITERAL1
+SANYO_SA8650B_BITS LITERAL1
+SEND_AIWA_RC_T501 LITERAL1
+SEND_ARGO LITERAL1
+SEND_CARRIER_AC LITERAL1
+SEND_COOLIX LITERAL1
+SEND_DAIKIN LITERAL1
+SEND_DENON LITERAL1
+SEND_DISH LITERAL1
+SEND_ELECTRA_AC LITERAL1
+SEND_FUJITSU_AC LITERAL1
+SEND_GICABLE LITERAL1
+SEND_GLOBALCACHE LITERAL1
+SEND_GREE LITERAL1
+SEND_HAIER_AC LITERAL1
+SEND_HAIER_AC_YRW02 LITERAL1
+SEND_HITACHI_AC LITERAL1
+SEND_HITACHI_AC1 LITERAL1
+SEND_HITACHI_AC2 LITERAL1
+SEND_JVC LITERAL1
+SEND_KELVINATOR LITERAL1
+SEND_LASERTAG LITERAL1
+SEND_LG LITERAL1
+SEND_LUTRON LITERAL1
+SEND_MAGIQUEST LITERAL1
+SEND_MIDEA LITERAL1
+SEND_MITSUBISHI LITERAL1
+SEND_MITSUBISHI2 LITERAL1
+SEND_MITSUBISHI_AC LITERAL1
+SEND_MWM LITERAL1
+SEND_NEC LITERAL1
+SEND_NIKAI LITERAL1
+SEND_PANASONIC LITERAL1
+SEND_PANASONIC_AC LITERAL1
+SEND_PIONEER LITERAL1
+SEND_PRONTO LITERAL1
+SEND_RAW LITERAL1
+SEND_RC5 LITERAL1
+SEND_RC6 LITERAL1
+SEND_RCMM LITERAL1
+SEND_SAMSUNG LITERAL1
+SEND_SAMSUNG_AC LITERAL1
+SEND_SANYO LITERAL1
+SEND_SHARP LITERAL1
+SEND_SHERWOOD LITERAL1
+SEND_SONY LITERAL1
+SEND_TOSHIBA_AC LITERAL1
+SEND_TROTEC LITERAL1
+SEND_WHIRLPOOL_AC LITERAL1
+SEND_WHYNTER LITERAL1
+SHARP LITERAL1
+SHARP_BITS LITERAL1
+SHERWOOD LITERAL1
+SHERWOOD_BITS LITERAL1
+SONY LITERAL1
+SONY_12_BITS LITERAL1
+SONY_15_BITS LITERAL1
+SONY_20_BITS LITERAL1
+TIMEOUT_MS LITERAL1
+TOSHIBA_AC LITERAL1
+TOSHIBA_AC_AUTO LITERAL1
+TOSHIBA_AC_COOL LITERAL1
+TOSHIBA_AC_DRY LITERAL1
+TOSHIBA_AC_FAN_AUTO LITERAL1
+TOSHIBA_AC_FAN_MAX LITERAL1
+TOSHIBA_AC_HEAT LITERAL1
+TOSHIBA_AC_MAX_TEMP LITERAL1
+TOSHIBA_AC_MIN_TEMP LITERAL1
+TOSHIBA_AC_POWER LITERAL1
+TOSHIBA_AC_STATE_LENGTH LITERAL1
+TROTEC LITERAL1
+TROTEC_AUTO LITERAL1
+TROTEC_COMMAND_LENGTH LITERAL1
+TROTEC_COOL LITERAL1
+TROTEC_DRY LITERAL1
+TROTEC_FAN LITERAL1
+TROTEC_FAN_HIGH LITERAL1
+TROTEC_FAN_LOW LITERAL1
+TROTEC_FAN_MED LITERAL1
+TROTEC_MAX_TEMP LITERAL1
+TROTEC_MAX_TIMER LITERAL1
+TROTEC_MIN_TEMP LITERAL1
+TROTEC_MIN_TIMER LITERAL1
+UNKNOWN LITERAL1
+UNUSED LITERAL1
+WHIRLPOOL_AC LITERAL1
+WHYNTER LITERAL1
+WHYNTER_BITS LITERAL1
+kAiwaRcT501Bits LITERAL1
+kAiwaRcT501MinRepeats LITERAL1
+kAiwaRcT501PostBits LITERAL1
+kAiwaRcT501PostData LITERAL1
+kAiwaRcT501PreBits LITERAL1
+kAiwaRcT501PreData LITERAL1
+kArgoBitMark LITERAL1
+kArgoCoolAuto LITERAL1
+kArgoCoolHum LITERAL1
+kArgoCoolOff LITERAL1
+kArgoCoolOn LITERAL1
+kArgoFan1 LITERAL1
+kArgoFan2 LITERAL1
+kArgoFan3 LITERAL1
+kArgoFanAuto LITERAL1
+kArgoFlap1 LITERAL1
+kArgoFlap2 LITERAL1
+kArgoFlap3 LITERAL1
+kArgoFlap4 LITERAL1
+kArgoFlap5 LITERAL1
+kArgoFlap6 LITERAL1
+kArgoFlapAuto LITERAL1
+kArgoFlapFull LITERAL1
+kArgoHdrMark LITERAL1
+kArgoHdrSpace LITERAL1
+kArgoHeatAuto LITERAL1
+kArgoHeatBlink LITERAL1
+kArgoHeatOn LITERAL1
+kArgoMaxTemp LITERAL1
+kArgoMinTemp LITERAL1
+kArgoOneSpace LITERAL1
+kArgoStateLength LITERAL1
+kArgoZeroSpace LITERAL1
+kCarrierAcBitMark LITERAL1
+kCarrierAcBits LITERAL1
+kCarrierAcGap LITERAL1
+kCarrierAcHdrMark LITERAL1
+kCarrierAcHdrSpace LITERAL1
+kCarrierAcMinRepeat LITERAL1
+kCarrierAcOneSpace LITERAL1
+kCarrierAcZeroSpace LITERAL1
+kCoolixAuto LITERAL1
+kCoolixBitMark LITERAL1
+kCoolixBitMarkTicks LITERAL1
+kCoolixBits LITERAL1
+kCoolixClean LITERAL1
+kCoolixCool LITERAL1
+kCoolixDefaultState LITERAL1
+kCoolixDry LITERAL1
+kCoolixFan LITERAL1
+kCoolixFanAuto LITERAL1
+kCoolixFanFixed LITERAL1
+kCoolixFanMask LITERAL1
+kCoolixFanMax LITERAL1
+kCoolixFanMed LITERAL1
+kCoolixFanMin LITERAL1
+kCoolixFanTempCode LITERAL1
+kCoolixFanZoneFollow LITERAL1
+kCoolixHdrMark LITERAL1
+kCoolixHdrMarkTicks LITERAL1
+kCoolixHdrSpace LITERAL1
+kCoolixHdrSpaceTicks LITERAL1
+kCoolixHeat LITERAL1
+kCoolixLed LITERAL1
+kCoolixMinGap LITERAL1
+kCoolixMinGapTicks LITERAL1
+kCoolixModeMask LITERAL1
+kCoolixOff LITERAL1
+kCoolixOneSpace LITERAL1
+kCoolixOneSpaceTicks LITERAL1
+kCoolixPrefix LITERAL1
+kCoolixSensorTempIgnoreCode LITERAL1
+kCoolixSensorTempMask LITERAL1
+kCoolixSensorTempMax LITERAL1
+kCoolixSensorTempMin LITERAL1
+kCoolixSleep LITERAL1
+kCoolixSwing LITERAL1
+kCoolixTempMap LITERAL1
+kCoolixTempMask LITERAL1
+kCoolixTempMax LITERAL1
+kCoolixTempMin LITERAL1
+kCoolixTempRange LITERAL1
+kCoolixTick LITERAL1
+kCoolixTurbo LITERAL1
+kCoolixUnknown LITERAL1
+kCoolixZeroSpace LITERAL1
+kCoolixZeroSpaceTicks LITERAL1
+kCoolixZoneFollowMask LITERAL1
+kDaikinAuto LITERAL1
+kDaikinBitEcono LITERAL1
+kDaikinBitEye LITERAL1
+kDaikinBitMark LITERAL1
+kDaikinBitMold LITERAL1
+kDaikinBitOffTimer LITERAL1
+kDaikinBitOnTimer LITERAL1
+kDaikinBitPower LITERAL1
+kDaikinBitPowerful LITERAL1
+kDaikinBitSensor LITERAL1
+kDaikinBitSilent LITERAL1
+kDaikinBits LITERAL1
+kDaikinByteEcono LITERAL1
+kDaikinByteEye LITERAL1
+kDaikinByteMold LITERAL1
+kDaikinByteOffTimer LITERAL1
+kDaikinByteOnTimer LITERAL1
+kDaikinBytePower LITERAL1
+kDaikinBytePowerful LITERAL1
+kDaikinByteSensor LITERAL1
+kDaikinByteSilent LITERAL1
+kDaikinCool LITERAL1
+kDaikinCurBit LITERAL1
+kDaikinCurIndex LITERAL1
+kDaikinDry LITERAL1
+kDaikinFan LITERAL1
+kDaikinFanAuto LITERAL1
+kDaikinFanMax LITERAL1
+kDaikinFanMin LITERAL1
+kDaikinFanQuiet LITERAL1
+kDaikinFirstHeader64 LITERAL1
+kDaikinGap LITERAL1
+kDaikinHdrMark LITERAL1
+kDaikinHdrSpace LITERAL1
+kDaikinHeat LITERAL1
+kDaikinMarkExcess LITERAL1
+kDaikinMaxTemp LITERAL1
+kDaikinMinTemp LITERAL1
+kDaikinOneSpace LITERAL1
+kDaikinRawBits LITERAL1
+kDaikinStateLength LITERAL1
+kDaikinTolerance LITERAL1
+kDaikinZeroSpace LITERAL1
+kDenonBitMark LITERAL1
+kDenonBitMarkTicks LITERAL1
+kDenonBits LITERAL1
+kDenonHdrMark LITERAL1
+kDenonHdrMarkTicks LITERAL1
+kDenonHdrSpace LITERAL1
+kDenonHdrSpaceTicks LITERAL1
+kDenonLegacyBits LITERAL1
+kDenonManufacturer LITERAL1
+kDenonMinCommandLengthTicks LITERAL1
+kDenonMinGap LITERAL1
+kDenonMinGapTicks LITERAL1
+kDenonOneSpace LITERAL1
+kDenonOneSpaceTicks LITERAL1
+kDenonTick LITERAL1
+kDenonZeroSpace LITERAL1
+kDenonZeroSpaceTicks LITERAL1
+kDishBitMark LITERAL1
+kDishBitMarkTicks LITERAL1
+kDishBits LITERAL1
+kDishHdrMark LITERAL1
+kDishHdrMarkTicks LITERAL1
+kDishHdrSpace LITERAL1
+kDishHdrSpaceTicks LITERAL1
+kDishMinRepeat LITERAL1
+kDishOneSpace LITERAL1
+kDishOneSpaceTicks LITERAL1
+kDishRptSpace LITERAL1
+kDishRptSpaceTicks LITERAL1
+kDishTick LITERAL1
+kDishZeroSpace LITERAL1
+kDishZeroSpaceTicks LITERAL1
+kDutyDefault LITERAL1
+kDutyMax LITERAL1
+kElectraAcBitMark LITERAL1
+kElectraAcBits LITERAL1
+kElectraAcHdrMark LITERAL1
+kElectraAcHdrSpace LITERAL1
+kElectraAcMessageGap LITERAL1
+kElectraAcOneSpace LITERAL1
+kElectraAcStateLength LITERAL1
+kElectraAcZeroSpace LITERAL1
+kFnvBasis32 LITERAL1
+kFnvPrime32 LITERAL1
+kFooter LITERAL1
+kFujitsuAcBitMark LITERAL1
+kFujitsuAcBits LITERAL1
+kFujitsuAcCmdStayOn LITERAL1
+kFujitsuAcCmdStepHoriz LITERAL1
+kFujitsuAcCmdStepVert LITERAL1
+kFujitsuAcCmdTurnOff LITERAL1
+kFujitsuAcCmdTurnOn LITERAL1
+kFujitsuAcFanAuto LITERAL1
+kFujitsuAcFanHigh LITERAL1
+kFujitsuAcFanLow LITERAL1
+kFujitsuAcFanMed LITERAL1
+kFujitsuAcFanQuiet LITERAL1
+kFujitsuAcHdrMark LITERAL1
+kFujitsuAcHdrSpace LITERAL1
+kFujitsuAcMaxTemp LITERAL1
+kFujitsuAcMinBits LITERAL1
+kFujitsuAcMinGap LITERAL1
+kFujitsuAcMinRepeat LITERAL1
+kFujitsuAcMinTemp LITERAL1
+kFujitsuAcModeAuto LITERAL1
+kFujitsuAcModeCool LITERAL1
+kFujitsuAcModeDry LITERAL1
+kFujitsuAcModeFan LITERAL1
+kFujitsuAcModeHeat LITERAL1
+kFujitsuAcOneSpace LITERAL1
+kFujitsuAcStateLength LITERAL1
+kFujitsuAcStateLengthShort LITERAL1
+kFujitsuAcSwingBoth LITERAL1
+kFujitsuAcSwingHoriz LITERAL1
+kFujitsuAcSwingOff LITERAL1
+kFujitsuAcSwingVert LITERAL1
+kFujitsuAcZeroSpace LITERAL1
+kGicableBitMark LITERAL1
+kGicableBits LITERAL1
+kGicableHdrMark LITERAL1
+kGicableHdrSpace LITERAL1
+kGicableMinCommandLength LITERAL1
+kGicableMinGap LITERAL1
+kGicableMinRepeat LITERAL1
+kGicableOneSpace LITERAL1
+kGicableRptSpace LITERAL1
+kGicableZeroSpace LITERAL1
+kGlobalCacheFreqIndex LITERAL1
+kGlobalCacheMaxRepeat LITERAL1
+kGlobalCacheMinUsec LITERAL1
+kGlobalCacheRptIndex LITERAL1
+kGlobalCacheRptStartIndex LITERAL1
+kGlobalCacheStartIndex LITERAL1
+kGreeAuto LITERAL1
+kGreeBitMark LITERAL1
+kGreeBits LITERAL1
+kGreeBlockFooter LITERAL1
+kGreeBlockFooterBits LITERAL1
+kGreeCool LITERAL1
+kGreeDry LITERAL1
+kGreeFan LITERAL1
+kGreeFanMask LITERAL1
+kGreeFanMax LITERAL1
+kGreeHdrMark LITERAL1
+kGreeHdrSpace LITERAL1
+kGreeHeat LITERAL1
+kGreeLightMask LITERAL1
+kGreeMaxTemp LITERAL1
+kGreeMinTemp LITERAL1
+kGreeModeMask LITERAL1
+kGreeMsgSpace LITERAL1
+kGreeOneSpace LITERAL1
+kGreePower1Mask LITERAL1
+kGreePower2Mask LITERAL1
+kGreeSleepMask LITERAL1
+kGreeStateLength LITERAL1
+kGreeSwingAuto LITERAL1
+kGreeSwingAutoMask LITERAL1
+kGreeSwingDown LITERAL1
+kGreeSwingDownAuto LITERAL1
+kGreeSwingLastPos LITERAL1
+kGreeSwingMiddle LITERAL1
+kGreeSwingMiddleAuto LITERAL1
+kGreeSwingMiddleDown LITERAL1
+kGreeSwingMiddleUp LITERAL1
+kGreeSwingPosMask LITERAL1
+kGreeSwingUp LITERAL1
+kGreeSwingUpAuto LITERAL1
+kGreeTurboMask LITERAL1
+kGreeXfanMask LITERAL1
+kGreeZeroSpace LITERAL1
+kHaierACBits LITERAL1
+kHaierACStateLength LITERAL1
+kHaierACYRW02Bits LITERAL1
+kHaierACYRW02StateLength LITERAL1
+kHaierAcAuto LITERAL1
+kHaierAcBitMark LITERAL1
+kHaierAcCmdFan LITERAL1
+kHaierAcCmdHealth LITERAL1
+kHaierAcCmdMode LITERAL1
+kHaierAcCmdOff LITERAL1
+kHaierAcCmdOn LITERAL1
+kHaierAcCmdSleep LITERAL1
+kHaierAcCmdSwing LITERAL1
+kHaierAcCmdTempDown LITERAL1
+kHaierAcCmdTempUp LITERAL1
+kHaierAcCmdTimerCancel LITERAL1
+kHaierAcCmdTimerSet LITERAL1
+kHaierAcCool LITERAL1
+kHaierAcDefTemp LITERAL1
+kHaierAcDry LITERAL1
+kHaierAcFan LITERAL1
+kHaierAcFanAuto LITERAL1
+kHaierAcFanHigh LITERAL1
+kHaierAcFanLow LITERAL1
+kHaierAcFanMed LITERAL1
+kHaierAcHdr LITERAL1
+kHaierAcHdrGap LITERAL1
+kHaierAcHeat LITERAL1
+kHaierAcMaxTemp LITERAL1
+kHaierAcMaxTime LITERAL1
+kHaierAcMinGap LITERAL1
+kHaierAcMinTemp LITERAL1
+kHaierAcOneSpace LITERAL1
+kHaierAcPrefix LITERAL1
+kHaierAcSwingChg LITERAL1
+kHaierAcSwingDown LITERAL1
+kHaierAcSwingOff LITERAL1
+kHaierAcSwingUp LITERAL1
+kHaierAcYrw02Auto LITERAL1
+kHaierAcYrw02ButtonFan LITERAL1
+kHaierAcYrw02ButtonHealth LITERAL1
+kHaierAcYrw02ButtonMode LITERAL1
+kHaierAcYrw02ButtonPower LITERAL1
+kHaierAcYrw02ButtonSleep LITERAL1
+kHaierAcYrw02ButtonSwing LITERAL1
+kHaierAcYrw02ButtonTempDown LITERAL1
+kHaierAcYrw02ButtonTempUp LITERAL1
+kHaierAcYrw02ButtonTurbo LITERAL1
+kHaierAcYrw02Cool LITERAL1
+kHaierAcYrw02Dry LITERAL1
+kHaierAcYrw02Fan LITERAL1
+kHaierAcYrw02FanAuto LITERAL1
+kHaierAcYrw02FanHigh LITERAL1
+kHaierAcYrw02FanLow LITERAL1
+kHaierAcYrw02FanMed LITERAL1
+kHaierAcYrw02Heat LITERAL1
+kHaierAcYrw02Power LITERAL1
+kHaierAcYrw02Prefix LITERAL1
+kHaierAcYrw02Sleep LITERAL1
+kHaierAcYrw02SwingAuto LITERAL1
+kHaierAcYrw02SwingBottom LITERAL1
+kHaierAcYrw02SwingDown LITERAL1
+kHaierAcYrw02SwingMiddle LITERAL1
+kHaierAcYrw02SwingOff LITERAL1
+kHaierAcYrw02SwingTop LITERAL1
+kHaierAcYrw02TurboHigh LITERAL1
+kHaierAcYrw02TurboLow LITERAL1
+kHaierAcYrw02TurboOff LITERAL1
+kHaierAcZeroSpace LITERAL1
+kHeader LITERAL1
+kHitachiAc1Bits LITERAL1
+kHitachiAc1HdrMark LITERAL1
+kHitachiAc1HdrSpace LITERAL1
+kHitachiAc1StateLength LITERAL1
+kHitachiAc2Bits LITERAL1
+kHitachiAc2StateLength LITERAL1
+kHitachiAcBitMark LITERAL1
+kHitachiAcBits LITERAL1
+kHitachiAcHdrMark LITERAL1
+kHitachiAcHdrSpace LITERAL1
+kHitachiAcMinGap LITERAL1
+kHitachiAcOneSpace LITERAL1
+kHitachiAcStateLength LITERAL1
+kHitachiAcZeroSpace LITERAL1
+kIdleState LITERAL1
+kJvcBitMark LITERAL1
+kJvcBitMarkTicks LITERAL1
+kJvcBits LITERAL1
+kJvcHdrMark LITERAL1
+kJvcHdrMarkTicks LITERAL1
+kJvcHdrSpace LITERAL1
+kJvcHdrSpaceTicks LITERAL1
+kJvcMinGap LITERAL1
+kJvcMinGapTicks LITERAL1
+kJvcOneSpace LITERAL1
+kJvcOneSpaceTicks LITERAL1
+kJvcRptLength LITERAL1
+kJvcRptLengthTicks LITERAL1
+kJvcTick LITERAL1
+kJvcZeroSpace LITERAL1
+kJvcZeroSpaceTicks LITERAL1
+kKelvinatorAuto LITERAL1
+kKelvinatorAutoTemp LITERAL1
+kKelvinatorBasicFanMask LITERAL1
+kKelvinatorBasicFanMax LITERAL1
+kKelvinatorBitMark LITERAL1
+kKelvinatorBitMarkTicks LITERAL1
+kKelvinatorBits LITERAL1
+kKelvinatorChecksumStart LITERAL1
+kKelvinatorCmdFooter LITERAL1
+kKelvinatorCmdFooterBits LITERAL1
+kKelvinatorCool LITERAL1
+kKelvinatorDry LITERAL1
+kKelvinatorFan LITERAL1
+kKelvinatorFanAuto LITERAL1
+kKelvinatorFanMask LITERAL1
+kKelvinatorFanMax LITERAL1
+kKelvinatorFanOffset LITERAL1
+kKelvinatorGapSpace LITERAL1
+kKelvinatorGapSpaceTicks LITERAL1
+kKelvinatorHdrMark LITERAL1
+kKelvinatorHdrMarkTicks LITERAL1
+kKelvinatorHdrSpace LITERAL1
+kKelvinatorHdrSpaceTicks LITERAL1
+kKelvinatorHeat LITERAL1
+kKelvinatorIonFilter LITERAL1
+kKelvinatorIonFilterOffset LITERAL1
+kKelvinatorLight LITERAL1
+kKelvinatorLightOffset LITERAL1
+kKelvinatorMaxTemp LITERAL1
+kKelvinatorMinTemp LITERAL1
+kKelvinatorModeMask LITERAL1
+kKelvinatorOneSpace LITERAL1
+kKelvinatorOneSpaceTicks LITERAL1
+kKelvinatorPower LITERAL1
+kKelvinatorQuiet LITERAL1
+kKelvinatorQuietOffset LITERAL1
+kKelvinatorSleep1And3 LITERAL1
+kKelvinatorStateLength LITERAL1
+kKelvinatorTick LITERAL1
+kKelvinatorTurbo LITERAL1
+kKelvinatorTurboOffset LITERAL1
+kKelvinatorVentSwing LITERAL1
+kKelvinatorVentSwingH LITERAL1
+kKelvinatorVentSwingOffset LITERAL1
+kKelvinatorVentSwingV LITERAL1
+kKelvinatorXfan LITERAL1
+kKelvinatorXfanOffset LITERAL1
+kKelvinatorZeroSpace LITERAL1
+kKelvinatorZeroSpaceTicks LITERAL1
+kLasertagBits LITERAL1
+kLasertagDelta LITERAL1
+kLasertagExcess LITERAL1
+kLasertagMinGap LITERAL1
+kLasertagMinRepeat LITERAL1
+kLasertagMinSamples LITERAL1
+kLasertagTick LITERAL1
+kLasertagTolerance LITERAL1
+kLg2BitMark LITERAL1
+kLg2BitMarkTicks LITERAL1
+kLg2HdrMark LITERAL1
+kLg2HdrMarkTicks LITERAL1
+kLg2HdrSpace LITERAL1
+kLg2HdrSpaceTicks LITERAL1
+kLg32Bits LITERAL1
+kLg32HdrMark LITERAL1
+kLg32HdrMarkTicks LITERAL1
+kLg32HdrSpace LITERAL1
+kLg32HdrSpaceTicks LITERAL1
+kLg32RptHdrMark LITERAL1
+kLg32RptHdrMarkTicks LITERAL1
+kLgBitMark LITERAL1
+kLgBitMarkTicks LITERAL1
+kLgBits LITERAL1
+kLgHdrMark LITERAL1
+kLgHdrMarkTicks LITERAL1
+kLgHdrSpace LITERAL1
+kLgHdrSpaceTicks LITERAL1
+kLgMinGap LITERAL1
+kLgMinGapTicks LITERAL1
+kLgMinMessageLength LITERAL1
+kLgMinMessageLengthTicks LITERAL1
+kLgOneSpace LITERAL1
+kLgOneSpaceTicks LITERAL1
+kLgRptSpace LITERAL1
+kLgRptSpaceTicks LITERAL1
+kLgTick LITERAL1
+kLgZeroSpace LITERAL1
+kLgZeroSpaceTicks LITERAL1
+kLutronBits LITERAL1
+kLutronDelta LITERAL1
+kLutronGap LITERAL1
+kLutronTick LITERAL1
+kMWMDelta LITERAL1
+kMWMExcess LITERAL1
+kMWMMaxWidth LITERAL1
+kMWMMinGap LITERAL1
+kMWMMinSamples LITERAL1
+kMWMTick LITERAL1
+kMWMTolerance LITERAL1
+kMagiQuestGap LITERAL1
+kMagiQuestMarkOne LITERAL1
+kMagiQuestMarkZero LITERAL1
+kMagiQuestOneRatio LITERAL1
+kMagiQuestSpaceOne LITERAL1
+kMagiQuestSpaceZero LITERAL1
+kMagiQuestTotalUsec LITERAL1
+kMagiQuestZeroRatio LITERAL1
+kMagiquestBits LITERAL1
+kMark LITERAL1
+kMarkExcess LITERAL1
+kMarkState LITERAL1
+kMaxAccurateUsecDelay LITERAL1
+kMaxTimeoutMs LITERAL1
+kMideaACAuto LITERAL1
+kMideaACChecksumMask LITERAL1
+kMideaACCool LITERAL1
+kMideaACDry LITERAL1
+kMideaACFan LITERAL1
+kMideaACFanAuto LITERAL1
+kMideaACFanHigh LITERAL1
+kMideaACFanLow LITERAL1
+kMideaACFanMask LITERAL1
+kMideaACFanMed LITERAL1
+kMideaACHeat LITERAL1
+kMideaACMaxTempC LITERAL1
+kMideaACMaxTempF LITERAL1
+kMideaACMinTempC LITERAL1
+kMideaACMinTempF LITERAL1
+kMideaACModeMask LITERAL1
+kMideaACPower LITERAL1
+kMideaACSleep LITERAL1
+kMideaACStateMask LITERAL1
+kMideaACTempMask LITERAL1
+kMideaBitMark LITERAL1
+kMideaBitMarkTicks LITERAL1
+kMideaBits LITERAL1
+kMideaHdrMark LITERAL1
+kMideaHdrMarkTicks LITERAL1
+kMideaHdrSpace LITERAL1
+kMideaHdrSpaceTicks LITERAL1
+kMideaMinGap LITERAL1
+kMideaMinGapTicks LITERAL1
+kMideaMinRepeat LITERAL1
+kMideaOneSpace LITERAL1
+kMideaOneSpaceTicks LITERAL1
+kMideaTick LITERAL1
+kMideaTolerance LITERAL1
+kMideaZeroSpace LITERAL1
+kMideaZeroSpaceTicks LITERAL1
+kMitsubishi2BitMark LITERAL1
+kMitsubishi2HdrMark LITERAL1
+kMitsubishi2HdrSpace LITERAL1
+kMitsubishi2MinGap LITERAL1
+kMitsubishi2OneSpace LITERAL1
+kMitsubishi2ZeroSpace LITERAL1
+kMitsubishiACBits LITERAL1
+kMitsubishiACMinRepeat LITERAL1
+kMitsubishiACStateLength LITERAL1
+kMitsubishiAcAuto LITERAL1
+kMitsubishiAcBitMark LITERAL1
+kMitsubishiAcCool LITERAL1
+kMitsubishiAcDry LITERAL1
+kMitsubishiAcFanAuto LITERAL1
+kMitsubishiAcFanMax LITERAL1
+kMitsubishiAcFanRealMax LITERAL1
+kMitsubishiAcFanSilent LITERAL1
+kMitsubishiAcHdrMark LITERAL1
+kMitsubishiAcHdrSpace LITERAL1
+kMitsubishiAcHeat LITERAL1
+kMitsubishiAcMaxTemp LITERAL1
+kMitsubishiAcMinTemp LITERAL1
+kMitsubishiAcNoTimer LITERAL1
+kMitsubishiAcOneSpace LITERAL1
+kMitsubishiAcPower LITERAL1
+kMitsubishiAcRptMark LITERAL1
+kMitsubishiAcRptSpace LITERAL1
+kMitsubishiAcStartStopTimer LITERAL1
+kMitsubishiAcStartTimer LITERAL1
+kMitsubishiAcStopTimer LITERAL1
+kMitsubishiAcVaneAuto LITERAL1
+kMitsubishiAcVaneAutoMove LITERAL1
+kMitsubishiAcZeroSpace LITERAL1
+kMitsubishiBitMark LITERAL1
+kMitsubishiBitMarkTicks LITERAL1
+kMitsubishiBits LITERAL1
+kMitsubishiMinCommandLength LITERAL1
+kMitsubishiMinCommandLengthTicks LITERAL1
+kMitsubishiMinGap LITERAL1
+kMitsubishiMinGapTicks LITERAL1
+kMitsubishiMinRepeat LITERAL1
+kMitsubishiOneSpace LITERAL1
+kMitsubishiOneSpaceTicks LITERAL1
+kMitsubishiTick LITERAL1
+kMitsubishiZeroSpace LITERAL1
+kMitsubishiZeroSpaceTicks LITERAL1
+kNECBits LITERAL1
+kNecBitMark LITERAL1
+kNecBitMarkTicks LITERAL1
+kNecHdrMark LITERAL1
+kNecHdrMarkTicks LITERAL1
+kNecHdrSpace LITERAL1
+kNecHdrSpaceTicks LITERAL1
+kNecMinCommandLength LITERAL1
+kNecMinCommandLengthTicks LITERAL1
+kNecMinGap LITERAL1
+kNecMinGapTicks LITERAL1
+kNecOneSpace LITERAL1
+kNecOneSpaceTicks LITERAL1
+kNecRptLength LITERAL1
+kNecRptSpace LITERAL1
+kNecRptSpaceTicks LITERAL1
+kNecTick LITERAL1
+kNecZeroSpace LITERAL1
+kNecZeroSpaceTicks LITERAL1
+kNikaiBitMark LITERAL1
+kNikaiBitMarkTicks LITERAL1
+kNikaiBits LITERAL1
+kNikaiHdrMark LITERAL1
+kNikaiHdrMarkTicks LITERAL1
+kNikaiHdrSpace LITERAL1
+kNikaiHdrSpaceTicks LITERAL1
+kNikaiMinGap LITERAL1
+kNikaiMinGapTicks LITERAL1
+kNikaiOneSpace LITERAL1
+kNikaiOneSpaceTicks LITERAL1
+kNikaiTick LITERAL1
+kNikaiZeroSpace LITERAL1
+kNikaiZeroSpaceTicks LITERAL1
+kNoRepeat LITERAL1
+kPanasonicAcAuto LITERAL1
+kPanasonicAcBits LITERAL1
+kPanasonicAcChecksumInit LITERAL1
+kPanasonicAcCool LITERAL1
+kPanasonicAcDry LITERAL1
+kPanasonicAcExcess LITERAL1
+kPanasonicAcFan LITERAL1
+kPanasonicAcFanAuto LITERAL1
+kPanasonicAcFanMax LITERAL1
+kPanasonicAcFanMin LITERAL1
+kPanasonicAcFanModeTemp LITERAL1
+kPanasonicAcFanOffset LITERAL1
+kPanasonicAcHeat LITERAL1
+kPanasonicAcMaxTemp LITERAL1
+kPanasonicAcMessageGap LITERAL1
+kPanasonicAcMinTemp LITERAL1
+kPanasonicAcOffTimer LITERAL1
+kPanasonicAcOnTimer LITERAL1
+kPanasonicAcPower LITERAL1
+kPanasonicAcPowerful LITERAL1
+kPanasonicAcPowerfulCkp LITERAL1
+kPanasonicAcQuiet LITERAL1
+kPanasonicAcQuietCkp LITERAL1
+kPanasonicAcSection1Length LITERAL1
+kPanasonicAcSectionGap LITERAL1
+kPanasonicAcShortBits LITERAL1
+kPanasonicAcStateLength LITERAL1
+kPanasonicAcStateShortLength LITERAL1
+kPanasonicAcSwingHAuto LITERAL1
+kPanasonicAcSwingHFullLeft LITERAL1
+kPanasonicAcSwingHFullRight LITERAL1
+kPanasonicAcSwingHLeft LITERAL1
+kPanasonicAcSwingHMiddle LITERAL1
+kPanasonicAcSwingHRight LITERAL1
+kPanasonicAcSwingVAuto LITERAL1
+kPanasonicAcSwingVDown LITERAL1
+kPanasonicAcSwingVUp LITERAL1
+kPanasonicAcTimeMax LITERAL1
+kPanasonicAcTimeSpecial LITERAL1
+kPanasonicAcTolerance LITERAL1
+kPanasonicBitMark LITERAL1
+kPanasonicBitMarkTicks LITERAL1
+kPanasonicBits LITERAL1
+kPanasonicCkp LITERAL1
+kPanasonicDke LITERAL1
+kPanasonicEndGap LITERAL1
+kPanasonicFreq LITERAL1
+kPanasonicHdrMark LITERAL1
+kPanasonicHdrMarkTicks LITERAL1
+kPanasonicHdrSpace LITERAL1
+kPanasonicHdrSpaceTicks LITERAL1
+kPanasonicJke LITERAL1
+kPanasonicKnownGoodState LITERAL1
+kPanasonicLke LITERAL1
+kPanasonicManufacturer LITERAL1
+kPanasonicMinCommandLength LITERAL1
+kPanasonicMinCommandLengthTicks LITERAL1
+kPanasonicMinGap LITERAL1
+kPanasonicMinGapTicks LITERAL1
+kPanasonicNke LITERAL1
+kPanasonicOneSpace LITERAL1
+kPanasonicOneSpaceTicks LITERAL1
+kPanasonicTick LITERAL1
+kPanasonicUnknown LITERAL1
+kPanasonicZeroSpace LITERAL1
+kPanasonicZeroSpaceTicks LITERAL1
+kPeriodOffset LITERAL1
+kPioneerBits LITERAL1
+kProntoDataOffset LITERAL1
+kProntoFreqFactor LITERAL1
+kProntoFreqOffset LITERAL1
+kProntoMinLength LITERAL1
+kProntoSeq1LenOffset LITERAL1
+kProntoSeq2LenOffset LITERAL1
+kProntoTypeOffset LITERAL1
+kRC5Bits LITERAL1
+kRC5RawBits LITERAL1
+kRC5XBits LITERAL1
+kRC6Mode0Bits LITERAL1
+kRC6_36Bits LITERAL1
+kRCMMBits LITERAL1
+kRawBuf LITERAL1
+kRawTick LITERAL1
+kRc5MinCommandLength LITERAL1
+kRc5MinGap LITERAL1
+kRc5SamplesMin LITERAL1
+kRc5T1 LITERAL1
+kRc5ToggleMask LITERAL1
+kRc6HdrMark LITERAL1
+kRc6HdrMarkTicks LITERAL1
+kRc6HdrSpace LITERAL1
+kRc6HdrSpaceTicks LITERAL1
+kRc6RptLength LITERAL1
+kRc6RptLengthTicks LITERAL1
+kRc6Tick LITERAL1
+kRc6ToggleMask LITERAL1
+kRc6_36ToggleMask LITERAL1
+kRcmmBitMark LITERAL1
+kRcmmBitMarkTicks LITERAL1
+kRcmmBitSpace0 LITERAL1
+kRcmmBitSpace0Ticks LITERAL1
+kRcmmBitSpace1 LITERAL1
+kRcmmBitSpace1Ticks LITERAL1
+kRcmmBitSpace2 LITERAL1
+kRcmmBitSpace2Ticks LITERAL1
+kRcmmBitSpace3 LITERAL1
+kRcmmBitSpace3Ticks LITERAL1
+kRcmmExcess LITERAL1
+kRcmmHdrMark LITERAL1
+kRcmmHdrMarkTicks LITERAL1
+kRcmmHdrSpace LITERAL1
+kRcmmHdrSpaceTicks LITERAL1
+kRcmmMinGap LITERAL1
+kRcmmMinGapTicks LITERAL1
+kRcmmRptLength LITERAL1
+kRcmmRptLengthTicks LITERAL1
+kRcmmTick LITERAL1
+kRcmmTolerance LITERAL1
+kRepeat LITERAL1
+kSamsungACSectionLength LITERAL1
+kSamsungAcAuto LITERAL1
+kSamsungAcAutoTemp LITERAL1
+kSamsungAcBeepMask LITERAL1
+kSamsungAcBitMark LITERAL1
+kSamsungAcBits LITERAL1
+kSamsungAcCleanMask10 LITERAL1
+kSamsungAcCleanMask11 LITERAL1
+kSamsungAcCool LITERAL1
+kSamsungAcDry LITERAL1
+kSamsungAcExtendedBits LITERAL1
+kSamsungAcExtendedStateLength LITERAL1
+kSamsungAcFan LITERAL1
+kSamsungAcFanAuto LITERAL1
+kSamsungAcFanAuto2 LITERAL1
+kSamsungAcFanHigh LITERAL1
+kSamsungAcFanLow LITERAL1
+kSamsungAcFanMask LITERAL1
+kSamsungAcFanMed LITERAL1
+kSamsungAcFanTurbo LITERAL1
+kSamsungAcHdrMark LITERAL1
+kSamsungAcHdrSpace LITERAL1
+kSamsungAcHeat LITERAL1
+kSamsungAcMaxTemp LITERAL1
+kSamsungAcMinTemp LITERAL1
+kSamsungAcModeMask LITERAL1
+kSamsungAcOneSpace LITERAL1
+kSamsungAcPowerMask1 LITERAL1
+kSamsungAcPowerMask2 LITERAL1
+kSamsungAcPowerSection LITERAL1
+kSamsungAcQuietMask11 LITERAL1
+kSamsungAcSectionGap LITERAL1
+kSamsungAcSectionMark LITERAL1
+kSamsungAcSectionSpace LITERAL1
+kSamsungAcSections LITERAL1
+kSamsungAcStateLength LITERAL1
+kSamsungAcSwingMask LITERAL1
+kSamsungAcSwingMove LITERAL1
+kSamsungAcSwingStop LITERAL1
+kSamsungAcTempMask LITERAL1
+kSamsungAcZeroSpace LITERAL1
+kSamsungBitMark LITERAL1
+kSamsungBitMarkTicks LITERAL1
+kSamsungBits LITERAL1
+kSamsungHdrMark LITERAL1
+kSamsungHdrMarkTicks LITERAL1
+kSamsungHdrSpace LITERAL1
+kSamsungHdrSpaceTicks LITERAL1
+kSamsungMinGap LITERAL1
+kSamsungMinGapTicks LITERAL1
+kSamsungMinMessageLength LITERAL1
+kSamsungMinMessageLengthTicks LITERAL1
+kSamsungOneSpace LITERAL1
+kSamsungOneSpaceTicks LITERAL1
+kSamsungRptSpace LITERAL1
+kSamsungRptSpaceTicks LITERAL1
+kSamsungTick LITERAL1
+kSamsungZeroSpace LITERAL1
+kSamsungZeroSpaceTicks LITERAL1
+kSanyoLC7461AddressBits LITERAL1
+kSanyoLC7461Bits LITERAL1
+kSanyoLC7461CommandBits LITERAL1
+kSanyoLc7461AddressMask LITERAL1
+kSanyoLc7461BitMark LITERAL1
+kSanyoLc7461CommandMask LITERAL1
+kSanyoLc7461HdrMark LITERAL1
+kSanyoLc7461HdrSpace LITERAL1
+kSanyoLc7461MinCommandLength LITERAL1
+kSanyoLc7461MinGap LITERAL1
+kSanyoLc7461OneSpace LITERAL1
+kSanyoLc7461ZeroSpace LITERAL1
+kSanyoSA8650BBits LITERAL1
+kSanyoSa8650bDoubleSpaceUsecs LITERAL1
+kSanyoSa8650bHdrMark LITERAL1
+kSanyoSa8650bHdrSpace LITERAL1
+kSanyoSa8650bOneMark LITERAL1
+kSanyoSa8650bRptLength LITERAL1
+kSanyoSa8650bZeroMark LITERAL1
+kSharpAddressBits LITERAL1
+kSharpAddressMask LITERAL1
+kSharpBitMark LITERAL1
+kSharpBitMarkTicks LITERAL1
+kSharpBits LITERAL1
+kSharpCommandBits LITERAL1
+kSharpCommandMask LITERAL1
+kSharpGap LITERAL1
+kSharpGapTicks LITERAL1
+kSharpOneSpace LITERAL1
+kSharpOneSpaceTicks LITERAL1
+kSharpTick LITERAL1
+kSharpToggleMask LITERAL1
+kSharpZeroSpace LITERAL1
+kSharpZeroSpaceTicks LITERAL1
+kSherwoodBits LITERAL1
+kSherwoodMinRepeat LITERAL1
+kSingleRepeat LITERAL1
+kSony12Bits LITERAL1
+kSony15Bits LITERAL1
+kSony20Bits LITERAL1
+kSonyHdrMark LITERAL1
+kSonyHdrMarkTicks LITERAL1
+kSonyMinBits LITERAL1
+kSonyMinGap LITERAL1
+kSonyMinGapTicks LITERAL1
+kSonyMinRepeat LITERAL1
+kSonyOneMark LITERAL1
+kSonyOneMarkTicks LITERAL1
+kSonyRptLength LITERAL1
+kSonyRptLengthTicks LITERAL1
+kSonySpace LITERAL1
+kSonySpaceTicks LITERAL1
+kSonyTick LITERAL1
+kSonyZeroMark LITERAL1
+kSonyZeroMarkTicks LITERAL1
+kSpace LITERAL1
+kSpaceState LITERAL1
+kStartOffset LITERAL1
+kStateSizeMax LITERAL1
+kStopState LITERAL1
+kTimeoutMs LITERAL1
+kTolerance LITERAL1
+kToshibaACBits LITERAL1
+kToshibaACMinRepeat LITERAL1
+kToshibaACStateLength LITERAL1
+kToshibaAcAuto LITERAL1
+kToshibaAcBitMark LITERAL1
+kToshibaAcCool LITERAL1
+kToshibaAcDry LITERAL1
+kToshibaAcFanAuto LITERAL1
+kToshibaAcFanMax LITERAL1
+kToshibaAcHdrMark LITERAL1
+kToshibaAcHdrSpace LITERAL1
+kToshibaAcHeat LITERAL1
+kToshibaAcMaxTemp LITERAL1
+kToshibaAcMinGap LITERAL1
+kToshibaAcMinTemp LITERAL1
+kToshibaAcOneSpace LITERAL1
+kToshibaAcPower LITERAL1
+kToshibaAcZeroSpace LITERAL1
+kTrotecAuto LITERAL1
+kTrotecCool LITERAL1
+kTrotecDefTemp LITERAL1
+kTrotecDry LITERAL1
+kTrotecFan LITERAL1
+kTrotecFanHigh LITERAL1
+kTrotecFanLow LITERAL1
+kTrotecFanMed LITERAL1
+kTrotecGap LITERAL1
+kTrotecGapEnd LITERAL1
+kTrotecHdrMark LITERAL1
+kTrotecHdrSpace LITERAL1
+kTrotecIntro1 LITERAL1
+kTrotecIntro2 LITERAL1
+kTrotecMaxTemp LITERAL1
+kTrotecMaxTimer LITERAL1
+kTrotecMinTemp LITERAL1
+kTrotecMinTimer LITERAL1
+kTrotecOff LITERAL1
+kTrotecOn LITERAL1
+kTrotecOneMark LITERAL1
+kTrotecOneSpace LITERAL1
+kTrotecSleepOn LITERAL1
+kTrotecStateLength LITERAL1
+kTrotecTimerOn LITERAL1
+kTrotecZeroMark LITERAL1
+kTrotecZeroSpace LITERAL1
+kUnknownThreshold LITERAL1
+kWhirlpoolAcBitMark LITERAL1
+kWhirlpoolAcBits LITERAL1
+kWhirlpoolAcGap LITERAL1
+kWhirlpoolAcHdrMark LITERAL1
+kWhirlpoolAcHdrSpace LITERAL1
+kWhirlpoolAcMinGap LITERAL1
+kWhirlpoolAcOneSpace LITERAL1
+kWhirlpoolAcSections LITERAL1
+kWhirlpoolAcStateLength LITERAL1
+kWhirlpoolAcZeroSpace LITERAL1
+kWhynterBitMark LITERAL1
+kWhynterBitMarkTicks LITERAL1
+kWhynterBits LITERAL1
+kWhynterHdrMark LITERAL1
+kWhynterHdrMarkTicks LITERAL1
+kWhynterHdrSpace LITERAL1
+kWhynterHdrSpaceTicks LITERAL1
+kWhynterMinCommandLength LITERAL1
+kWhynterMinCommandLengthTicks LITERAL1
+kWhynterMinGap LITERAL1
+kWhynterMinGapTicks LITERAL1
+kWhynterOneSpace LITERAL1
+kWhynterOneSpaceTicks LITERAL1
+kWhynterTick LITERAL1
+kWhynterZeroSpace LITERAL1
+kWhynterZeroSpaceTicks LITERAL1
diff --git a/lib/IRremoteESP8266-2.2.1.02/library.json b/lib/IRremoteESP8266-2.5.2.03/library.json
similarity index 97%
rename from lib/IRremoteESP8266-2.2.1.02/library.json
rename to lib/IRremoteESP8266-2.5.2.03/library.json
index b8141a2ebe37..3fc14f027e16 100644
--- a/lib/IRremoteESP8266-2.2.1.02/library.json
+++ b/lib/IRremoteESP8266-2.5.2.03/library.json
@@ -1,6 +1,6 @@
{
"name": "IRremoteESP8266",
- "version": "2.2.1",
+ "version": "2.5.2",
"keywords": "infrared, ir, remote, esp8266",
"description": "Send and receive infrared signals with multiple protocols (ESP8266)",
"repository":
diff --git a/lib/IRremoteESP8266-2.2.1.02/library.properties b/lib/IRremoteESP8266-2.5.2.03/library.properties
similarity index 96%
rename from lib/IRremoteESP8266-2.2.1.02/library.properties
rename to lib/IRremoteESP8266-2.5.2.03/library.properties
index ae6f93da7b2b..e71dc41542ef 100644
--- a/lib/IRremoteESP8266-2.2.1.02/library.properties
+++ b/lib/IRremoteESP8266-2.5.2.03/library.properties
@@ -1,5 +1,5 @@
name=IRremoteESP8266
-version=2.2.1
+version=2.5.2
author=Sebastien Warin, Mark Szabo, Ken Shirriff, David Conran
maintainer=Mark Szabo, David Conran, Sebastien Warin, Roi Dayan, Massimiliano Pinto
sentence=Send and receive infrared signals with multiple protocols (ESP8266)
diff --git a/lib/IRremoteESP8266-2.2.1.02/platformio.ini b/lib/IRremoteESP8266-2.5.2.03/platformio.ini
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/platformio.ini
rename to lib/IRremoteESP8266-2.5.2.03/platformio.ini
diff --git a/lib/IRremoteESP8266-2.5.2.03/pylintrc b/lib/IRremoteESP8266-2.5.2.03/pylintrc
new file mode 100644
index 000000000000..987c6abf9dd7
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/pylintrc
@@ -0,0 +1,12 @@
+[REPORTS]
+
+# Tells whether to display a full report or only the messages
+reports=no
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=80
+
+# String used as indentation unit.
+indent-string=' '
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/CPPLINT.cfg b/lib/IRremoteESP8266-2.5.2.03/src/CPPLINT.cfg
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/src/CPPLINT.cfg
rename to lib/IRremoteESP8266-2.5.2.03/src/CPPLINT.cfg
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/IRrecv.cpp b/lib/IRremoteESP8266-2.5.2.03/src/IRrecv.cpp
similarity index 59%
rename from lib/IRremoteESP8266-2.2.1.02/src/IRrecv.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/IRrecv.cpp
index d8e390633f0c..b2c98439694b 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/IRrecv.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/IRrecv.cpp
@@ -7,13 +7,14 @@
#include
#ifndef UNIT_TEST
extern "C" {
- #include
- #include
+#include
+#include
}
#include
#endif
#include
#include "IRremoteESP8266.h"
+#include "IRutils.h"
#ifdef UNIT_TEST
#undef ICACHE_RAM_ATTR
@@ -34,8 +35,7 @@ irparams_t *irparams_save; // A copy of the interrupt state while decoding.
#ifndef UNIT_TEST
static void ICACHE_RAM_ATTR read_timeout(void *arg __attribute__((unused))) {
os_intr_lock();
- if (irparams.rawlen)
- irparams.rcvstate = STATE_STOP;
+ if (irparams.rawlen) irparams.rcvstate = kStopState;
os_intr_unlock();
}
@@ -57,25 +57,24 @@ static void ICACHE_RAM_ATTR gpio_intr() {
if (rawlen >= irparams.bufsize) {
irparams.overflow = true;
- irparams.rcvstate = STATE_STOP;
+ irparams.rcvstate = kStopState;
}
- if (irparams.rcvstate == STATE_STOP)
- return;
+ if (irparams.rcvstate == kStopState) return;
- if (irparams.rcvstate == STATE_IDLE) {
- irparams.rcvstate = STATE_MARK;
+ if (irparams.rcvstate == kIdleState) {
+ irparams.rcvstate = kMarkState;
irparams.rawbuf[rawlen] = 1;
} else {
if (now < start)
- irparams.rawbuf[rawlen] = (UINT32_MAX - start + now) / RAWTICK;
+ irparams.rawbuf[rawlen] = (UINT32_MAX - start + now) / kRawTick;
else
- irparams.rawbuf[rawlen] = (now - start) / RAWTICK;
+ irparams.rawbuf[rawlen] = (now - start) / kRawTick;
}
irparams.rawlen++;
start = now;
- #define ONCE 0
+#define ONCE 0
os_timer_arm(&timer, irparams.timeout, ONCE);
}
#endif // UNIT_TEST
@@ -85,23 +84,24 @@ static void ICACHE_RAM_ATTR gpio_intr() {
// Class constructor
// Args:
// recvpin: GPIO pin the IR receiver module's data pin is connected to.
-// bufsize: Nr. of entries to have in the capture buffer. (Default: RAWBUF)
+// bufsize: Nr. of entries to have in the capture buffer. (Default: kRawBuf)
// timeout: Nr. of milli-Seconds of no signal before we stop capturing data.
-// (Default: TIMEOUT_MS)
+// (Default: kTimeoutMs)
// save_buffer: Use a second (save) buffer to decode from. (Def: false)
// Returns:
-// A IRrecv class object.
+// An IRrecv class object.
IRrecv::IRrecv(uint16_t recvpin, uint16_t bufsize, uint8_t timeout,
bool save_buffer) {
irparams.recvpin = recvpin;
irparams.bufsize = bufsize;
// Ensure we are going to be able to store all possible values in the
// capture buffer.
- irparams.timeout = std::min(timeout, (uint8_t) MAX_TIMEOUT_MS);
+ irparams.timeout = std::min(timeout, (uint8_t)kMaxTimeoutMs);
irparams.rawbuf = new uint16_t[bufsize];
if (irparams.rawbuf == NULL) {
- DPRINTLN("Could not allocate memory for the primary IR buffer.\n"
- "Try a smaller size for CAPTURE_BUFFER_SIZE.\nRebooting!");
+ DPRINTLN(
+ "Could not allocate memory for the primary IR buffer.\n"
+ "Try a smaller size for CAPTURE_BUFFER_SIZE.\nRebooting!");
#ifndef UNIT_TEST
ESP.restart(); // Mem alloc failure. Reboot.
#endif
@@ -112,8 +112,9 @@ IRrecv::IRrecv(uint16_t recvpin, uint16_t bufsize, uint8_t timeout,
irparams_save->rawbuf = new uint16_t[bufsize];
// Check we allocated the memory successfully.
if (irparams_save->rawbuf == NULL) {
- DPRINTLN("Could not allocate memory for the second IR buffer.\n"
- "Try a smaller size for CAPTURE_BUFFER_SIZE.\nRebooting!");
+ DPRINTLN(
+ "Could not allocate memory for the second IR buffer.\n"
+ "Try a smaller size for CAPTURE_BUFFER_SIZE.\nRebooting!");
#ifndef UNIT_TEST
ESP.restart(); // Mem alloc failure. Reboot.
#endif
@@ -121,13 +122,16 @@ IRrecv::IRrecv(uint16_t recvpin, uint16_t bufsize, uint8_t timeout,
} else {
irparams_save = NULL;
}
+#if DECODE_HASH
+ unknown_threshold = kUnknownThreshold;
+#endif // DECODE_HASH
}
// Class destructor
IRrecv::~IRrecv(void) {
- delete [] irparams.rawbuf;
+ delete[] irparams.rawbuf;
if (irparams_save != NULL) {
- delete [] irparams_save->rawbuf;
+ delete[] irparams_save->rawbuf;
delete irparams_save;
}
}
@@ -156,7 +160,7 @@ void IRrecv::disableIRIn() {
}
void IRrecv::resume() {
- irparams.rcvstate = STATE_IDLE;
+ irparams.rcvstate = kIdleState;
irparams.rawlen = 0;
irparams.overflow = false;
}
@@ -164,15 +168,15 @@ void IRrecv::resume() {
// Make a copy of the interrupt state & buffer data.
// Needed because irparams is marked as volatile, thus memcpy() isn't allowed.
// Only call this when you know the interrupt handlers won't modify anything.
-// i.e. In STATE_STOP.
+// i.e. In kStopState.
//
// Args:
// src: Pointer to an irparams_t structure to copy from.
// dst: Pointer to an irparams_t structure to copy to.
void IRrecv::copyIrParams(volatile irparams_t *src, irparams_t *dst) {
// Typecast src and dst addresses to (char *)
- char *csrc = (char *) src; // NOLINT(readability/casting)
- char *cdst = (char *) dst; // NOLINT(readability/casting)
+ char *csrc = (char *)src; // NOLINT(readability/casting)
+ char *cdst = (char *)dst; // NOLINT(readability/casting)
// Save the pointer to the destination's rawbuf so we don't lose it as
// the for-loop/copy after this will overwrite it with src's rawbuf pointer.
@@ -181,22 +185,25 @@ void IRrecv::copyIrParams(volatile irparams_t *src, irparams_t *dst) {
dst_rawbuf_ptr = dst->rawbuf;
// Copy contents of src[] to dst[]
- for (uint16_t i = 0; i < sizeof(irparams_t); i++)
- cdst[i] = csrc[i];
+ for (uint16_t i = 0; i < sizeof(irparams_t); i++) cdst[i] = csrc[i];
// Restore the buffer pointer
dst->rawbuf = dst_rawbuf_ptr;
// Copy the rawbuf
- for (uint16_t i = 0; i < dst->bufsize; i++)
- dst->rawbuf[i] = src->rawbuf[i];
+ for (uint16_t i = 0; i < dst->bufsize; i++) dst->rawbuf[i] = src->rawbuf[i];
}
// Obtain the maximum number of entries possible in the capture buffer.
// i.e. It's size.
-uint16_t IRrecv::getBufSize() {
- return irparams.bufsize;
+uint16_t IRrecv::getBufSize() { return irparams.bufsize; }
+
+#if DECODE_HASH
+// Set the minimum length we will consider for reporting UNKNOWN message types.
+void IRrecv::setUnknownThreshold(uint16_t length) {
+ unknown_threshold = length;
}
+#endif // DECODE_HASH
// Decodes the received IR message.
// If the interrupt state is saved, we will immediately resume waiting
@@ -213,8 +220,7 @@ uint16_t IRrecv::getBufSize() {
bool IRrecv::decode(decode_results *results, irparams_t *save) {
// Proceed only if an IR message been received.
#ifndef UNIT_TEST
- if (irparams.rcvstate != STATE_STOP)
- return false;
+ if (irparams.rcvstate != kStopState) return false;
#endif
// Clear the entry we are currently pointing to when we got the timeout.
@@ -230,8 +236,7 @@ bool IRrecv::decode(decode_results *results, irparams_t *save) {
bool resumed = false; // Flag indicating if we have resumed.
// If we were requested to use a save buffer previously, do so.
- if (save == NULL)
- save = irparams_save;
+ if (save == NULL) save = irparams_save;
if (save == NULL) {
// We haven't been asked to copy it so use the existing memory.
@@ -263,8 +268,7 @@ bool IRrecv::decode(decode_results *results, irparams_t *save) {
// Try decodeAiwaRCT501() before decodeSanyoLC7461() & decodeNEC()
// because the protocols are similar. This protocol is more specific than
// those ones, so should got before them.
- if (decodeAiwaRCT501(results))
- return true;
+ if (decodeAiwaRCT501(results)) return true;
#endif
#if DECODE_SANYO
DPRINTLN("Attempting Sanyo LC7461 decode");
@@ -272,97 +276,135 @@ bool IRrecv::decode(decode_results *results, irparams_t *save) {
// similar in timings & structure, but the Sanyo one is much longer than the
// NEC protocol (42 vs 32 bits) so this one should be tried first to try to
// reduce false detection as a NEC packet.
- if (decodeSanyoLC7461(results))
- return true;
+ if (decodeSanyoLC7461(results)) return true;
+#endif
+#if DECODE_CARRIER_AC
+ DPRINTLN("Attempting Carrier AC decode");
+ // Try decodeCarrierAC() before decodeNEC() because the protocols are
+ // similar in timings & structure, but the Carrier one is much longer than the
+ // NEC protocol (3x32 bits vs 1x32 bits) so this one should be tried first to
+ // try to reduce false detection as a NEC packet.
+ if (decodeCarrierAC(results)) return true;
+#endif
+#if DECODE_PIONEER
+ DPRINTLN("Attempting Pioneer decode");
+ // Try decodePioneer() before decodeNEC() because the protocols are
+ // similar in timings & structure, but the Pioneer one is much longer than the
+ // NEC protocol (2x32 bits vs 1x32 bits) so this one should be tried first to
+ // try to reduce false detection as a NEC packet.
+ if (decodePioneer(results)) return true;
#endif
#if DECODE_NEC
DPRINTLN("Attempting NEC decode");
- if (decodeNEC(results))
- return true;
+ if (decodeNEC(results)) return true;
#endif
#if DECODE_SONY
DPRINTLN("Attempting Sony decode");
- if (decodeSony(results))
- return true;
+ if (decodeSony(results)) return true;
#endif
#if DECODE_MITSUBISHI
DPRINTLN("Attempting Mitsubishi decode");
- if (decodeMitsubishi(results))
- return true;
+ if (decodeMitsubishi(results)) return true;
+#endif
+#if DECODE_MITSUBISHI_AC
+ DPRINTLN("Attempting Mitsubishi AC decode");
+ if (decodeMitsubishiAC(results)) return true;
+#endif
+#if DECODE_MITSUBISHI2
+ DPRINTLN("Attempting Mitsubishi2 decode");
+ if (decodeMitsubishi2(results)) return true;
#endif
#if DECODE_RC5
DPRINTLN("Attempting RC5 decode");
- if (decodeRC5(results))
- return true;
+ if (decodeRC5(results)) return true;
#endif
#if DECODE_RC6
DPRINTLN("Attempting RC6 decode");
- if (decodeRC6(results))
- return true;
+ if (decodeRC6(results)) return true;
#endif
#if DECODE_RCMM
DPRINTLN("Attempting RC-MM decode");
- if (decodeRCMM(results))
- return true;
+ if (decodeRCMM(results)) return true;
+#endif
+#if DECODE_FUJITSU_AC
+ // Fujitsu A/C needs to precede Panasonic and Denon as it has a short
+ // message which looks exactly the same as a Panasonic/Denon message.
+ DPRINTLN("Attempting Fujitsu A/C decode");
+ if (decodeFujitsuAC(results)) return true;
#endif
#if DECODE_DENON
// Denon needs to precede Panasonic as it is a special case of Panasonic.
-#ifdef DEBUG
DPRINTLN("Attempting Denon decode");
-#endif
- if (decodeDenon(results, DENON_48_BITS) ||
- decodeDenon(results, DENON_BITS) ||
- decodeDenon(results, DENON_LEGACY_BITS))
+ if (decodeDenon(results, DENON_48_BITS) || decodeDenon(results, DENON_BITS) ||
+ decodeDenon(results, kDenonLegacyBits))
return true;
#endif
#if DECODE_PANASONIC
DPRINTLN("Attempting Panasonic decode");
- if (decodePanasonic(results))
- return true;
+ if (decodePanasonic(results)) return true;
#endif
#if DECODE_LG
DPRINTLN("Attempting LG (28-bit) decode");
- if (decodeLG(results, LG_BITS, true))
- return true;
+ if (decodeLG(results, kLgBits, true)) return true;
DPRINTLN("Attempting LG (32-bit) decode");
// LG32 should be tried before Samsung
- if (decodeLG(results, LG32_BITS, true))
- return true;
+ if (decodeLG(results, kLg32Bits, true)) return true;
+#endif
+#if DECODE_GICABLE
+ // Note: Needs to happen before JVC decode, because it looks similar except
+ // with a required NEC-like repeat code.
+ DPRINTLN("Attempting GICable decode");
+ if (decodeGICable(results)) return true;
#endif
#if DECODE_JVC
DPRINTLN("Attempting JVC decode");
- if (decodeJVC(results))
- return true;
+ if (decodeJVC(results)) return true;
#endif
#if DECODE_SAMSUNG
DPRINTLN("Attempting SAMSUNG decode");
- if (decodeSAMSUNG(results))
- return true;
+ if (decodeSAMSUNG(results)) return true;
#endif
#if DECODE_WHYNTER
DPRINTLN("Attempting Whynter decode");
- if (decodeWhynter(results))
- return true;
+ if (decodeWhynter(results)) return true;
#endif
#if DECODE_DISH
DPRINTLN("Attempting DISH decode");
- if (decodeDISH(results))
- return true;
+ if (decodeDISH(results)) return true;
#endif
#if DECODE_SHARP
DPRINTLN("Attempting Sharp decode");
- if (decodeSharp(results))
- return true;
+ if (decodeSharp(results)) return true;
#endif
#if DECODE_COOLIX
DPRINTLN("Attempting Coolix decode");
- if (decodeCOOLIX(results))
- return true;
+ if (decodeCOOLIX(results)) return true;
#endif
#if DECODE_NIKAI
DPRINTLN("Attempting Nikai decode");
- if (decodeNikai(results))
- return true;
+ if (decodeNikai(results)) return true;
+#endif
+#if DECODE_KELVINATOR
+ // Kelvinator based-devices use a similar code to Gree ones, to avoid false
+ // matches this needs to happen before decodeGree().
+ DPRINTLN("Attempting Kelvinator decode");
+ if (decodeKelvinator(results)) return true;
+#endif
+#if DECODE_DAIKIN
+ DPRINTLN("Attempting Daikin decode");
+ if (decodeDaikin(results)) return true;
+#endif
+#if DECODE_TOSHIBA_AC
+ DPRINTLN("Attempting Toshiba AC decode");
+ if (decodeToshibaAC(results)) return true;
+#endif
+#if DECODE_MIDEA
+ DPRINTLN("Attempting Midea decode");
+ if (decodeMidea(results)) return true;
+#endif
+#if DECODE_MAGIQUEST
+ DPRINTLN("Attempting Magiquest decode");
+ if (decodeMagiQuest(results)) return true;
#endif
/* NOTE: Disabled due to poor quality.
#if DECODE_SANYO
@@ -380,18 +422,81 @@ bool IRrecv::decode(decode_results *results, irparams_t *save) {
// This needs to be done after all other codes that use strict and some
// other protocols that are NEC-like as well, as turning off strict may
// cause this to match other valid protocols.
- DPRINTLN("Attempting NEC (non-stict) decode");
- if (decodeNEC(results, NEC_BITS, false)) {
+ DPRINTLN("Attempting NEC (non-strict) decode");
+ if (decodeNEC(results, kNECBits, false)) {
results->decode_type = NEC_LIKE;
return true;
}
#endif
+#if DECODE_LASERTAG
+ DPRINTLN("Attempting Lasertag decode");
+ if (decodeLasertag(results)) return true;
+#endif
+#if DECODE_GREE
+ // Gree based-devices use a similar code to Kelvinator ones, to avoid false
+ // matches this needs to happen after decodeKelvinator().
+ DPRINTLN("Attempting Gree decode");
+ if (decodeGree(results)) return true;
+#endif
+#if DECODE_HAIER_AC
+ DPRINTLN("Attempting Haier AC decode");
+ if (decodeHaierAC(results)) return true;
+#endif
+#if DECODE_HAIER_AC_YRW02
+ DPRINTLN("Attempting Haier AC YR-W02 decode");
+ if (decodeHaierACYRW02(results)) return true;
+#endif
+#if DECODE_HITACHI_AC2
+ // HitachiAC2 should be checked before HitachiAC
+ DPRINTLN("Attempting Hitachi AC2 decode");
+ if (decodeHitachiAC(results, kHitachiAc2Bits)) return true;
+#endif
+#if DECODE_HITACHI_AC
+ DPRINTLN("Attempting Hitachi AC decode");
+ if (decodeHitachiAC(results, kHitachiAcBits)) return true;
+#endif
+#if DECODE_HITACHI_AC1
+ DPRINTLN("Attempting Hitachi AC1 decode");
+ if (decodeHitachiAC(results, kHitachiAc1Bits)) return true;
+#endif
+#if DECODE_WHIRLPOOL_AC
+ DPRINTLN("Attempting Whirlpool AC decode");
+ if (decodeWhirlpoolAC(results)) return true;
+#endif
+#if DECODE_SAMSUNG_AC
+ DPRINTLN("Attempting Samsung AC (extended) decode");
+ // Check the extended size first, as it should fail fast due to longer length.
+ if (decodeSamsungAC(results, kSamsungAcExtendedBits, false)) return true;
+ // Now check for the more common length.
+ DPRINTLN("Attempting Samsung AC decode");
+ if (decodeSamsungAC(results, kSamsungAcBits)) return true;
+#endif
+#if DECODE_ELECTRA_AC
+ DPRINTLN("Attempting Electra AC decode");
+ if (decodeElectraAC(results)) return true;
+#endif
+#if DECODE_PANASONIC_AC
+ DPRINTLN("Attempting Panasonic AC decode");
+ if (decodePanasonicAC(results)) return true;
+ DPRINTLN("Attempting Panasonic AC short decode");
+ if (decodePanasonicAC(results, kPanasonicAcShortBits)) return true;
+#endif
+#if DECODE_LUTRON
+ DPRINTLN("Attempting Lutron decode");
+ if (decodeLutron(results)) return true;
+#endif
+#if DECODE_MWM
+ DPRINTLN("Attempting MWM decode");
+ if (decodeMWM(results)) return true;
+#endif
+#if DECODE_HASH
// 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 true;
}
+#endif // DECODE_HASH
// Throw away and start over
if (!resumed) // Check if we have already resumed.
resume();
@@ -403,11 +508,13 @@ bool IRrecv::decode(decode_results *results, irparams_t *save) {
// Args:
// usecs: Nr. of uSeconds.
// tolerance: Percent as an integer. e.g. 10 is 10%
+// delta: A non-scaling amount to reduce usecs by.
// Returns:
// Nr. of ticks.
-uint32_t IRrecv::ticksLow(uint32_t usecs, uint8_t tolerance) {
+uint32_t IRrecv::ticksLow(uint32_t usecs, uint8_t tolerance, uint16_t delta) {
// max() used to ensure the result can't drop below 0 before the cast.
- return((uint32_t) std::max((int32_t) (usecs * (1.0 - tolerance / 100.0)), 0));
+ return ((uint32_t)std::max(
+ (int32_t)(usecs * (1.0 - tolerance / 100.0) - delta), 0));
}
// Calculate the upper bound of the nr. of ticks.
@@ -415,49 +522,52 @@ uint32_t IRrecv::ticksLow(uint32_t usecs, uint8_t tolerance) {
// Args:
// usecs: Nr. of uSeconds.
// tolerance: Percent as an integer. e.g. 10 is 10%
+// delta: A non-scaling amount to increase usecs by.
// Returns:
// Nr. of ticks.
-uint32_t IRrecv::ticksHigh(uint32_t usecs, uint8_t tolerance) {
- return((uint32_t) (usecs * (1.0 + tolerance / 100.0)) + 1);
+uint32_t IRrecv::ticksHigh(uint32_t usecs, uint8_t tolerance, uint16_t delta) {
+ return ((uint32_t)(usecs * (1.0 + tolerance / 100.0)) + 1 + delta);
}
// Check if we match a pulse(measured) with the desired within
-// +/-tolerance percent.
+// +/-tolerance percent and/or +/- a fixed delta range.
//
// Args:
// measured: The recorded period of the signal pulse.
// desired: The expected period (in useconds) we are matching against.
// tolerance: A percentage expressed as an integer. e.g. 10 is 10%.
+// delta: A non-scaling (+/-) error margin (in useconds).
//
// Returns:
// Boolean: true if it matches, false if it doesn't.
-bool IRrecv::match(uint32_t measured, uint32_t desired,
- uint8_t tolerance) {
- measured *= RAWTICK; // Convert to uSecs.
+bool IRrecv::match(uint32_t measured, uint32_t desired, uint8_t tolerance,
+ uint16_t delta) {
+ measured *= kRawTick; // Convert to uSecs.
DPRINT("Matching: ");
- DPRINT(ticksLow(desired, tolerance));
+ DPRINT(ticksLow(desired, tolerance, delta));
DPRINT(" <= ");
DPRINT(measured);
DPRINT(" <= ");
- DPRINTLN(ticksHigh(desired, tolerance));
- return (measured >= ticksLow(desired, tolerance) &&
- measured <= ticksHigh(desired, tolerance));
+ DPRINTLN(ticksHigh(desired, tolerance, delta));
+ return (measured >= ticksLow(desired, tolerance, delta) &&
+ measured <= ticksHigh(desired, tolerance, delta));
}
-
// Check if we match a pulse(measured) of at least desired within
-// +/-tolerance percent.
+// tolerance percent and/or a fixed delta margin.
//
// Args:
// measured: The recorded period of the signal pulse.
// desired: The expected period (in useconds) we are matching against.
// tolerance: A percentage expressed as an integer. e.g. 10 is 10%.
+// delta: A non-scaling amount to reduce usecs by.
+
//
// Returns:
// Boolean: true if it matches, false if it doesn't.
bool IRrecv::matchAtLeast(uint32_t measured, uint32_t desired,
- uint8_t tolerance) {
- measured *= RAWTICK; // Convert to uSecs.
+ uint8_t tolerance, uint16_t delta) {
+ measured *= kRawTick; // Convert to uSecs.
DPRINT("Matching ATLEAST ");
DPRINT(measured);
DPRINT(" vs ");
@@ -465,17 +575,18 @@ bool IRrecv::matchAtLeast(uint32_t measured, uint32_t desired,
DPRINT(". Matching: ");
DPRINT(measured);
DPRINT(" >= ");
- DPRINT(ticksLow(std::min(desired, MS_TO_USEC(irparams.timeout)), tolerance));
+ DPRINT(ticksLow(std::min(desired, MS_TO_USEC(irparams.timeout)), tolerance,
+ delta));
DPRINT(" [min(");
- DPRINT(ticksLow(desired, tolerance));
+ DPRINT(ticksLow(desired, tolerance, delta));
DPRINT(", ");
- DPRINT(ticksLow(MS_TO_USEC(irparams.timeout), tolerance));
+ DPRINT(ticksLow(MS_TO_USEC(irparams.timeout), tolerance, delta));
DPRINTLN(")]");
// We really should never get a value of 0, except as the last value
// in the buffer. If that is the case, then assume infinity and return true.
if (measured == 0) return true;
return measured >= ticksLow(std::min(desired, MS_TO_USEC(irparams.timeout)),
- tolerance);
+ tolerance, delta);
}
// Check if we match a mark signal(measured) with the desired within
@@ -489,10 +600,10 @@ bool IRrecv::matchAtLeast(uint32_t measured, uint32_t desired,
//
// Returns:
// Boolean: true if it matches, false if it doesn't.
-bool IRrecv::matchMark(uint32_t measured, uint32_t desired,
- uint8_t tolerance, int16_t excess) {
+bool IRrecv::matchMark(uint32_t measured, uint32_t desired, uint8_t tolerance,
+ int16_t excess) {
DPRINT("Matching MARK ");
- DPRINT(measured * RAWTICK);
+ DPRINT(measured * kRawTick);
DPRINT(" vs ");
DPRINT(desired);
DPRINT(" + ");
@@ -512,10 +623,10 @@ bool IRrecv::matchMark(uint32_t measured, uint32_t desired,
//
// Returns:
// Boolean: true if it matches, false if it doesn't.
-bool IRrecv::matchSpace(uint32_t measured, uint32_t desired,
- uint8_t tolerance, int16_t excess) {
+bool IRrecv::matchSpace(uint32_t measured, uint32_t desired, uint8_t tolerance,
+ int16_t excess) {
DPRINT("Matching SPACE ");
- DPRINT(measured * RAWTICK);
+ DPRINT(measured * kRawTick);
DPRINT(" vs ");
DPRINT(desired);
DPRINT(" - ");
@@ -550,15 +661,15 @@ int16_t IRrecv::compare(uint16_t oldval, uint16_t newval) {
return 1;
}
+#if DECODE_HASH
/* 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.
*/
bool IRrecv::decodeHash(decode_results *results) {
- // Require at least 6 samples to prevent triggering on noise
- if (results->rawlen < 6)
- return false;
- int32_t hash = FNV_BASIS_32;
+ // Require at least some samples to prevent triggering on noise
+ if (results->rawlen < unknown_threshold) return false;
+ int32_t hash = kFnvBasis32;
// 'rawlen - 2' to avoid the look ahead from going out of bounds.
// Should probably be -3 to avoid comparing the trailing space entry,
// however it is left this way for compatibility with previously captured
@@ -566,7 +677,7 @@ bool IRrecv::decodeHash(decode_results *results) {
for (uint16_t i = 1; i < results->rawlen - 2; i++) {
int16_t value = compare(results->rawbuf[i], results->rawbuf[i + 2]);
// Add value into the hash
- hash = (hash * FNV_PRIME_32) ^ value;
+ hash = (hash * kFnvPrime32) ^ value;
}
results->value = hash & 0xFFFFFFFF;
results->bits = results->rawlen / 2;
@@ -575,9 +686,11 @@ bool IRrecv::decodeHash(decode_results *results) {
results->decode_type = UNKNOWN;
return true;
}
+#endif // DECODE_HASH
// Match & decode the typical data section of an IR message.
-// The data value constructed as the Most Significant Bit first.
+// The data value is stored in the least significant bits reguardless of the
+// bit ordering requested.
//
// Args:
// data_ptr: A pointer to where we are at in the capture buffer.
@@ -586,46 +699,35 @@ bool IRrecv::decodeHash(decode_results *results) {
// onespace: Nr. of uSeconds in an expected space signal for a '1' bit.
// zeromark: Nr. of uSeconds in an expected mark signal for a '0' bit.
// zerospace: Nr. of uSeconds in an expected space signal for a '0' bit.
+// tolerance: Percentage error margin to allow. (Def: kTolerance)
+// excess: Nr. of useconds. (Def: kMarkExcess)
+// MSBfirst: Bit order to save the data in. (Def: true)
// Returns:
// A match_result_t structure containing the success (or not), the data value,
// and how many buffer entries were used.
-match_result_t IRrecv::matchData(volatile uint16_t *data_ptr, uint16_t nbits,
- uint16_t onemark, uint32_t onespace,
- uint16_t zeromark, uint32_t zerospace) {
+match_result_t IRrecv::matchData(
+ volatile uint16_t *data_ptr, const uint16_t nbits, const uint16_t onemark,
+ const uint32_t onespace, const uint16_t zeromark, const uint32_t zerospace,
+ const uint8_t tolerance, const int16_t excess, const bool MSBfirst) {
match_result_t result;
- result.success = false;
+ result.success = false; // Fail by default.
result.data = 0;
- if (onemark == zeromark) { // Is this space encoded data format?
- for (result.used = 0;
- result.used < nbits * 2;
- result.used += 2, data_ptr++) {
- if (!matchMark(*data_ptr, onemark))
- return result; // Fail
- data_ptr++;
- if (matchSpace(*data_ptr, onespace))
- result.data = (result.data << 1) | 1;
- else if (matchSpace(*data_ptr, zerospace))
- result.data <<= 1;
- else
- return result; // Fail
- }
- result.success = true;
- } else if (onespace == zerospace) { // Is this mark encoded data format?
- for (result.used = 0;
- result.used < nbits * 2;
- result.used += 2, data_ptr++) {
- if (matchMark(*data_ptr, onemark))
- result.data = (result.data << 1) | 1;
- else if (matchMark(*data_ptr, zeromark))
- result.data <<= 1;
- else
- return result; // Fail
- data_ptr++;
- if (!matchSpace(*data_ptr, onespace))
- return result; // Fail
+ for (result.used = 0; result.used < nbits * 2;
+ result.used += 2, data_ptr += 2) {
+ // Is the bit a '1'?
+ if (matchMark(*data_ptr, onemark, tolerance, excess) &&
+ matchSpace(*(data_ptr + 1), onespace, tolerance, excess)) {
+ result.data = (result.data << 1) | 1;
+ } else if (matchMark(*data_ptr, zeromark, tolerance, excess) &&
+ matchSpace(*(data_ptr + 1), zerospace, tolerance, excess)) {
+ result.data <<= 1; // The bit is a '0'.
+ } else {
+ if (!MSBfirst) result.data = reverseBits(result.data, result.used / 2);
+ return result; // It's neither, so fail.
}
- result.success = true;
}
+ result.success = true;
+ if (!MSBfirst) result.data = reverseBits(result.data, nbits);
return result;
}
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/IRrecv.h b/lib/IRremoteESP8266-2.5.2.03/src/IRrecv.h
new file mode 100644
index 000000000000..c0f5e781aa90
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/IRrecv.h
@@ -0,0 +1,335 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2015 Mark Szabo
+// Copyright 2015 Sebastien Warin
+// Copyright 2017 David Conran
+
+#ifndef IRRECV_H_
+#define IRRECV_H_
+
+#ifndef UNIT_TEST
+#include
+#endif
+#include
+#define __STDC_LIMIT_MACROS
+#include
+#include "IRremoteESP8266.h"
+
+// Constants
+const uint16_t kHeader = 2; // Usual nr. of header entries.
+const uint16_t kFooter = 2; // Usual nr. of footer (stop bits) entries.
+const uint16_t kStartOffset = 1; // Usual rawbuf entry to start from.
+#define MS_TO_USEC(x) (x * 1000U) // Convert milli-Seconds to micro-Seconds.
+// Marks tend to be 100us too long, and spaces 100us too short
+// when received due to sensor lag.
+const uint16_t kMarkExcess = 50;
+const uint16_t kRawBuf = 100; // Default length of raw capture buffer
+const uint64_t kRepeat = UINT64_MAX;
+// Default min size of reported UNKNOWN messages.
+const uint16_t kUnknownThreshold = 6;
+
+// receiver states
+const uint8_t kIdleState = 2;
+const uint8_t kMarkState = 3;
+const uint8_t kSpaceState = 4;
+const uint8_t kStopState = 5;
+const uint8_t kTolerance = 25; // default percent tolerance in measurements.
+const uint16_t kRawTick = 2; // Capture tick to uSec factor.
+#define RAWTICK kRawTick // Deprecated. For legacy user code support only.
+// How long (ms) before we give up wait for more data?
+// Don't exceed kMaxTimeoutMs without a good reason.
+// That is the capture buffers maximum value size. (UINT16_MAX / kRawTick)
+// Typically messages/protocols tend to repeat around the 100ms timeframe,
+// thus we should timeout before that to give us some time to try to decode
+// before we need to start capturing a possible new message.
+// Typically 15ms suits most applications. However, some protocols demand a
+// higher value. e.g. 90ms for XMP-1 and some aircon units.
+const uint8_t kTimeoutMs = 15; // In MilliSeconds.
+#define TIMEOUT_MS kTimeoutMs // For legacy documentation.
+const uint16_t kMaxTimeoutMs = kRawTick * (UINT16_MAX / MS_TO_USEC(1));
+
+// Use FNV hash algorithm: http://isthe.com/chongo/tech/comp/fnv/#FNV-param
+const uint32_t kFnvPrime32 = 16777619UL;
+const uint32_t kFnvBasis32 = 2166136261UL;
+
+#if DECODE_AC
+// Hitachi AC is the current largest state size.
+const uint16_t kStateSizeMax = kHitachiAc2StateLength;
+#else
+// Just define something
+const uint16_t kStateSizeMax = 0;
+#endif
+
+// Types
+// information for the interrupt handler
+typedef struct {
+ uint8_t recvpin; // pin for IR data from detector
+ uint8_t rcvstate; // state machine
+ uint16_t timer; // state timer, counts 50uS ticks.
+ uint16_t bufsize; // max. nr. of entries in the capture buffer.
+ uint16_t *rawbuf; // raw data
+ // uint16_t is used for rawlen as it saves 3 bytes of iram in the interrupt
+ // handler. Don't ask why, I don't know. It just does.
+ uint16_t rawlen; // counter of entries in rawbuf.
+ uint8_t overflow; // Buffer overflow indicator.
+ uint8_t timeout; // Nr. of milliSeconds before we give up.
+} irparams_t;
+
+// results from a data match
+typedef struct {
+ bool success; // Was the match successful?
+ uint64_t data; // The data found.
+ uint16_t used; // How many buffer positions were used.
+} match_result_t;
+
+// Classes
+
+// Results returned from the decoder
+class decode_results {
+ public:
+ decode_type_t decode_type; // NEC, SONY, RC5, UNKNOWN
+ // value, address, & command are all mutually exclusive with state.
+ // i.e. They MUST NOT be used at the same time as state, so we can use a union
+ // structure to save us a handful of valuable bytes of memory.
+ union {
+ struct {
+ uint64_t value; // Decoded value
+ uint32_t address; // Decoded device address.
+ uint32_t command; // Decoded command.
+ };
+ uint8_t state[kStateSizeMax]; // Multi-byte results.
+ };
+ uint16_t bits; // Number of bits in decoded value
+ volatile uint16_t *rawbuf; // Raw intervals in .5 us ticks
+ uint16_t rawlen; // Number of records in rawbuf.
+ bool overflow;
+ bool repeat; // Is the result a repeat code?
+};
+
+// main class for receiving IR
+class IRrecv {
+ public:
+ explicit IRrecv(uint16_t recvpin, uint16_t bufsize = kRawBuf,
+ uint8_t timeout = kTimeoutMs,
+ bool save_buffer = false); // Constructor
+ ~IRrecv(); // Destructor
+ bool decode(decode_results *results, irparams_t *save = NULL);
+ void enableIRIn();
+ void disableIRIn();
+ void resume();
+ uint16_t getBufSize();
+#if DECODE_HASH
+ void setUnknownThreshold(uint16_t length);
+#endif
+ static bool match(uint32_t measured, uint32_t desired,
+ uint8_t tolerance = kTolerance, uint16_t delta = 0);
+ static bool matchMark(uint32_t measured, uint32_t desired,
+ uint8_t tolerance = kTolerance,
+ int16_t excess = kMarkExcess);
+ static bool matchSpace(uint32_t measured, uint32_t desired,
+ uint8_t tolerance = kTolerance,
+ int16_t excess = kMarkExcess);
+#ifndef UNIT_TEST
+
+ private:
+#endif
+ irparams_t *irparams_save;
+#if DECODE_HASH
+ uint16_t unknown_threshold;
+#endif
+ // These are called by decode
+ void copyIrParams(volatile irparams_t *src, irparams_t *dst);
+ int16_t compare(uint16_t oldval, uint16_t newval);
+ static uint32_t ticksLow(uint32_t usecs, uint8_t tolerance = kTolerance,
+ uint16_t delta = 0);
+ static uint32_t ticksHigh(uint32_t usecs, uint8_t tolerance = kTolerance,
+ uint16_t delta = 0);
+ bool matchAtLeast(uint32_t measured, uint32_t desired,
+ uint8_t tolerance = kTolerance, uint16_t delta = 0);
+ match_result_t matchData(volatile uint16_t *data_ptr, const uint16_t nbits,
+ const uint16_t onemark, const uint32_t onespace,
+ const uint16_t zeromark, const uint32_t zerospace,
+ const uint8_t tolerance = kTolerance,
+ const int16_t excess = kMarkExcess,
+ const bool MSBfirst = true);
+ bool decodeHash(decode_results *results);
+#if (DECODE_NEC || DECODE_SHERWOOD || DECODE_AIWA_RC_T501 || SEND_SANYO)
+ bool decodeNEC(decode_results *results, uint16_t nbits = kNECBits,
+ bool strict = true);
+#endif
+#if DECODE_SONY
+ bool decodeSony(decode_results *results, uint16_t nbits = kSonyMinBits,
+ bool strict = false);
+#endif
+#if DECODE_SANYO
+ // DISABLED due to poor quality.
+ // bool decodeSanyo(decode_results *results,
+ // uint16_t nbits = kSanyoSA8650BBits,
+ // bool strict = false);
+ bool decodeSanyoLC7461(decode_results *results,
+ uint16_t nbits = kSanyoLC7461Bits, bool strict = true);
+#endif
+#if DECODE_MITSUBISHI
+ bool decodeMitsubishi(decode_results *results,
+ uint16_t nbits = kMitsubishiBits, bool strict = true);
+#endif
+#if DECODE_MITSUBISHI2
+ bool decodeMitsubishi2(decode_results *results,
+ uint16_t nbits = kMitsubishiBits, bool strict = true);
+#endif
+#if DECODE_MITSUBISHI_AC
+ bool decodeMitsubishiAC(decode_results *results,
+ uint16_t nbits = kMitsubishiACBits,
+ bool strict = false);
+#endif
+#if (DECODE_RC5 || DECODE_R6 || DECODE_LASERTAG || DECODE_MWM)
+ int16_t getRClevel(decode_results *results, uint16_t *offset, uint16_t *used,
+ uint16_t bitTime, uint8_t tolerance = kTolerance,
+ int16_t excess = kMarkExcess, uint16_t delta = 0,
+ uint8_t maxwidth = 3);
+#endif
+#if DECODE_RC5
+ bool decodeRC5(decode_results *results, uint16_t nbits = kRC5XBits,
+ bool strict = true);
+#endif
+#if DECODE_RC6
+ bool decodeRC6(decode_results *results, uint16_t nbits = kRC6Mode0Bits,
+ bool strict = false);
+#endif
+#if DECODE_RCMM
+ bool decodeRCMM(decode_results *results, uint16_t nbits = kRCMMBits,
+ bool strict = false);
+#endif
+#if (DECODE_PANASONIC || DECODE_DENON)
+ bool decodePanasonic(decode_results *results, uint16_t nbits = kPanasonicBits,
+ bool strict = false,
+ uint32_t manufacturer = kPanasonicManufacturer);
+#endif
+#if DECODE_LG
+ bool decodeLG(decode_results *results, uint16_t nbits = kLgBits,
+ bool strict = false);
+#endif
+#if DECODE_JVC
+ bool decodeJVC(decode_results *results, uint16_t nbits = kJvcBits,
+ bool strict = true);
+#endif
+#if DECODE_SAMSUNG
+ bool decodeSAMSUNG(decode_results *results, uint16_t nbits = kSamsungBits,
+ bool strict = true);
+#endif
+#if DECODE_SAMSUNG_AC
+ bool decodeSamsungAC(decode_results *results, uint16_t nbits = kSamsungAcBits,
+ bool strict = true);
+#endif
+#if DECODE_WHYNTER
+ bool decodeWhynter(decode_results *results, uint16_t nbits = kWhynterBits,
+ bool strict = true);
+#endif
+#if DECODE_COOLIX
+ bool decodeCOOLIX(decode_results *results, uint16_t nbits = kCoolixBits,
+ bool strict = true);
+#endif
+#if DECODE_DENON
+ bool decodeDenon(decode_results *results, uint16_t nbits = DENON_BITS,
+ bool strict = true);
+#endif
+#if DECODE_DISH
+ bool decodeDISH(decode_results *results, uint16_t nbits = kDishBits,
+ bool strict = true);
+#endif
+#if (DECODE_SHARP || DECODE_DENON)
+ bool decodeSharp(decode_results *results, uint16_t nbits = kSharpBits,
+ bool strict = true, bool expansion = true);
+#endif
+#if DECODE_AIWA_RC_T501
+ bool decodeAiwaRCT501(decode_results *results,
+ uint16_t nbits = kAiwaRcT501Bits, bool strict = true);
+#endif
+#if DECODE_NIKAI
+ bool decodeNikai(decode_results *results, uint16_t nbits = kNikaiBits,
+ bool strict = true);
+#endif
+#if DECODE_MAGIQUEST
+ bool decodeMagiQuest(decode_results *results, uint16_t nbits = kMagiquestBits,
+ bool strict = true);
+#endif
+#if DECODE_KELVINATOR
+ bool decodeKelvinator(decode_results *results,
+ uint16_t nbits = kKelvinatorBits, bool strict = true);
+#endif
+#if DECODE_DAIKIN
+ bool decodeDaikin(decode_results *results, uint16_t nbits = kDaikinRawBits,
+ bool strict = true);
+#endif
+#if DECODE_TOSHIBA_AC
+ bool decodeToshibaAC(decode_results *results,
+ uint16_t nbytes = kToshibaACBits, bool strict = true);
+#endif
+#if DECODE_MIDEA
+ bool decodeMidea(decode_results *results, uint16_t nbits = kMideaBits,
+ bool strict = true);
+#endif
+#if DECODE_FUJITSU_AC
+ bool decodeFujitsuAC(decode_results *results, uint16_t nbits = kFujitsuAcBits,
+ bool strict = false);
+#endif
+#if DECODE_LASERTAG
+ bool decodeLasertag(decode_results *results, uint16_t nbits = kLasertagBits,
+ bool strict = true);
+#endif
+#if DECODE_CARRIER_AC
+ bool decodeCarrierAC(decode_results *results, uint16_t nbits = kCarrierAcBits,
+ bool strict = true);
+#endif
+#if DECODE_GREE
+ bool decodeGree(decode_results *results, uint16_t nbits = kGreeBits,
+ bool strict = true);
+#endif
+#if (DECODE_HAIER_AC | DECODE_HAIER_AC_YRW02)
+ bool decodeHaierAC(decode_results *results, uint16_t nbits = kHaierACBits,
+ bool strict = true);
+#endif
+#if DECODE_HAIER_AC_YRW02
+ bool decodeHaierACYRW02(decode_results *results,
+ uint16_t nbits = kHaierACYRW02Bits,
+ bool strict = true);
+#endif
+#if (DECODE_HITACHI_AC || DECODE_HITACHI_AC2)
+ bool decodeHitachiAC(decode_results *results, uint16_t nbits = kHitachiAcBits,
+ bool strict = true);
+#endif
+#if DECODE_HITACHI_AC1
+ bool decodeHitachiAC1(decode_results *results,
+ uint16_t nbits = kHitachiAc1Bits, bool strict = true);
+#endif
+#if DECODE_GICABLE
+ bool decodeGICable(decode_results *results, uint16_t nbits = kGicableBits,
+ bool strict = true);
+#endif
+#if DECODE_WHIRLPOOL_AC
+ bool decodeWhirlpoolAC(decode_results *results,
+ uint16_t nbits = kWhirlpoolAcBits, bool strict = true);
+#endif
+#if DECODE_LUTRON
+ bool decodeLutron(decode_results *results, uint16_t nbits = kLutronBits,
+ bool strict = true);
+#endif
+#if DECODE_ELECTRA_AC
+ bool decodeElectraAC(decode_results *results, uint16_t nbits = kElectraAcBits,
+ bool strict = true);
+#endif
+#if DECODE_PANASONIC_AC
+ bool decodePanasonicAC(decode_results *results,
+ uint16_t nbits = kPanasonicAcBits, bool strict = true);
+#endif
+#if DECODE_PIONEER
+ bool decodePioneer(decode_results *results,
+ const uint16_t nbits = kPioneerBits,
+ const bool strict = true);
+#endif
+#if DECODE_MWM
+ bool decodeMWM(decode_results *results, uint16_t nbits = 24,
+ bool strict = true);
+#endif
+};
+
+#endif // IRRECV_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/IRremoteESP8266.h b/lib/IRremoteESP8266-2.5.2.03/src/IRremoteESP8266.h
new file mode 100644
index 000000000000..e228cbcb0a4f
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/IRremoteESP8266.h
@@ -0,0 +1,601 @@
+ /***************************************************
+ * 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
+ *
+ * Edited by Mitra to add new controller SANYO
+ *
+ * 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
+ * Coolix A/C / heatpump added by (send) bakrus & (decode) crankyoldgit
+ * Denon: sendDenon, decodeDenon added by Massimiliano Pinto
+ (from https://github.com/z3t0/Arduino-IRremote/blob/master/ir_Denon.cpp)
+ * Kelvinator A/C and Sherwood added by crankyoldgit
+ * Mitsubishi (TV) sending added by crankyoldgit
+ * Pronto code sending added by crankyoldgit
+ * Mitsubishi & Toshiba A/C added by crankyoldgit
+ * (derived from https://github.com/r45635/HVAC-IR-Control)
+ * DISH decode by marcosamarinho
+ * Gree Heatpump sending added by Ville Skyttä (scop)
+ * (derived from https://github.com/ToniA/arduino-heatpumpir/blob/master/GreeHeatpumpIR.cpp)
+ * 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
+ *
+ * Updated by sillyfrog for Daikin, adopted from
+ * (https://github.com/mharizanov/Daikin-AC-remote-control-over-the-Internet/)
+ * Fujitsu A/C code added by jonnygraham
+ * Trotec AC code by stufisher
+ * Carrier & Haier AC code by crankyoldgit
+ *
+ * GPL license, all text above must be included in any redistribution
+ ****************************************************/
+
+#ifndef IRREMOTEESP8266_H_
+#define IRREMOTEESP8266_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifdef UNIT_TEST
+#include
+#endif
+
+// Library Version
+#define _IRREMOTEESP8266_VERSION_ "2.5.2"
+// Supported IR protocols
+// Each protocol you include costs memory and, during decode, costs time
+// Disable (set to false) all the protocols you do not need/want!
+// The Air Conditioner protocols are the most expensive memory-wise.
+//
+/*
+#define DECODE_HASH true // Semi-unique code for unknown messages
+
+#define SEND_RAW true
+
+#define DECODE_NEC true
+#define SEND_NEC true
+
+#define DECODE_SHERWOOD true // Doesn't exist. Actually is DECODE_NEC
+#define SEND_SHERWOOD true
+
+#define DECODE_RC5 true
+#define SEND_RC5 true
+
+#define DECODE_RC6 true
+#define SEND_RC6 true
+
+#define DECODE_RCMM true
+#define SEND_RCMM true
+
+#define DECODE_SONY true
+#define SEND_SONY true
+
+#define DECODE_PANASONIC true
+#define SEND_PANASONIC true
+
+#define DECODE_JVC true
+#define SEND_JVC true
+
+#define DECODE_SAMSUNG true
+#define SEND_SAMSUNG true
+
+#define DECODE_SAMSUNG_AC true
+#define SEND_SAMSUNG_AC true
+
+#define DECODE_WHYNTER true
+#define SEND_WHYNTER true
+
+#define DECODE_AIWA_RC_T501 true
+#define SEND_AIWA_RC_T501 true
+
+#define DECODE_LG true
+#define SEND_LG true
+
+#define DECODE_SANYO true
+#define SEND_SANYO true
+
+#define DECODE_MITSUBISHI true
+#define SEND_MITSUBISHI true
+
+#define DECODE_MITSUBISHI2 true
+#define SEND_MITSUBISHI2 true
+
+#define DECODE_DISH true
+#define SEND_DISH true
+
+#define DECODE_SHARP true
+#define SEND_SHARP true
+
+#define DECODE_DENON true
+#define SEND_DENON true
+
+#define DECODE_KELVINATOR true
+#define SEND_KELVINATOR true
+
+#define DECODE_MITSUBISHI_AC true // Beta.
+#define SEND_MITSUBISHI_AC true
+
+#define DECODE_FUJITSU_AC true
+#define SEND_FUJITSU_AC true
+
+#define DECODE_DAIKIN true
+#define SEND_DAIKIN true
+
+#define DECODE_COOLIX true
+#define SEND_COOLIX true
+
+#define DECODE_GLOBALCACHE false // Not written.
+#define SEND_GLOBALCACHE true
+
+#define DECODE_GREE true
+#define SEND_GREE true
+
+#define DECODE_PRONTO false // Not written.
+#define SEND_PRONTO true
+
+#define DECODE_ARGO false // Not written.
+#define SEND_ARGO true
+
+#define DECODE_TROTEC false // Not implemented.
+#define SEND_TROTEC true
+
+#define DECODE_NIKAI true
+#define SEND_NIKAI true
+
+#define DECODE_TOSHIBA_AC true
+#define SEND_TOSHIBA_AC true
+
+#define DECODE_MAGIQUEST true
+#define SEND_MAGIQUEST true
+
+#define DECODE_MIDEA true
+#define SEND_MIDEA true
+
+#define DECODE_LASERTAG true
+#define SEND_LASERTAG true
+
+#define DECODE_CARRIER_AC true
+#define SEND_CARRIER_AC true
+
+#define DECODE_HAIER_AC true
+#define SEND_HAIER_AC true
+
+#define DECODE_HITACHI_AC true
+#define SEND_HITACHI_AC true
+
+#define DECODE_HITACHI_AC1 true
+#define SEND_HITACHI_AC1 true
+
+#define DECODE_HITACHI_AC2 true
+#define SEND_HITACHI_AC2 true
+
+#define DECODE_GICABLE true
+#define SEND_GICABLE true
+
+#define DECODE_HAIER_AC_YRW02 true
+#define SEND_HAIER_AC_YRW02 true
+
+#define DECODE_WHIRLPOOL_AC true
+#define SEND_WHIRLPOOL_AC true
+
+#define DECODE_LUTRON true
+#define SEND_LUTRON true
+
+#define DECODE_ELECTRA_AC true
+#define SEND_ELECTRA_AC true
+
+#define DECODE_PANASONIC_AC true
+#define SEND_PANASONIC_AC true
+
+#define DECODE_MWM true
+#define SEND_MWM true
+
+#define DECODE_PIONEER true
+#define SEND_PIONEER true
+*/
+
+// Tasmota supported protocols (less protocols is less code size)
+#define DECODE_HASH true // Semi-unique code for unknown messages
+
+#define SEND_RAW true
+
+#define DECODE_NEC true
+#define SEND_NEC true
+
+#define DECODE_SHERWOOD false // Doesn't exist. Actually is DECODE_NEC
+#define SEND_SHERWOOD false
+
+#define DECODE_RC5 true
+#define SEND_RC5 true
+
+#define DECODE_RC6 true
+#define SEND_RC6 true
+
+#define DECODE_RCMM false
+#define SEND_RCMM false
+
+#define DECODE_SONY true
+#define SEND_SONY true
+
+#define DECODE_PANASONIC true
+#define SEND_PANASONIC true
+
+#define DECODE_JVC true
+#define SEND_JVC true
+
+#define DECODE_SAMSUNG true
+#define SEND_SAMSUNG true
+
+#define DECODE_SAMSUNG_AC false
+#define SEND_SAMSUNG_AC false
+
+#define DECODE_WHYNTER false
+#define SEND_WHYNTER false
+
+#define DECODE_AIWA_RC_T501 false
+#define SEND_AIWA_RC_T501 false
+
+#define DECODE_LG true
+#define SEND_LG true
+
+#define DECODE_SANYO false
+#define SEND_SANYO false
+
+#define DECODE_MITSUBISHI false
+#define SEND_MITSUBISHI false
+
+#define DECODE_MITSUBISHI2 false
+#define SEND_MITSUBISHI2 false
+
+#define DECODE_DISH false
+#define SEND_DISH true
+
+#define DECODE_SHARP false
+#define SEND_SHARP false
+
+#define DECODE_DENON false
+#define SEND_DENON false
+
+#define DECODE_KELVINATOR false
+#define SEND_KELVINATOR false
+
+#define DECODE_MITSUBISHI_AC false // Beta.
+#define SEND_MITSUBISHI_AC true
+
+#define DECODE_FUJITSU_AC false
+#define SEND_FUJITSU_AC true
+
+#define DECODE_DAIKIN false
+#define SEND_DAIKIN false
+
+#define DECODE_COOLIX false
+#define SEND_COOLIX false
+
+#define DECODE_GLOBALCACHE false // Not written.
+#define SEND_GLOBALCACHE false
+
+#define DECODE_GREE false
+#define SEND_GREE false
+
+#define DECODE_PRONTO false // Not written.
+#define SEND_PRONTO false
+
+#define DECODE_ARGO false // Not written.
+#define SEND_ARGO false
+
+#define DECODE_TROTEC false // Not implemented.
+#define SEND_TROTEC false
+
+#define DECODE_NIKAI false
+#define SEND_NIKAI false
+
+#define DECODE_TOSHIBA_AC false
+#define SEND_TOSHIBA_AC false
+
+#define DECODE_MAGIQUEST false
+#define SEND_MAGIQUEST false
+
+#define DECODE_MIDEA false
+#define SEND_MIDEA false
+
+#define DECODE_LASERTAG false
+#define SEND_LASERTAG false
+
+#define DECODE_CARRIER_AC false
+#define SEND_CARRIER_AC false
+
+#define DECODE_HAIER_AC false
+#define SEND_HAIER_AC false
+
+#define DECODE_HITACHI_AC false
+#define SEND_HITACHI_AC false
+
+#define DECODE_HITACHI_AC1 false
+#define SEND_HITACHI_AC1 false
+
+#define DECODE_HITACHI_AC2 false
+#define SEND_HITACHI_AC2 false
+
+#define DECODE_GICABLE false
+#define SEND_GICABLE false
+
+#define DECODE_HAIER_AC_YRW02 false
+#define SEND_HAIER_AC_YRW02 false
+
+#define DECODE_WHIRLPOOL_AC false
+#define SEND_WHIRLPOOL_AC false
+
+#define DECODE_LUTRON false
+#define SEND_LUTRON false
+
+#define DECODE_ELECTRA_AC false
+#define SEND_ELECTRA_AC false
+
+#define DECODE_PANASONIC_AC false
+#define SEND_PANASONIC_AC false
+
+#define DECODE_MWM false
+#define SEND_MWM false
+
+#define DECODE_PIONEER false
+#define SEND_PIONEER false
+
+#if (DECODE_ARGO || DECODE_DAIKIN || DECODE_FUJITSU_AC || DECODE_GREE || \
+ DECODE_KELVINATOR || DECODE_MITSUBISHI_AC || DECODE_TOSHIBA_AC || \
+ DECODE_TROTEC || DECODE_HAIER_AC || DECODE_HITACHI_AC || \
+ DECODE_HITACHI_AC1 || DECODE_HITACHI_AC2 || DECODE_HAIER_AC_YRW02 || \
+ DECODE_WHIRLPOOL_AC || DECODE_SAMSUNG_AC || DECODE_ELECTRA_AC || \
+ DECODE_PANASONIC_AC || DECODE_MWM)
+#define DECODE_AC true // We need some common infrastructure for decoding A/Cs.
+#else
+#define DECODE_AC false // We don't need that infrastructure.
+#endif
+
+// Use millisecond 'delay()' calls where we can to avoid tripping the WDT.
+// Note: If you plan to send IR messages in the callbacks of the AsyncWebserver
+// library, you need to set ALLOW_DELAY_CALLS to false.
+// Ref: https://github.com/markszabo/IRremoteESP8266/issues/430
+#define ALLOW_DELAY_CALLS true
+
+/*
+ * Always add to the end of the list and should never remove entries
+ * or change order. Projects may save the type number for later usage
+ * so numbering should always stay the same.
+ */
+enum decode_type_t {
+ UNKNOWN = -1,
+ UNUSED = 0,
+ RC5,
+ RC6,
+ NEC,
+ SONY,
+ PANASONIC,
+ JVC,
+ SAMSUNG,
+ WHYNTER,
+ AIWA_RC_T501,
+ LG,
+ SANYO,
+ MITSUBISHI,
+ DISH,
+ SHARP,
+ COOLIX,
+ DAIKIN,
+ DENON,
+ KELVINATOR,
+ SHERWOOD,
+ MITSUBISHI_AC,
+ RCMM,
+ SANYO_LC7461,
+ RC5X,
+ GREE,
+ PRONTO, // Technically not a protocol, but an encoding.
+ NEC_LIKE,
+ ARGO,
+ TROTEC,
+ NIKAI,
+ RAW, // Technically not a protocol, but an encoding.
+ GLOBALCACHE, // Technically not a protocol, but an encoding.
+ TOSHIBA_AC,
+ FUJITSU_AC,
+ MIDEA,
+ MAGIQUEST,
+ LASERTAG,
+ CARRIER_AC,
+ HAIER_AC,
+ MITSUBISHI2,
+ HITACHI_AC,
+ HITACHI_AC1,
+ HITACHI_AC2,
+ GICABLE,
+ HAIER_AC_YRW02,
+ WHIRLPOOL_AC,
+ SAMSUNG_AC,
+ LUTRON,
+ ELECTRA_AC,
+ PANASONIC_AC,
+ PIONEER,
+ LG2,
+ MWM,
+};
+
+// Message lengths & required repeat values
+const uint16_t kNoRepeat = 0;
+const uint16_t kSingleRepeat = 1;
+
+const uint16_t kAiwaRcT501Bits = 15;
+const uint16_t kAiwaRcT501MinRepeats = kSingleRepeat;
+const uint16_t kArgoStateLength = 12;
+const uint16_t kCoolixBits = 24;
+const uint16_t kCarrierAcBits = 32;
+const uint16_t kCarrierAcMinRepeat = kNoRepeat;
+// Daikin has a lot of static stuff that is discarded
+const uint16_t kDaikinRawBits = 583;
+const uint16_t kDaikinStateLength = 27;
+const uint16_t kDaikinBits = kDaikinStateLength * 8;
+const uint16_t kDenonBits = 15;
+const uint16_t kDenonLegacyBits = 14;
+const uint16_t kDishBits = 16;
+const uint16_t kDishMinRepeat = 3;
+const uint16_t kElectraAcStateLength = 13;
+const uint16_t kElectraAcBits = kElectraAcStateLength * 8;
+const uint16_t kFujitsuAcMinRepeat = kNoRepeat;
+const uint16_t kFujitsuAcStateLength = 16;
+const uint16_t kFujitsuAcStateLengthShort = 7;
+const uint16_t kFujitsuAcBits = kFujitsuAcStateLength * 8;
+const uint16_t kFujitsuAcMinBits = (kFujitsuAcStateLengthShort - 1) * 8;
+const uint16_t kGicableBits = 16;
+const uint16_t kGicableMinRepeat = kSingleRepeat;
+const uint16_t kGreeStateLength = 8;
+const uint16_t kGreeBits = kGreeStateLength * 8;
+const uint16_t kHaierACStateLength = 9;
+const uint16_t kHaierACBits = kHaierACStateLength * 8;
+const uint16_t kHaierACYRW02StateLength = 14;
+const uint16_t kHaierACYRW02Bits = kHaierACYRW02StateLength * 8;
+const uint16_t kHitachiAcStateLength = 28;
+const uint16_t kHitachiAcBits = kHitachiAcStateLength * 8;
+const uint16_t kHitachiAc1StateLength = 13;
+const uint16_t kHitachiAc1Bits = kHitachiAc1StateLength * 8;
+const uint16_t kHitachiAc2StateLength = 53;
+const uint16_t kHitachiAc2Bits = kHitachiAc2StateLength * 8;
+const uint16_t kJvcBits = 16;
+const uint16_t kKelvinatorStateLength = 16;
+const uint16_t kKelvinatorBits = kKelvinatorStateLength * 8;
+const uint16_t kLasertagBits = 13;
+const uint16_t kLasertagMinRepeat = kNoRepeat;
+const uint16_t kLgBits = 28;
+const uint16_t kLg32Bits = 32;
+const uint16_t kLutronBits = 35;
+const uint16_t kMagiquestBits = 56;
+const uint16_t kMideaBits = 48;
+const uint16_t kMideaMinRepeat = kNoRepeat;
+const uint16_t kMitsubishiBits = 16;
+// TODO(anyone): Verify that the Mitsubishi repeat is really needed.
+// Based on marcosamarinho's code.
+const uint16_t kMitsubishiMinRepeat = kSingleRepeat;
+const uint16_t kMitsubishiACStateLength = 18;
+const uint16_t kMitsubishiACBits = kMitsubishiACStateLength * 8;
+const uint16_t kMitsubishiACMinRepeat = kSingleRepeat;
+const uint16_t kNikaiBits = 24;
+const uint16_t kNECBits = 32;
+const uint16_t kPanasonicBits = 48;
+const uint32_t kPanasonicManufacturer = 0x4004;
+const uint16_t kPanasonicAcStateLength = 27;
+const uint16_t kPanasonicAcStateShortLength = 16;
+const uint16_t kPanasonicAcBits = kPanasonicAcStateLength * 8;
+const uint16_t kPanasonicAcShortBits = kPanasonicAcStateShortLength * 8;
+const uint16_t kPioneerBits = 64;
+const uint16_t kProntoMinLength = 6;
+const uint16_t kRC5RawBits = 14;
+const uint16_t kRC5Bits = kRC5RawBits - 2;
+const uint16_t kRC5XBits = kRC5RawBits - 1;
+const uint16_t kRC6Mode0Bits = 20; // Excludes the 'start' bit.
+const uint16_t kRC6_36Bits = 36; // Excludes the 'start' bit.
+const uint16_t kRCMMBits = 24;
+const uint16_t kSamsungBits = 32;
+const uint16_t kSamsungAcStateLength = 14;
+const uint16_t kSamsungAcBits = kSamsungAcStateLength * 8;
+const uint16_t kSamsungAcExtendedStateLength = 21;
+const uint16_t kSamsungAcExtendedBits = kSamsungAcExtendedStateLength * 8;
+const uint16_t kSanyoSA8650BBits = 12;
+const uint16_t kSanyoLC7461AddressBits = 13;
+const uint16_t kSanyoLC7461CommandBits = 8;
+const uint16_t kSanyoLC7461Bits = (kSanyoLC7461AddressBits +
+ kSanyoLC7461CommandBits) * 2;
+const uint8_t kSharpAddressBits = 5;
+const uint8_t kSharpCommandBits = 8;
+const uint16_t kSharpBits = kSharpAddressBits + kSharpCommandBits + 2; // 15
+const uint8_t kSherwoodBits = kNECBits;
+const uint16_t kSherwoodMinRepeat = kSingleRepeat;
+const uint16_t kSony12Bits = 12;
+const uint16_t kSony15Bits = 15;
+const uint16_t kSony20Bits = 20;
+const uint16_t kSonyMinBits = 12;
+const uint16_t kSonyMinRepeat = 2;
+const uint16_t kToshibaACStateLength = 9;
+const uint16_t kToshibaACBits = kToshibaACStateLength * 8;
+const uint16_t kToshibaACMinRepeat = kSingleRepeat;
+const uint16_t kTrotecStateLength = 9;
+const uint16_t kWhirlpoolAcStateLength = 21;
+const uint16_t kWhirlpoolAcBits = kWhirlpoolAcStateLength * 8;
+const uint16_t kWhynterBits = 32;
+
+// Legacy defines. (Deprecated)
+#define AIWA_RC_T501_BITS kAiwaRcT501Bits
+#define ARGO_COMMAND_LENGTH kArgoStateLength
+#define COOLIX_BITS kCoolixBits
+#define CARRIER_AC_BITS kCarrierAcBits
+#define DAIKIN_COMMAND_LENGTH kDaikinStateLength
+#define DENON_BITS kDenonBits
+#define DENON_48_BITS kPanasonicBits
+#define DENON_LEGACY_BITS kDenonLegacyBits
+#define DISH_BITS kDishBits
+#define FUJITSU_AC_MIN_REPEAT kFujitsuAcMinRepeat
+#define FUJITSU_AC_STATE_LENGTH kFujitsuAcStateLength
+#define FUJITSU_AC_STATE_LENGTH_SHORT kFujitsuAcStateLengthShort
+#define FUJITSU_AC_BITS kFujitsuAcBits
+#define FUJITSU_AC_MIN_BITS kFujitsuAcMinBits
+#define GICABLE_BITS kGicableBits
+#define GREE_STATE_LENGTH kGreeStateLength
+#define HAIER_AC_STATE_LENGTH kHaierACStateLength
+#define HAIER_AC_YRW02_STATE_LENGTH kHaierACYRW02StateLength
+#define HITACHI_AC_STATE_LENGTH kHitachiAcStateLength
+#define HITACHI_AC_BITS kHitachiAcBits
+#define HITACHI_AC1_STATE_LENGTH kHitachiAc1StateLength
+#define HITACHI_AC1_BITS kHitachiAc1Bits
+#define HITACHI_AC2_STATE_LENGTH kHitachiAc2StateLength
+#define HITACHI_AC2_BITS kHitachiAc2Bits
+#define JVC_BITS kJvcBits
+#define KELVINATOR_STATE_LENGTH kKelvinatorStateLength
+#define LASERTAG_BITS kLasertagBits
+#define LG_BITS kLgBits
+#define LG32_BITS kLg32Bits
+#define MAGIQUEST_BITS kMagiquestBits
+#define MIDEA_BITS kMideaBits
+#define MITSUBISHI_BITS kMitsubishiBits
+#define MITSUBISHI_AC_STATE_LENGTH kMitsubishiACStateLength
+#define NEC_BITS kNECBits
+#define NIKAI_BITS kNikaiBits
+#define PANASONIC_BITS kPanasonicBits
+#define RC5_BITS kRC5Bits
+#define RC5X_BITS kRC5XBits
+#define RC6_MODE0_BITS kRC6Mode0Bits
+#define RC6_36_BITS kRC6_36Bits
+#define RCMM_BITS kRCMMBits
+#define SANYO_LC7461_BITS kSanyoLC7461Bits
+#define SAMSUNG_BITS kSamsungBits
+#define SANYO_SA8650B_BITS kSanyoSA8650BBits
+#define SHARP_BITS kSharpBits
+#define SHERWOOD_BITS kSherwoodBits
+#define SONY_12_BITS kSony12Bits
+#define SONY_15_BITS kSony15Bits
+#define SONY_20_BITS kSony20Bits
+#define TOSHIBA_AC_STATE_LENGTH kToshibaACStateLength
+#define TROTEC_COMMAND_LENGTH kTrotecStateLength
+#define WHYNTER_BITS kWhynterBits
+
+// Turn on Debugging information by uncommenting the following line.
+// #define DEBUG 1
+
+#ifdef DEBUG
+#ifdef UNIT_TEST
+#define DPRINT(x) do { std::cout << x; } while (0)
+#define DPRINTLN(x) do { std::cout << x << std::endl; } while (0)
+#endif // UNIT_TEST
+#ifdef ARDUINO
+#define DPRINT(x) do { Serial.print(x); } while (0)
+#define DPRINTLN(x) do { Serial.println(x); } while (0)
+#endif // ARDUINO
+#else // DEBUG
+#define DPRINT(x)
+#define DPRINTLN(x)
+#endif // DEBUG
+
+#endif // IRREMOTEESP8266_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/IRsend.cpp b/lib/IRremoteESP8266-2.5.2.03/src/IRsend.cpp
new file mode 100644
index 000000000000..96f95172da0f
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/IRsend.cpp
@@ -0,0 +1,601 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2015 Mark Szabo
+// Copyright 2017 David Conran
+
+#include "IRsend.h"
+#ifndef UNIT_TEST
+#include
+#else
+#define __STDC_LIMIT_MACROS
+#include
+#endif
+#include
+#ifdef UNIT_TEST
+#include
+#endif
+#include "IRtimer.h"
+
+// Originally from https://github.com/shirriff/Arduino-IRremote/
+// Updated by markszabo (https://github.com/markszabo/IRremoteESP8266) for
+// sending IR code on ESP8266
+
+// IRsend ----------------------------------------------------------------------
+// Create an IRsend object.
+//
+// Args:
+// IRsendPin: Which GPIO pin to use when sending an IR command.
+// inverted: *DANGER* Optional flag to invert the output. (default = false)
+// e.g. LED is illuminated when GPIO is LOW rather than HIGH.
+// Setting this to something other than the default could
+// easily destroy your IR LED if you are overdriving it.
+// Unless you *REALLY* know what you are doing, don't change this.
+// use_modulation: Do we do frequency modulation during transmission?
+// i.e. If not, assume a 100% duty cycle. Ignore attempts
+// to change the duty cycle etc.
+// Returns:
+// An IRsend object.
+IRsend::IRsend(uint16_t IRsendPin, bool inverted, bool use_modulation)
+ : IRpin(IRsendPin), periodOffset(kPeriodOffset) {
+ if (inverted) {
+ outputOn = LOW;
+ outputOff = HIGH;
+ } else {
+ outputOn = HIGH;
+ outputOff = LOW;
+ }
+ modulation = use_modulation;
+ if (modulation)
+ _dutycycle = kDutyDefault;
+ else
+ _dutycycle = kDutyMax;
+}
+
+// Enable the pin for output.
+void IRsend::begin() {
+#ifndef UNIT_TEST
+ pinMode(IRpin, OUTPUT);
+#endif
+ ledOff(); // Ensure the LED is in a known safe state when we start.
+}
+
+// Turn off the IR LED.
+void IRsend::ledOff() {
+#ifndef UNIT_TEST
+ digitalWrite(IRpin, outputOff);
+#endif
+}
+
+// Turn on the IR LED.
+void IRsend::ledOn() {
+#ifndef UNIT_TEST
+ digitalWrite(IRpin, outputOn);
+#endif
+}
+
+// Calculate the period for a given frequency. (T = 1/f)
+//
+// Args:
+// freq: Frequency in Hz.
+// use_offset: Should we use the calculated offset or not?
+// Returns:
+// nr. of uSeconds.
+uint32_t IRsend::calcUSecPeriod(uint32_t hz, bool use_offset) {
+ if (hz == 0) hz = 1; // Avoid Zero hz. Divide by Zero is nasty.
+ uint32_t period =
+ (1000000UL + hz / 2) / hz; // The equiv of round(1000000/hz).
+ // Apply the offset and ensure we don't result in a <= 0 value.
+ if (use_offset)
+ return std::max((uint32_t)1, period + periodOffset);
+ else
+ return std::max((uint32_t)1, period);
+}
+
+// Set the output frequency modulation and duty cycle.
+//
+// Args:
+// freq: The freq we want to modulate at. Assumes < 1000 means kHz else Hz.
+// duty: Percentage duty cycle of the LED. e.g. 25 = 25% = 1/4 on, 3/4 off.
+// This is ignored if modulation is disabled at object instantiation.
+//
+// Note:
+// Integer timing functions & math mean we can't do fractions of
+// microseconds timing. Thus minor changes to the freq & duty values may have
+// limited effect. You've been warned.
+void IRsend::enableIROut(uint32_t freq, uint8_t duty) {
+ // Set the duty cycle to use if we want freq. modulation.
+ if (modulation) {
+ _dutycycle = std::min(duty, kDutyMax);
+ } else {
+ _dutycycle = kDutyMax;
+ }
+ if (freq < 1000) // Were we given kHz? Supports the old call usage.
+ freq *= 1000;
+ uint32_t period = calcUSecPeriod(freq);
+ // Nr. of uSeconds the LED will be on per pulse.
+ onTimePeriod = (period * _dutycycle) / kDutyMax;
+ // Nr. of uSeconds the LED will be off per pulse.
+ offTimePeriod = period - onTimePeriod;
+}
+
+#if ALLOW_DELAY_CALLS
+// An ESP8266 RTOS watch-dog timer friendly version of delayMicroseconds().
+// Args:
+// usec: Nr. of uSeconds to delay for.
+void IRsend::_delayMicroseconds(uint32_t usec) {
+ // delayMicroseconds() is only accurate to 16383us.
+ // Ref: https://www.arduino.cc/en/Reference/delayMicroseconds
+ if (usec <= kMaxAccurateUsecDelay) {
+#ifndef UNIT_TEST
+ delayMicroseconds(usec);
+#endif
+ } else {
+#ifndef UNIT_TEST
+ // Invoke a delay(), where possible, to avoid triggering the WDT.
+ delay(usec / 1000UL); // Delay for as many whole milliseconds as we can.
+ // Delay the remaining sub-millisecond.
+ delayMicroseconds(static_cast(usec % 1000UL));
+#endif
+ }
+}
+#else // ALLOW_DELAY_CALLS
+// A version of delayMicroseconds() that handles large values and does NOT use
+// the watch-dog friendly delay() calls where appropriate.
+// Args:
+// usec: Nr. of uSeconds to delay for.
+//
+// NOTE: Use this only if you know what you are doing as it may cause the WDT
+// to reset the ESP8266.
+void IRsend::_delayMicroseconds(uint32_t usec) {
+ for (; usec > kMaxAccurateUsecDelay; usec -= kMaxAccurateUsecDelay)
+#ifndef UNIT_TEST
+ delayMicroseconds(kMaxAccurateUsecDelay);
+ delayMicroseconds(static_cast(usec));
+#endif // UNIT_TEST
+}
+#endif // ALLOW_DELAY_CALLS
+
+// Modulate the IR LED for the given period (usec) and at the duty cycle set.
+//
+// Args:
+// usec: The period of time to modulate the IR LED for, in microseconds.
+// Returns:
+// Nr. of pulses actually sent.
+//
+// Note:
+// The ESP8266 has no good way to do hardware PWM, so we have to do it all
+// in software. There is a horrible kludge/brilliant hack to use the second
+// serial TX line to do fairly accurate hardware PWM, but it is only
+// available on a single specific GPIO and only available on some modules.
+// e.g. It's not available on the ESP-01 module.
+// Hence, for greater compatibility & choice, we don't use that method.
+// Ref:
+// https://www.analysir.com/blog/2017/01/29/updated-esp8266-nodemcu-backdoor-upwm-hack-for-ir-signals/
+uint16_t IRsend::mark(uint16_t usec) {
+ // Handle the simple case of no required frequency modulation.
+ if (!modulation || _dutycycle >= 100) {
+ ledOn();
+ _delayMicroseconds(usec);
+ ledOff();
+ return 1;
+ }
+
+ // Not simple, so do it assuming frequency modulation.
+ uint16_t counter = 0;
+ IRtimer usecTimer = IRtimer();
+ // Cache the time taken so far. This saves us calling time, and we can be
+ // assured that we can't have odd math problems. i.e. unsigned under/overflow.
+ uint32_t elapsed = usecTimer.elapsed();
+
+ while (elapsed < usec) { // Loop until we've met/exceeded our required time.
+ ledOn();
+ // Calculate how long we should pulse on for.
+ // e.g. Are we to close to the end of our requested mark time (usec)?
+ _delayMicroseconds(std::min((uint32_t)onTimePeriod, usec - elapsed));
+ ledOff();
+ counter++;
+ if (elapsed + onTimePeriod >= usec)
+ return counter; // LED is now off & we've passed our allotted time.
+ // Wait for the lesser of the rest of the duty cycle, or the time remaining.
+ _delayMicroseconds(
+ std::min(usec - elapsed - onTimePeriod, (uint32_t)offTimePeriod));
+ elapsed = usecTimer.elapsed(); // Update & recache the actual elapsed time.
+ }
+ return counter;
+}
+
+// Turn the pin (LED) off for a given time.
+// Sends an IR space for the specified number of microseconds.
+// A space is no output, so the PWM output is disabled.
+//
+// Args:
+// time: Time in microseconds (us).
+void IRsend::space(uint32_t time) {
+ ledOff();
+ if (time == 0) return;
+ _delayMicroseconds(time);
+}
+
+// Calculate & set any offsets to account for execution times.
+//
+// Args:
+// hz: The frequency to calibrate at >= 1000Hz. Default is 38000Hz.
+//
+// Returns:
+// The calculated period offset (in uSeconds) which is now in use. e.g. -5.
+//
+// Status: Stable / Working.
+//
+// NOTE:
+// This will generate an 65535us mark() IR LED signal.
+// This only needs to be called once, if at all.
+int8_t IRsend::calibrate(uint16_t hz) {
+ if (hz < 1000) // Were we given kHz? Supports the old call usage.
+ hz *= 1000;
+ periodOffset = 0; // Turn off any existing offset while we calibrate.
+ enableIROut(hz);
+ IRtimer usecTimer = IRtimer(); // Start a timer *just* before we do the call.
+ uint16_t pulses = mark(UINT16_MAX); // Generate a PWM of 65,535 us. (Max.)
+ uint32_t timeTaken = usecTimer.elapsed(); // Record the time it took.
+ // While it shouldn't be necessary, assume at least 1 pulse, to avoid a
+ // divide by 0 situation.
+ pulses = std::max(pulses, (uint16_t)1U);
+ uint32_t calcPeriod = calcUSecPeriod(hz); // e.g. @38kHz it should be 26us.
+ // Assuming 38kHz for the example calculations:
+ // In a 65535us pulse, we should have 2520.5769 pulses @ 26us periods.
+ // e.g. 65535.0us / 26us = 2520.5769
+ // This should have caused approx 2520 loops through the main loop in mark().
+ // The average over that many interations should give us a reasonable
+ // approximation at what offset we need to use to account for instruction
+ // execution times.
+ //
+ // Calculate the actual period from the actual time & the actual pulses
+ // generated.
+ double_t actualPeriod = (double_t)timeTaken / (double_t)pulses;
+ // Store the difference between the actual time per period vs. calculated.
+ periodOffset = (int8_t)((double_t)calcPeriod - actualPeriod);
+ return periodOffset;
+}
+
+// Generic method for sending data that is common to most protocols.
+// Will send leading or trailing 0's if the nbits is larger than the number
+// of bits in data.
+//
+// Args:
+// onemark: Nr. of usecs for the led to be pulsed for a '1' bit.
+// onespace: Nr. of usecs for the led to be fully off for a '1' bit.
+// zeromark: Nr. of usecs for the led to be pulsed for a '0' bit.
+// zerospace: Nr. of usecs for the led to be fully off for a '0' bit.
+// data: The data to be transmitted.
+// nbits: Nr. of bits of data to be sent.
+// MSBfirst: Flag for bit transmission order. Defaults to MSB->LSB order.
+void IRsend::sendData(uint16_t onemark, uint32_t onespace, uint16_t zeromark,
+ uint32_t zerospace, uint64_t data, uint16_t nbits,
+ bool MSBfirst) {
+ if (nbits == 0) // If we are asked to send nothing, just return.
+ return;
+ if (MSBfirst) { // Send the MSB first.
+ // Send 0's until we get down to a bit size we can actually manage.
+ while (nbits > sizeof(data) * 8) {
+ mark(zeromark);
+ space(zerospace);
+ nbits--;
+ }
+ // Send the supplied data.
+ for (uint64_t mask = 1ULL << (nbits - 1); mask; mask >>= 1)
+ if (data & mask) { // Send a 1
+ mark(onemark);
+ space(onespace);
+ } else { // Send a 0
+ mark(zeromark);
+ space(zerospace);
+ }
+ } else { // Send the Least Significant Bit (LSB) first / MSB last.
+ for (uint16_t bit = 0; bit < nbits; bit++, data >>= 1)
+ if (data & 1) { // Send a 1
+ mark(onemark);
+ space(onespace);
+ } else { // Send a 0
+ mark(zeromark);
+ space(zerospace);
+ }
+ }
+}
+
+// Generic method for sending simple protocol messages.
+// Will send leading or trailing 0's if the nbits is larger than the number
+// of bits in data.
+//
+// Args:
+// headermark: Nr. of usecs for the led to be pulsed for the header mark.
+// A value of 0 means no header mark.
+// headerspace: Nr. of usecs for the led to be off after the header mark.
+// A value of 0 means no header space.
+// onemark: Nr. of usecs for the led to be pulsed for a '1' bit.
+// onespace: Nr. of usecs for the led to be fully off for a '1' bit.
+// zeromark: Nr. of usecs for the led to be pulsed for a '0' bit.
+// zerospace: Nr. of usecs for the led to be fully off for a '0' bit.
+// footermark: Nr. of usecs for the led to be pulsed for the footer mark.
+// A value of 0 means no footer mark.
+// gap: Nr. of usecs for the led to be off after the footer mark.
+// This is effectively the gap between messages.
+// A value of 0 means no gap space.
+// data: The data to be transmitted.
+// nbits: Nr. of bits of data to be sent.
+// frequency: The frequency we want to modulate at.
+// Assumes < 1000 means kHz otherwise it is in Hz.
+// Most common value is 38000 or 38, for 38kHz.
+// MSBfirst: Flag for bit transmission order. Defaults to MSB->LSB order.
+// repeat: Nr. of extra times the message will be sent.
+// e.g. 0 = 1 message sent, 1 = 1 initial + 1 repeat = 2 messages
+// dutycycle: Percentage duty cycle of the LED.
+// e.g. 25 = 25% = 1/4 on, 3/4 off.
+// If you are not sure, try 50 percent.
+void IRsend::sendGeneric(const uint16_t headermark, const uint32_t headerspace,
+ const uint16_t onemark, const uint32_t onespace,
+ const uint16_t zeromark, const uint32_t zerospace,
+ const uint16_t footermark, const uint32_t gap,
+ const uint64_t data, const uint16_t nbits,
+ const uint16_t frequency, const bool MSBfirst,
+ const uint16_t repeat, const uint8_t dutycycle) {
+ sendGeneric(headermark, headerspace, onemark, onespace, zeromark, zerospace,
+ footermark, gap, 0U, data, nbits, frequency, MSBfirst, repeat,
+ dutycycle);
+}
+
+// Generic method for sending simple protocol messages.
+// Will send leading or trailing 0's if the nbits is larger than the number
+// of bits in data.
+//
+// Args:
+// headermark: Nr. of usecs for the led to be pulsed for the header mark.
+// A value of 0 means no header mark.
+// headerspace: Nr. of usecs for the led to be off after the header mark.
+// A value of 0 means no header space.
+// onemark: Nr. of usecs for the led to be pulsed for a '1' bit.
+// onespace: Nr. of usecs for the led to be fully off for a '1' bit.
+// zeromark: Nr. of usecs for the led to be pulsed for a '0' bit.
+// zerospace: Nr. of usecs for the led to be fully off for a '0' bit.
+// footermark: Nr. of usecs for the led to be pulsed for the footer mark.
+// A value of 0 means no footer mark.
+// gap: Min. nr. of usecs for the led to be off after the footer mark.
+// This is effectively the absolute minimum gap between messages.
+// mesgtime: Min. nr. of usecs a single message needs to be.
+// This is effectively the min. total length of a single message.
+// data: The data to be transmitted.
+// nbits: Nr. of bits of data to be sent.
+// frequency: The frequency we want to modulate at.
+// Assumes < 1000 means kHz otherwise it is in Hz.
+// Most common value is 38000 or 38, for 38kHz.
+// MSBfirst: Flag for bit transmission order. Defaults to MSB->LSB order.
+// repeat: Nr. of extra times the message will be sent.
+// e.g. 0 = 1 message sent, 1 = 1 initial + 1 repeat = 2 messages
+// dutycycle: Percentage duty cycle of the LED.
+// e.g. 25 = 25% = 1/4 on, 3/4 off.
+// If you are not sure, try 50 percent.
+void IRsend::sendGeneric(const uint16_t headermark, const uint32_t headerspace,
+ const uint16_t onemark, const uint32_t onespace,
+ const uint16_t zeromark, const uint32_t zerospace,
+ const uint16_t footermark, const uint32_t gap,
+ const uint32_t mesgtime, const uint64_t data,
+ const uint16_t nbits, const uint16_t frequency,
+ const bool MSBfirst, const uint16_t repeat,
+ const uint8_t dutycycle) {
+ // Setup
+ enableIROut(frequency, dutycycle);
+ IRtimer usecs = IRtimer();
+
+ // We always send a message, even for repeat=0, hence '<= repeat'.
+ for (uint16_t r = 0; r <= repeat; r++) {
+ usecs.reset();
+
+ // Header
+ if (headermark) mark(headermark);
+ if (headerspace) space(headerspace);
+
+ // Data
+ sendData(onemark, onespace, zeromark, zerospace, data, nbits, MSBfirst);
+
+ // Footer
+ if (footermark) mark(footermark);
+ uint32_t elapsed = usecs.elapsed();
+ // Avoid potential unsigned integer underflow. e.g. when mesgtime is 0.
+ if (elapsed >= mesgtime)
+ space(gap);
+ else
+ space(std::max(gap, mesgtime - elapsed));
+ }
+}
+
+// Generic method for sending simple protocol messages.
+//
+// Args:
+// headermark: Nr. of usecs for the led to be pulsed for the header mark.
+// A value of 0 means no header mark.
+// headerspace: Nr. of usecs for the led to be off after the header mark.
+// A value of 0 means no header space.
+// onemark: Nr. of usecs for the led to be pulsed for a '1' bit.
+// onespace: Nr. of usecs for the led to be fully off for a '1' bit.
+// zeromark: Nr. of usecs for the led to be pulsed for a '0' bit.
+// zerospace: Nr. of usecs for the led to be fully off for a '0' bit.
+// footermark: Nr. of usecs for the led to be pulsed for the footer mark.
+// A value of 0 means no footer mark.
+// gap: Nr. of usecs for the led to be off after the footer mark.
+// This is effectively the gap between messages.
+// A value of 0 means no gap space.
+// dataptr: Pointer to the data to be transmitted.
+// nbytes: Nr. of bytes of data to be sent.
+// frequency: The frequency we want to modulate at.
+// Assumes < 1000 means kHz otherwise it is in Hz.
+// Most common value is 38000 or 38, for 38kHz.
+// MSBfirst: Flag for bit transmission order. Defaults to MSB->LSB order.
+// repeat: Nr. of extra times the message will be sent.
+// e.g. 0 = 1 message sent, 1 = 1 initial + 1 repeat = 2 messages
+// dutycycle: Percentage duty cycle of the LED.
+// e.g. 25 = 25% = 1/4 on, 3/4 off.
+// If you are not sure, try 50 percent.
+void IRsend::sendGeneric(const uint16_t headermark, const uint32_t headerspace,
+ const uint16_t onemark, const uint32_t onespace,
+ const uint16_t zeromark, const uint32_t zerospace,
+ const uint16_t footermark, const uint32_t gap,
+ const uint8_t *dataptr, const uint16_t nbytes,
+ const uint16_t frequency, const bool MSBfirst,
+ const uint16_t repeat, const uint8_t dutycycle) {
+ // Setup
+ enableIROut(frequency, dutycycle);
+ // We always send a message, even for repeat=0, hence '<= repeat'.
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // Header
+ if (headermark) mark(headermark);
+ if (headerspace) space(headerspace);
+
+ // Data
+ for (uint16_t i = 0; i < nbytes; i++)
+ sendData(onemark, onespace, zeromark, zerospace, *(dataptr + i), 8,
+ MSBfirst);
+
+ // Footer
+ if (footermark) mark(footermark);
+ space(gap);
+ }
+}
+
+#if SEND_RAW
+// Send a raw IRremote message.
+//
+// Args:
+// buf: An array of uint16_t's that has microseconds elements.
+// len: Nr. of elements in the buf[] array.
+// hz: Frequency to send the message at. (kHz < 1000; Hz >= 1000)
+//
+// Status: STABLE / Known working.
+//
+// Notes:
+// Even elements are Mark times (On), Odd elements are Space times (Off).
+//
+// Ref:
+// examples/IRrecvDumpV2/IRrecvDumpV2.ino
+void IRsend::sendRaw(uint16_t buf[], uint16_t len, uint16_t hz) {
+ // Set IR carrier frequency
+ enableIROut(hz);
+ for (uint16_t i = 0; i < len; i++) {
+ if (i & 1) { // Odd bit.
+ space(buf[i]);
+ } else { // Even bit.
+ mark(buf[i]);
+ }
+ }
+ ledOff(); // We potentially have ended with a mark(), so turn of the LED.
+}
+#endif // SEND_RAW
+
+#ifndef UNIT_TEST
+void IRsend::send(uint16_t type, uint64_t data, uint16_t nbits) {
+ switch (type) {
+#if SEND_NEC
+ case NEC:
+ sendNEC(data, nbits);
+ break;
+#endif
+#if SEND_SONY
+ case SONY:
+ sendSony(data, nbits);
+ break;
+#endif
+#if SEND_RC5
+ case RC5:
+ sendRC5(data, nbits);
+ break;
+#endif
+#if SEND_RC6
+ case RC6:
+ sendRC6(data, nbits);
+ break;
+#endif
+#if SEND_DISH
+ case DISH:
+ sendDISH(data, nbits);
+ break;
+#endif
+#if SEND_JVC
+ case JVC:
+ sendJVC(data, nbits);
+ break;
+#endif
+#if SEND_SAMSUNG
+ case SAMSUNG:
+ sendSAMSUNG(data, nbits);
+ break;
+#endif
+#if SEND_LG
+ case LG:
+ sendLG(data, nbits);
+ break;
+#endif
+#if SEND_LG
+ case LG2:
+ sendLG2(data, nbits);
+ break;
+#endif
+#if SEND_WHYNTER
+ case WHYNTER:
+ sendWhynter(data, nbits);
+ break;
+#endif
+#if SEND_COOLIX
+ case COOLIX:
+ sendCOOLIX(data, nbits);
+ break;
+#endif
+#if SEND_DENON
+ case DENON:
+ sendDenon(data, nbits);
+ break;
+#endif
+#if SEND_SHERWOOD
+ case SHERWOOD:
+ sendSherwood(data, nbits);
+ break;
+#endif
+#if SEND_RCMM
+ case RCMM:
+ sendRCMM(data, nbits);
+ break;
+#endif
+#if SEND_MITSUBISHI
+ case MITSUBISHI:
+ sendMitsubishi(data, nbits);
+ break;
+#endif
+#if SEND_MITSUBISHI2
+ case MITSUBISHI2:
+ sendMitsubishi2(data, nbits);
+ break;
+#endif
+#if SEND_SHARP
+ case SHARP:
+ sendSharpRaw(data, nbits);
+ break;
+#endif
+#if SEND_AIWA_RC_T501
+ case AIWA_RC_T501:
+ sendAiwaRCT501(data, nbits);
+ break;
+#endif
+#if SEND_MIDEA
+ case MIDEA:
+ sendMidea(data, nbits);
+ break;
+#endif
+#if SEND_GICABLE
+ case GICABLE:
+ sendGICable(data, nbits);
+ break;
+#endif
+#if SEND_PIONEER
+ case PIONEER:
+ sendPioneer(data, nbits);
+ break;
+#endif
+ }
+}
+#endif
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/IRsend.h b/lib/IRremoteESP8266-2.5.2.03/src/IRsend.h
new file mode 100644
index 000000000000..8e2dc248e178
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/IRsend.h
@@ -0,0 +1,333 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2015 Mark Szabo
+// Copyright 2017 David Conran
+#ifndef IRSEND_H_
+#define IRSEND_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#include "IRremoteESP8266.h"
+
+// Originally from https://github.com/shirriff/Arduino-IRremote/
+// Updated by markszabo (https://github.com/markszabo/IRremoteESP8266) for
+// sending IR code on ESP8266
+
+#if TEST || UNIT_TEST
+#define VIRTUAL virtual
+#else
+#define VIRTUAL
+#endif
+
+// Constants
+// Offset (in microseconds) to use in Period time calculations to account for
+// code excution time in producing the software PWM signal.
+// Value was calculated on Wemos D1 mini using v2.4.1 with v2.4.0 ESP core
+const int8_t kPeriodOffset = -5;
+const uint8_t kDutyDefault = 50; // Percentage
+const uint8_t kDutyMax = 100; // Percentage
+// delayMicroseconds() is only accurate to 16383us.
+// Ref: https://www.arduino.cc/en/Reference/delayMicroseconds
+const uint16_t kMaxAccurateUsecDelay = 16383;
+
+// Classes
+class IRsend {
+ public:
+ explicit IRsend(uint16_t IRsendPin, bool inverted = false,
+ bool use_modulation = true);
+ void begin();
+ void enableIROut(uint32_t freq, uint8_t duty = kDutyDefault);
+ VIRTUAL void _delayMicroseconds(uint32_t usec);
+ VIRTUAL uint16_t mark(uint16_t usec);
+ VIRTUAL void space(uint32_t usec);
+ int8_t calibrate(uint16_t hz = 38000U);
+ void sendRaw(uint16_t buf[], uint16_t len, uint16_t hz);
+ void sendData(uint16_t onemark, uint32_t onespace, uint16_t zeromark,
+ uint32_t zerospace, uint64_t data, uint16_t nbits,
+ bool MSBfirst = true);
+ void sendGeneric(const uint16_t headermark, const uint32_t headerspace,
+ const uint16_t onemark, const uint32_t onespace,
+ const uint16_t zeromark, const uint32_t zerospace,
+ const uint16_t footermark, const uint32_t gap,
+ const uint64_t data, const uint16_t nbits,
+ const uint16_t frequency, const bool MSBfirst,
+ const uint16_t repeat, const uint8_t dutycycle);
+ void sendGeneric(const uint16_t headermark, const uint32_t headerspace,
+ const uint16_t onemark, const uint32_t onespace,
+ const uint16_t zeromark, const uint32_t zerospace,
+ const uint16_t footermark, const uint32_t gap,
+ const uint32_t mesgtime, const uint64_t data,
+ const uint16_t nbits, const uint16_t frequency,
+ const bool MSBfirst, const uint16_t repeat,
+ const uint8_t dutycycle);
+ void sendGeneric(const uint16_t headermark, const uint32_t headerspace,
+ const uint16_t onemark, const uint32_t onespace,
+ const uint16_t zeromark, const uint32_t zerospace,
+ const uint16_t footermark, const uint32_t gap,
+ const uint8_t *dataptr, const uint16_t nbytes,
+ const uint16_t frequency, const bool MSBfirst,
+ const uint16_t repeat, const uint8_t dutycycle);
+ void send(uint16_t type, uint64_t data, uint16_t nbits);
+#if (SEND_NEC || SEND_SHERWOOD || SEND_AIWA_RC_T501 || SEND_SANYO)
+ void sendNEC(uint64_t data, uint16_t nbits = kNECBits,
+ uint16_t repeat = kNoRepeat);
+ uint32_t encodeNEC(uint16_t address, uint16_t command);
+#endif
+#if SEND_SONY
+ // sendSony() should typically be called with repeat=2 as Sony devices
+ // expect the code to be sent at least 3 times. (code + 2 repeats = 3 codes)
+ // Legacy use of this procedure was to only send a single code so call it with
+ // repeat=0 for backward compatibility. As of v2.0 it defaults to sending
+ // a Sony command that will be accepted be a device.
+ void sendSony(uint64_t data, uint16_t nbits = kSony20Bits,
+ uint16_t repeat = kSonyMinRepeat);
+ uint32_t encodeSony(uint16_t nbits, uint16_t command, uint16_t address,
+ uint16_t extended = 0);
+#endif
+#if SEND_SHERWOOD
+ void sendSherwood(uint64_t data, uint16_t nbits = kSherwoodBits,
+ uint16_t repeat = kSherwoodMinRepeat);
+#endif
+#if SEND_SAMSUNG
+ void sendSAMSUNG(uint64_t data, uint16_t nbits = kSamsungBits,
+ uint16_t repeat = kNoRepeat);
+ uint32_t encodeSAMSUNG(uint8_t customer, uint8_t command);
+#endif
+#if SEND_SAMSUNG_AC
+ void sendSamsungAC(unsigned char data[],
+ uint16_t nbytes = kSamsungAcStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_LG
+ void sendLG(uint64_t data, uint16_t nbits = kLgBits,
+ uint16_t repeat = kNoRepeat);
+ void sendLG2(uint64_t data, uint16_t nbits = kLgBits,
+ uint16_t repeat = kNoRepeat);
+ uint32_t encodeLG(uint16_t address, uint16_t command);
+#endif
+#if (SEND_SHARP || SEND_DENON)
+ uint32_t encodeSharp(uint16_t address, uint16_t command,
+ uint16_t expansion = 1, uint16_t check = 0,
+ bool MSBfirst = false);
+ void sendSharp(uint16_t address, uint16_t command,
+ uint16_t nbits = kSharpBits, uint16_t repeat = kNoRepeat);
+ void sendSharpRaw(uint64_t data, uint16_t nbits = kSharpBits,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_JVC
+ void sendJVC(uint64_t data, uint16_t nbits = kJvcBits,
+ uint16_t repeat = kNoRepeat);
+ uint16_t encodeJVC(uint8_t address, uint8_t command);
+#endif
+#if SEND_DENON
+ void sendDenon(uint64_t data, uint16_t nbits = DENON_BITS,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_SANYO
+ uint64_t encodeSanyoLC7461(uint16_t address, uint8_t command);
+ void sendSanyoLC7461(uint64_t data, uint16_t nbits = kSanyoLC7461Bits,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_DISH
+ // sendDISH() should typically be called with repeat=3 as DISH devices
+ // expect the code to be sent at least 4 times. (code + 3 repeats = 4 codes)
+ // Legacy use of this procedure was only to send a single code
+ // so use repeat=0 for backward compatibility.
+ void sendDISH(uint64_t data, uint16_t nbits = kDishBits,
+ uint16_t repeat = kDishMinRepeat);
+#endif
+#if (SEND_PANASONIC || SEND_DENON)
+ void sendPanasonic64(uint64_t data, uint16_t nbits = kPanasonicBits,
+ uint16_t repeat = kNoRepeat);
+ void sendPanasonic(uint16_t address, uint32_t data,
+ uint16_t nbits = kPanasonicBits,
+ uint16_t repeat = kNoRepeat);
+ uint64_t encodePanasonic(uint16_t manufacturer, uint8_t device,
+ uint8_t subdevice, uint8_t function);
+#endif
+#if SEND_RC5
+ void sendRC5(uint64_t data, uint16_t nbits = kRC5XBits,
+ uint16_t repeat = kNoRepeat);
+ uint16_t encodeRC5(uint8_t address, uint8_t command,
+ bool key_released = false);
+ uint16_t encodeRC5X(uint8_t address, uint8_t command,
+ bool key_released = false);
+ uint64_t toggleRC5(uint64_t data);
+#endif
+#if SEND_RC6
+ void sendRC6(uint64_t data, uint16_t nbits = kRC6Mode0Bits,
+ uint16_t repeat = kNoRepeat);
+ uint64_t encodeRC6(uint32_t address, uint8_t command,
+ uint16_t mode = kRC6Mode0Bits);
+ uint64_t toggleRC6(uint64_t data, uint16_t nbits = kRC6Mode0Bits);
+#endif
+#if SEND_RCMM
+ void sendRCMM(uint64_t data, uint16_t nbits = kRCMMBits,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_COOLIX
+ void sendCOOLIX(uint64_t data, uint16_t nbits = kCoolixBits,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_WHYNTER
+ void sendWhynter(uint64_t data, uint16_t nbits = kWhynterBits,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_MITSUBISHI
+ void sendMitsubishi(uint64_t data, uint16_t nbits = kMitsubishiBits,
+ uint16_t repeat = kMitsubishiMinRepeat);
+#endif
+#if SEND_MITSUBISHI2
+ void sendMitsubishi2(uint64_t data, uint16_t nbits = kMitsubishiBits,
+ uint16_t repeat = kMitsubishiMinRepeat);
+#endif
+#if SEND_MITSUBISHI_AC
+ void sendMitsubishiAC(unsigned char data[],
+ uint16_t nbytes = kMitsubishiACStateLength,
+ uint16_t repeat = kMitsubishiACMinRepeat);
+#endif
+#if SEND_FUJITSU_AC
+ void sendFujitsuAC(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat = kFujitsuAcMinRepeat);
+#endif
+#if SEND_GLOBALCACHE
+ void sendGC(uint16_t buf[], uint16_t len);
+#endif
+#if SEND_KELVINATOR
+ void sendKelvinator(unsigned char data[],
+ uint16_t nbytes = kKelvinatorStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_DAIKIN
+ void sendDaikin(unsigned char data[], uint16_t nbytes = kDaikinStateLength,
+ uint16_t repeat = kNoRepeat);
+ void sendDaikinGapHeader();
+#endif
+#if SEND_AIWA_RC_T501
+ void sendAiwaRCT501(uint64_t data, uint16_t nbits = kAiwaRcT501Bits,
+ uint16_t repeat = kAiwaRcT501MinRepeats);
+#endif
+#if SEND_GREE
+ void sendGree(uint64_t data, uint16_t nbits = kGreeBits,
+ uint16_t repeat = kNoRepeat);
+ void sendGree(uint8_t data[], uint16_t nbytes = kGreeStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_PRONTO
+ void sendPronto(uint16_t data[], uint16_t len, uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_ARGO
+ void sendArgo(unsigned char data[], uint16_t nbytes = kArgoStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_TROTEC
+ void sendTrotec(unsigned char data[], uint16_t nbytes = kTrotecStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_NIKAI
+ void sendNikai(uint64_t data, uint16_t nbits = kNikaiBits,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_TOSHIBA_AC
+ void sendToshibaAC(unsigned char data[],
+ uint16_t nbytes = kToshibaACStateLength,
+ uint16_t repeat = kToshibaACMinRepeat);
+#endif
+#if SEND_MIDEA
+ void sendMidea(uint64_t data, uint16_t nbits = kMideaBits,
+ uint16_t repeat = kMideaMinRepeat);
+#endif
+#if SEND_MAGIQUEST
+ void sendMagiQuest(uint64_t data, uint16_t nbits = kMagiquestBits,
+ uint16_t repeat = kNoRepeat);
+ uint64_t encodeMagiQuest(uint32_t wand_id, uint16_t magnitude);
+#endif
+#if SEND_LASERTAG
+ void sendLasertag(uint64_t data, uint16_t nbits = kLasertagBits,
+ uint16_t repeat = kLasertagMinRepeat);
+#endif
+#if SEND_CARRIER_AC
+ void sendCarrierAC(uint64_t data, uint16_t nbits = kCarrierAcBits,
+ uint16_t repeat = kCarrierAcMinRepeat);
+#endif
+#if (SEND_HAIER_AC || SEND_HAIER_AC_YRW02)
+ void sendHaierAC(unsigned char data[], uint16_t nbytes = kHaierACStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_HAIER_AC_YRW02
+ void sendHaierACYRW02(unsigned char data[],
+ uint16_t nbytes = kHaierACYRW02StateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_HITACHI_AC
+ void sendHitachiAC(unsigned char data[],
+ uint16_t nbytes = kHitachiAcStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_HITACHI_AC1
+ void sendHitachiAC1(unsigned char data[],
+ uint16_t nbytes = kHitachiAc1StateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_HITACHI_AC2
+ void sendHitachiAC2(unsigned char data[],
+ uint16_t nbytes = kHitachiAc2StateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_GICABLE
+ void sendGICable(uint64_t data, uint16_t nbits = kGicableBits,
+ uint16_t repeat = kGicableMinRepeat);
+#endif
+#if SEND_WHIRLPOOL_AC
+ void sendWhirlpoolAC(unsigned char data[],
+ uint16_t nbytes = kWhirlpoolAcStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_LUTRON
+ void sendLutron(uint64_t data, uint16_t nbits = kLutronBits,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_ELECTRA_AC
+ void sendElectraAC(unsigned char data[],
+ uint16_t nbytes = kElectraAcStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_PANASONIC_AC
+ void sendPanasonicAC(unsigned char data[],
+ uint16_t nbytes = kPanasonicAcStateLength,
+ uint16_t repeat = kNoRepeat);
+#endif
+#if SEND_PIONEER
+ void sendPioneer(const uint64_t data, const uint16_t nbits = kPioneerBits,
+ const uint16_t repeat = kNoRepeat);
+ uint64_t encodePioneer(uint16_t address, uint16_t command);
+#endif
+#if SEND_MWM
+ void sendMWM(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat = kNoRepeat);
+#endif
+
+ protected:
+#ifdef UNIT_TEST
+#ifndef HIGH
+#define HIGH 0x1
+#endif
+#ifndef LOW
+#define LOW 0x0
+#endif
+#endif // UNIT_TEST
+ uint8_t outputOn;
+ uint8_t outputOff;
+ VIRTUAL void ledOff();
+ VIRTUAL void ledOn();
+
+ private:
+ uint16_t onTimePeriod;
+ uint16_t offTimePeriod;
+ uint16_t IRpin;
+ int8_t periodOffset;
+ uint8_t _dutycycle;
+ bool modulation;
+ uint32_t calcUSecPeriod(uint32_t hz, bool use_offset = true);
+};
+
+#endif // IRSEND_H_
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/IRtimer.cpp b/lib/IRremoteESP8266-2.5.2.03/src/IRtimer.cpp
similarity index 52%
rename from lib/IRremoteESP8266-2.2.1.02/src/IRtimer.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/IRtimer.cpp
index cc5cdfaff298..029637cbb94d 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/IRtimer.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/IRtimer.cpp
@@ -5,18 +5,21 @@
#include
#endif
+#ifdef UNIT_TEST
+// Used to help simulate elapsed time in unit tests.
+extern uint32_t _IRtimer_unittest_now;
+#endif // UNIT_TEST
+
// This class performs a simple time in useconds since instantiated.
// Handles when the system timer wraps around (once).
-IRtimer::IRtimer() {
- reset();
-}
+IRtimer::IRtimer() { reset(); }
void IRtimer::reset() {
#ifndef UNIT_TEST
start = micros();
#else
- start = 0;
+ start = _IRtimer_unittest_now;
#endif
}
@@ -24,10 +27,15 @@ uint32_t IRtimer::elapsed() {
#ifndef UNIT_TEST
uint32_t now = micros();
#else
- uint32_t now = 0;
+ uint32_t now = _IRtimer_unittest_now;
#endif
- if (start <= now) // Check if the system timer has wrapped.
+ if (start <= now) // Check if the system timer has wrapped.
return now - start; // No wrap.
else
return UINT32_MAX - start + now; // Has wrapped.
}
+
+// Only used in unit testing.
+#ifdef UNIT_TEST
+void IRtimer::add(uint32_t usecs) { _IRtimer_unittest_now += usecs; }
+#endif // UNIT_TEST
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/IRtimer.h b/lib/IRremoteESP8266-2.5.2.03/src/IRtimer.h
similarity index 78%
rename from lib/IRremoteESP8266-2.2.1.02/src/IRtimer.h
rename to lib/IRremoteESP8266-2.5.2.03/src/IRtimer.h
index 6cf7f7dc825d..baca1cf74d3e 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/IRtimer.h
+++ b/lib/IRremoteESP8266-2.5.2.03/src/IRtimer.h
@@ -12,6 +12,9 @@ class IRtimer {
IRtimer();
void reset();
uint32_t elapsed();
+#ifdef UNIT_TEST
+ static void add(uint32_t usecs);
+#endif // UNIT_TEST
private:
uint32_t start;
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/IRutils.cpp b/lib/IRremoteESP8266-2.5.2.03/src/IRutils.cpp
new file mode 100644
index 000000000000..7864625a58f7
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/IRutils.cpp
@@ -0,0 +1,470 @@
+// Copyright 2017 David Conran
+
+#include "IRutils.h"
+#ifndef UNIT_TEST
+#include
+#endif
+
+#define __STDC_LIMIT_MACROS
+#include
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRremoteESP8266.h"
+
+// Reverse the order of the requested least significant nr. of bits.
+// Args:
+// input: Bit pattern/integer to reverse.
+// nbits: Nr. of bits to reverse.
+// Returns:
+// The reversed bit pattern.
+uint64_t reverseBits(uint64_t input, uint16_t nbits) {
+ if (nbits <= 1) return input; // Reversing <= 1 bits makes no change at all.
+ // Cap the nr. of bits to rotate to the max nr. of bits in the input.
+ nbits = std::min(nbits, (uint16_t)(sizeof(input) * 8));
+ uint64_t output = 0;
+ for (uint16_t i = 0; i < nbits; i++) {
+ output <<= 1;
+ output |= (input & 1);
+ input >>= 1;
+ }
+ // Merge any remaining unreversed bits back to the top of the reversed bits.
+ return (input << nbits) | output;
+}
+
+// Convert a uint64_t (unsigned long long) to a string.
+// Arduino String/toInt/Serial.print() can't handle printing 64 bit values.
+//
+// Args:
+// input: The value to print
+// base: The output base.
+// Returns:
+// A string representation of the integer.
+// Note: Based on Arduino's Print::printNumber()
+#ifdef ARDUINO // Arduino's & C++'s string implementations can't co-exist.
+String uint64ToString(uint64_t input, uint8_t base) {
+ String result = "";
+#else
+std::string uint64ToString(uint64_t input, uint8_t base) {
+ std::string result = "";
+#endif
+ // prevent issues if called with base <= 1
+ if (base < 2) base = 10;
+ // Check we have a base that we can actually print.
+ // i.e. [0-9A-Z] == 36
+ if (base > 36) base = 10;
+
+ do {
+ char c = input % base;
+ input /= base;
+
+ if (c < 10)
+ c += '0';
+ else
+ c += 'A' - 10;
+ result = c + result;
+ } while (input);
+ return result;
+}
+
+#ifdef ARDUINO
+// Print a uint64_t/unsigned long long to the Serial port
+// Serial.print() can't handle printing long longs. (uint64_t)
+//
+// Args:
+// input: The value to print
+// base: The output base.
+void serialPrintUint64(uint64_t input, uint8_t base) {
+ Serial.print(uint64ToString(input, base));
+}
+#endif
+
+// Convert a protocol type (enum etc) to a human readable string.
+// Args:
+// protocol: Nr. (enum) of the protocol.
+// isRepeat: A flag indicating if it is a repeat message of the protocol.
+// Returns:
+// A string containing the protocol name.
+#ifdef ARDUINO // Arduino's & C++'s string implementations can't co-exist.
+String typeToString(const decode_type_t protocol, const bool isRepeat) {
+ String result = "";
+#else
+std::string typeToString(const decode_type_t protocol, const bool isRepeat) {
+ std::string result = "";
+#endif
+ switch (protocol) {
+ default:
+ case UNKNOWN:
+ result = "UNKNOWN";
+ break;
+ case UNUSED:
+ result = "UNUSED";
+ break;
+ case AIWA_RC_T501:
+ result = "AIWA_RC_T501";
+ break;
+ case ARGO:
+ result = "ARGO";
+ break;
+ case CARRIER_AC:
+ result = "CARRIER_AC";
+ break;
+ case COOLIX:
+ result = "COOLIX";
+ break;
+ case DAIKIN:
+ result = "DAIKIN";
+ break;
+ case DENON:
+ result = "DENON";
+ break;
+ case DISH:
+ result = "DISH";
+ break;
+ case ELECTRA_AC:
+ result = "ELECTRA_AC";
+ break;
+ case FUJITSU_AC:
+ result = "FUJITSU_AC";
+ break;
+ case GICABLE:
+ result = "GICABLE";
+ break;
+ case GLOBALCACHE:
+ result = "GLOBALCACHE";
+ break;
+ case GREE:
+ result = "GREE";
+ break;
+ case HAIER_AC:
+ result = "HAIER_AC";
+ break;
+ case HAIER_AC_YRW02:
+ result = "HAIER_AC_YRW02";
+ break;
+ case HITACHI_AC:
+ result = "HITACHI_AC";
+ break;
+ case HITACHI_AC1:
+ result = "HITACHI_AC1";
+ break;
+ case HITACHI_AC2:
+ result = "HITACHI_AC2";
+ break;
+ case JVC:
+ result = "JVC";
+ break;
+ case KELVINATOR:
+ result = "KELVINATOR";
+ break;
+ case LG:
+ result = "LG";
+ break;
+ case LG2:
+ result = "LG2";
+ break;
+ case LASERTAG:
+ result = "LASERTAG";
+ break;
+ case LUTRON:
+ result = "LUTRON";
+ break;
+ case MAGIQUEST:
+ result = "MAGIQUEST";
+ break;
+ case MIDEA:
+ result = "MIDEA";
+ break;
+ case MITSUBISHI:
+ result = "MITSUBISHI";
+ break;
+ case MITSUBISHI2:
+ result = "MITSUBISHI2";
+ break;
+ case MITSUBISHI_AC:
+ result = "MITSUBISHI_AC";
+ break;
+ case MWM:
+ result = "MWM";
+ break;
+ case NEC:
+ result = "NEC";
+ break;
+ case NEC_LIKE:
+ result = "NEC (non-strict)";
+ break;
+ case NIKAI:
+ result = "NIKAI";
+ break;
+ case PANASONIC:
+ result = "PANASONIC";
+ break;
+ case PANASONIC_AC:
+ result = "PANASONIC_AC";
+ break;
+ case PIONEER:
+ result = "PIONEER";
+ break;
+ case PRONTO:
+ result = "PRONTO";
+ break;
+ case RAW:
+ result = "RAW";
+ break;
+ case RC5:
+ result = "RC5";
+ break;
+ case RC5X:
+ result = "RC5X";
+ break;
+ case RC6:
+ result = "RC6";
+ break;
+ case RCMM:
+ result = "RCMM";
+ break;
+ case SAMSUNG:
+ result = "SAMSUNG";
+ break;
+ case SAMSUNG_AC:
+ result = "SAMSUNG_AC";
+ break;
+ case SANYO:
+ result = "SANYO";
+ break;
+ case SANYO_LC7461:
+ result = "SANYO_LC7461";
+ break;
+ case SHARP:
+ result = "SHARP";
+ break;
+ case SHERWOOD:
+ result = "SHERWOOD";
+ break;
+ case SONY:
+ result = "SONY";
+ break;
+ case TOSHIBA_AC:
+ result = "TOSHIBA_AC";
+ break;
+ case TROTEC:
+ result = "TROTEC";
+ break;
+ case WHIRLPOOL_AC:
+ result = "WHIRLPOOL_AC";
+ break;
+ case WHYNTER:
+ result = "WHYNTER";
+ break;
+ }
+ if (isRepeat) result += " (Repeat)";
+ return result;
+}
+
+// Does the given protocol use a complex state as part of the decode?
+bool hasACState(const decode_type_t protocol) {
+ switch (protocol) {
+ case DAIKIN:
+ case ELECTRA_AC:
+ case FUJITSU_AC:
+ case GREE:
+ case HAIER_AC:
+ case HAIER_AC_YRW02:
+ case HITACHI_AC:
+ case HITACHI_AC1:
+ case HITACHI_AC2:
+ case KELVINATOR:
+ case MITSUBISHI_AC:
+ case MWM:
+ case PANASONIC_AC:
+ case SAMSUNG_AC:
+ case TOSHIBA_AC:
+ case WHIRLPOOL_AC:
+ return true;
+ default:
+ return false;
+ }
+}
+
+// Return the corrected length of a 'raw' format array structure
+// after over-large values are converted into multiple entries.
+// Args:
+// results: A ptr to a decode result.
+// Returns:
+// A uint16_t containing the length.
+uint16_t getCorrectedRawLength(const decode_results *results) {
+ uint16_t extended_length = results->rawlen - 1;
+ for (uint16_t i = 0; i < results->rawlen - 1; i++) {
+ uint32_t usecs = results->rawbuf[i] * kRawTick;
+ // Add two extra entries for multiple larger than UINT16_MAX it is.
+ extended_length += (usecs / (UINT16_MAX + 1)) * 2;
+ }
+ return extended_length;
+}
+
+// Return a string containing the key values of a decode_results structure
+// in a C/C++ code style format.
+#ifdef ARDUINO
+String resultToSourceCode(const decode_results *results) {
+ String output = "";
+#else
+std::string resultToSourceCode(const decode_results *results) {
+ std::string output = "";
+#endif
+ // Start declaration
+ output += "uint16_t "; // variable type
+ output += "rawData["; // array name
+ output += uint64ToString(getCorrectedRawLength(results), 10);
+ // array size
+ output += "] = {"; // Start declaration
+
+ // Dump data
+ for (uint16_t i = 1; i < results->rawlen; i++) {
+ uint32_t usecs;
+ for (usecs = results->rawbuf[i] * kRawTick; usecs > UINT16_MAX;
+ usecs -= UINT16_MAX) {
+ output += uint64ToString(UINT16_MAX);
+ if (i % 2)
+ output += ", 0, ";
+ else
+ output += ", 0, ";
+ }
+ output += uint64ToString(usecs, 10);
+ if (i < results->rawlen - 1)
+ output += ", "; // ',' not needed on the last one
+ if (i % 2 == 0) output += " "; // Extra if it was even.
+ }
+
+ // End declaration
+ output += "};";
+
+ // Comment
+ output += " // " + typeToString(results->decode_type, results->repeat);
+ // Only display the value if the decode type doesn't have an A/C state.
+ if (!hasACState(results->decode_type))
+ output += " " + uint64ToString(results->value, 16);
+ output += "\n";
+
+ // Now dump "known" codes
+ if (results->decode_type != UNKNOWN) {
+ if (hasACState(results->decode_type)) {
+#if DECODE_AC
+ uint16_t nbytes = results->bits / 8;
+ output += "uint8_t state[" + uint64ToString(nbytes) + "] = {";
+ for (uint16_t i = 0; i < nbytes; i++) {
+ output += "0x";
+ if (results->state[i] < 0x10) output += "0";
+ output += uint64ToString(results->state[i], 16);
+ if (i < nbytes - 1) output += ", ";
+ }
+ output += "};\n";
+#endif // DECODE_AC
+ } else {
+ // Simple protocols
+ // Some protocols have an address &/or command.
+ // NOTE: It will ignore the atypical case when a message has been
+ // decoded but the address & the command are both 0.
+ if (results->address > 0 || results->command > 0) {
+ output += "uint32_t address = 0x" +
+ uint64ToString(results->address, 16) + ";\n";
+ output += "uint32_t command = 0x" +
+ uint64ToString(results->command, 16) + ";\n";
+ }
+ // Most protocols have data
+ output +=
+ "uint64_t data = 0x" + uint64ToString(results->value, 16) + ";\n";
+ }
+ }
+ return output;
+}
+
+// Dump out the decode_results structure.
+//
+#ifdef ARDUINO
+String resultToTimingInfo(const decode_results *results) {
+ String output = "";
+ String value = "";
+#else
+std::string resultToTimingInfo(const decode_results *results) {
+ std::string output = "";
+ std::string value = "";
+#endif
+ output += "Raw Timing[" + uint64ToString(results->rawlen - 1, 10) + "]:\n";
+
+ for (uint16_t i = 1; i < results->rawlen; i++) {
+ if (i % 2 == 0)
+ output += "-"; // even
+ else
+ output += " +"; // odd
+ value = uint64ToString(results->rawbuf[i] * kRawTick);
+ // Space pad the value till it is at least 6 chars long.
+ while (value.length() < 6) value = " " + value;
+ output += value;
+ if (i < results->rawlen - 1) output += ", "; // ',' not needed for last one
+ if (!(i % 8)) output += "\n"; // Newline every 8 entries.
+ }
+ output += "\n";
+ return output;
+}
+
+// Convert the decode_results structure's value/state to simple hexadecimal.
+//
+#ifdef ARDUINO
+String resultToHexidecimal(const decode_results *result) {
+ String output = "";
+#else
+std::string resultToHexidecimal(const decode_results *result) {
+ std::string output = "";
+#endif
+ if (hasACState(result->decode_type)) {
+#if DECODE_AC
+ for (uint16_t i = 0; result->bits > i * 8; i++) {
+ if (result->state[i] < 0x10) output += "0"; // Zero pad
+ output += uint64ToString(result->state[i], 16);
+ }
+#endif // DECODE_AC
+ } else {
+ output += uint64ToString(result->value, 16);
+ }
+ return output;
+}
+
+// Dump out the decode_results structure.
+//
+#ifdef ARDUINO
+String resultToHumanReadableBasic(const decode_results *results) {
+ String output = "";
+#else
+std::string resultToHumanReadableBasic(const decode_results *results) {
+ std::string output = "";
+#endif
+ // Show Encoding standard
+ output +=
+ "Encoding : " + typeToString(results->decode_type, results->repeat) +
+ "\n";
+
+ // Show Code & length
+ output += "Code : ";
+ output += resultToHexidecimal(results);
+ output += " (" + uint64ToString(results->bits) + " bits)\n";
+ return output;
+}
+
+uint8_t sumBytes(uint8_t *start, const uint16_t length, const uint8_t init) {
+ uint8_t checksum = init;
+ uint8_t *ptr;
+ for (ptr = start; ptr - start < length; ptr++) checksum += *ptr;
+ return checksum;
+}
+
+uint64_t invertBits(const uint64_t data, const uint16_t nbits) {
+ // No change if we are asked to invert no bits.
+ if (nbits == 0) return data;
+ uint64_t result = ~data;
+ // If we are asked to invert all the bits or more than we have, it's simple.
+ if (nbits >= sizeof(data) * 8) return result;
+ // Mask off any unwanted bits and return the result.
+ return (result & ((1ULL << nbits) - 1));
+}
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/IRutils.h b/lib/IRremoteESP8266-2.5.2.03/src/IRutils.h
new file mode 100644
index 000000000000..c17375d98121
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/IRutils.h
@@ -0,0 +1,41 @@
+#ifndef IRUTILS_H_
+#define IRUTILS_H_
+
+// Copyright 2017 David Conran
+
+#ifndef UNIT_TEST
+#include
+#endif
+#define __STDC_LIMIT_MACROS
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRrecv.h"
+
+uint64_t reverseBits(uint64_t input, uint16_t nbits);
+#ifdef ARDUINO // Arduino's & C++'s string implementations can't co-exist.
+String uint64ToString(uint64_t input, uint8_t base = 10);
+String typeToString(const decode_type_t protocol,
+ const bool isRepeat = false);
+void serialPrintUint64(uint64_t input, uint8_t base = 10);
+String resultToSourceCode(const decode_results *results);
+String resultToTimingInfo(const decode_results *results);
+String resultToHumanReadableBasic(const decode_results *results);
+String resultToHexidecimal(const decode_results *result);
+#else
+std::string uint64ToString(uint64_t input, uint8_t base = 10);
+std::string typeToString(const decode_type_t protocol,
+ const bool isRepeat = false);
+std::string resultToSourceCode(const decode_results *results);
+std::string resultToTimingInfo(const decode_results *results);
+std::string resultToHumanReadableBasic(const decode_results *results);
+std::string resultToHexidecimal(const decode_results *result);
+#endif
+bool hasACState(const decode_type_t protocol);
+uint16_t getCorrectedRawLength(const decode_results *results);
+uint8_t sumBytes(uint8_t *start, const uint16_t length, const uint8_t init = 0);
+uint64_t invertBits(const uint64_t data, const uint16_t nbits);
+
+#endif // IRUTILS_H_
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Aiwa.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Aiwa.cpp
similarity index 76%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Aiwa.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Aiwa.cpp
index 99a97e18769e..617711a99f86 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Aiwa.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Aiwa.cpp
@@ -2,7 +2,6 @@
#include "IRrecv.h"
#include "IRsend.h"
-#include "IRtimer.h"
// AAA IIIII W W AAA
// A A I W W A A
@@ -14,20 +13,20 @@
// Added by David Conran. (Inspired by IRremoteESP8266's implementation:
// https://github.com/z3t0/Arduino-IRremote)
-#define AIWA_RC_T501_PRE_BITS 26U
-#define AIWA_RC_T501_POST_BITS 1U
+const uint16_t kAiwaRcT501PreBits = 26;
+const uint16_t kAiwaRcT501PostBits = 1;
// NOTE: These are the compliment (inverted) of lirc values as
// lirc uses a '0' for a mark, and a '1' for a space.
-#define AIWA_RC_T501_PRE_DATA 0x1D8113FULL // 26-bits
-#define AIWA_RC_T501_POST_DATA 1ULL
+const uint64_t kAiwaRcT501PreData = 0x1D8113FULL; // 26-bits
+const uint64_t kAiwaRcT501PostData = 1ULL;
#if SEND_AIWA_RC_T501
-// Send a Aiwa RC T501 formatted message.
+// Send an Aiwa RC T501 formatted message.
//
// Args:
// data: The message to be sent.
// nbits: The number of bits of the message to be sent.
-// Typically AIWA_RC_T501_BITS. Max is 37 = (64 - 27)
+// Typically kAiwaRcT501Bits. Max is 37 = (64 - 27)
// repeat: The number of times the command is to be repeated.
//
// Status: BETA / Should work.
@@ -38,10 +37,9 @@ void IRsend::sendAiwaRCT501(uint64_t data, uint16_t nbits, uint16_t repeat) {
// Appears to be an extended NEC1 protocol. i.e. 42 bits instead of 32 bits.
// So use sendNEC instead, however the twist is it has a fixed 26 bit
// prefix, and a fixed postfix bit.
- uint64_t new_data = (
- (AIWA_RC_T501_PRE_DATA << (nbits + AIWA_RC_T501_POST_BITS)) |
- (data << AIWA_RC_T501_POST_BITS) | AIWA_RC_T501_POST_DATA);
- nbits += AIWA_RC_T501_PRE_BITS + AIWA_RC_T501_POST_BITS;
+ uint64_t new_data = ((kAiwaRcT501PreData << (nbits + kAiwaRcT501PostBits)) |
+ (data << kAiwaRcT501PostBits) | kAiwaRcT501PostData);
+ nbits += kAiwaRcT501PreBits + kAiwaRcT501PostBits;
if (nbits > sizeof(new_data) * 8)
return; // We are overflowing. Abort, and don't send.
sendNEC(new_data, nbits, repeat);
@@ -53,7 +51,7 @@ void IRsend::sendAiwaRCT501(uint64_t data, uint16_t nbits, uint16_t repeat) {
//
// Args:
// results: Ptr to the data to decode and where to store the decode result.
-// nbits: The number of data bits to expect. Typically AIWA_RC_T501_BITS.
+// nbits: The number of data bits to expect. Typically kAiwaRcT501Bits.
// strict: Flag indicating if we should perform strict matching.
// Returns:
// boolean: True if it can decode it, false if it can't.
@@ -72,12 +70,11 @@ void IRsend::sendAiwaRCT501(uint64_t data, uint16_t nbits, uint16_t repeat) {
bool IRrecv::decodeAiwaRCT501(decode_results *results, uint16_t nbits,
bool strict) {
// Compliance
- if (strict && nbits != AIWA_RC_T501_BITS)
+ if (strict && nbits != kAiwaRcT501Bits)
return false; // Doesn't match our protocol defn.
// Add on the pre & post bits to our requested bit length.
- uint16_t expected_nbits = nbits + AIWA_RC_T501_PRE_BITS +
- AIWA_RC_T501_POST_BITS;
+ uint16_t expected_nbits = nbits + kAiwaRcT501PreBits + kAiwaRcT501PostBits;
uint64_t new_data;
if (expected_nbits > sizeof(new_data) * 8)
return false; // We can't possibly match something that big.
@@ -89,24 +86,23 @@ bool IRrecv::decodeAiwaRCT501(decode_results *results, uint16_t nbits,
new_data = results->value;
if (actual_bits < expected_nbits)
return false; // The data we caught was undersized. Throw it back.
- if ((new_data & 0x1ULL) != AIWA_RC_T501_POST_DATA)
+ if ((new_data & 0x1ULL) != kAiwaRcT501PostData)
return false; // The post data doesn't match, so it can't be this protocol.
// Trim off the post data bit.
- new_data >>= AIWA_RC_T501_POST_BITS;
- actual_bits -= AIWA_RC_T501_POST_BITS;
+ new_data >>= kAiwaRcT501PostBits;
+ actual_bits -= kAiwaRcT501PostBits;
// Extract out our likely new value and put it back in the results.
- actual_bits -= AIWA_RC_T501_PRE_BITS;
+ actual_bits -= kAiwaRcT501PreBits;
results->value = new_data & ((1ULL << actual_bits) - 1);
// Check the prefix data matches.
new_data >>= actual_bits; // Trim off the new data to expose the prefix.
- if (new_data != AIWA_RC_T501_PRE_DATA) // Check the prefix.
+ if (new_data != kAiwaRcT501PreData) // Check the prefix.
return false;
// Compliance
- if (strict && results->bits != expected_nbits)
- return false;
+ if (strict && results->bits != expected_nbits) return false;
// Success
results->decode_type = AIWA_RC_T501;
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Argo.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Argo.cpp
similarity index 69%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Argo.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Argo.cpp
index 0129c723144a..8a3e69f72ef8 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Argo.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Argo.cpp
@@ -11,53 +11,40 @@ Copyright 2017 Schmolders
// Constants
// using SPACE modulation. MARK is always const 400u
-#define ARGO_PREAMBLE_1 6400U // Mark
-#define ARGO_PREAMBLE_2 3300U // Space
-#define ARGO_MARK 400U
-#define ARGO_ONE_SPACE 2200U
-#define ARGO_ZERO_SPACE 900U
+const uint16_t kArgoHdrMark = 6400;
+const uint16_t kArgoHdrSpace = 3300;
+const uint16_t kArgoBitMark = 400;
+const uint16_t kArgoOneSpace = 2200;
+const uint16_t kArgoZeroSpace = 900;
#if SEND_ARGO
-// Send a Argo A/C message.
+// Send an Argo A/C message.
//
// Args:
-// data: An array of ARGO_COMMAND_LENGTH bytes containing the IR command.
+// data: An array of kArgoStateLength bytes containing the IR command.
//
// Status: ALPHA / Untested.
-//
-// Overloading the IRSend Function
void IRsend::sendArgo(unsigned char data[], uint16_t nbytes, uint16_t repeat) {
// Check if we have enough bytes to send a proper message.
- if (nbytes < ARGO_COMMAND_LENGTH) return;
- // Set IR carrier frequency
- enableIROut(38);
- for (uint16_t r = 0; r <= repeat; r++) {
- // Header
- // TODO(kaschmo): validate
- mark(ARGO_PREAMBLE_1);
- space(ARGO_PREAMBLE_2);
- // send data, defined in IRSend.cpp
- for (uint16_t i = 0; i < nbytes; i++)
- sendData(ARGO_MARK, ARGO_ONE_SPACE, ARGO_MARK,
- ARGO_ZERO_SPACE, data[i], 8, false);
- // send LSB first reverses the bit order in array for sending.
- }
+ if (nbytes < kArgoStateLength) return;
+ // TODO(kaschmo): validate
+ sendGeneric(kArgoHdrMark, kArgoHdrSpace, kArgoBitMark, kArgoOneSpace,
+ kArgoBitMark, kArgoZeroSpace, 0, 0, // No Footer.
+ data, nbytes, 38, false, repeat, kDutyDefault);
}
+#endif // SEND_ARGO
-IRArgoAC::IRArgoAC(uint16_t pin) : _irsend(pin) {
- stateReset();
-}
+IRArgoAC::IRArgoAC(uint16_t pin) : _irsend(pin) { stateReset(); }
-void IRArgoAC::begin() {
- _irsend.begin();
-}
+void IRArgoAC::begin() { _irsend.begin(); }
+#if SEND_ARGO
void IRArgoAC::send() {
- // Serial.println("Sending IR code"); // Only for Debug
checksum(); // Create valid checksum before sending
_irsend.sendArgo(argo);
}
+#endif // SEND_ARGO
void IRArgoAC::checksum() {
uint8_t sum = 2; // Corresponds to byte 11 being constant 0b01
@@ -65,20 +52,18 @@ void IRArgoAC::checksum() {
// Only add up bytes to 9. byte 10 is 0b01 constant anyway.
// Assume that argo array is MSB first (left)
- for (i = 0; i < 10; i++)
- sum += argo[i];
+ for (i = 0; i < 10; i++) sum += argo[i];
sum = sum % 256; // modulo 256
// Append sum to end of array
// Set const part of checksum bit 10
argo[10] = 0b00000010;
argo[10] += sum << 2; // Shift up 2 bits and append to byte 10
- argo[11] = sum >> 6; // Shift down 6 bits and add in two LSBs of bit 11
+ argo[11] = sum >> 6; // Shift down 6 bits and add in two LSBs of bit 11
}
void IRArgoAC::stateReset() {
- for (uint8_t i = 0; i < ARGO_COMMAND_LENGTH; i++)
- argo[i] = 0x0;
+ for (uint8_t i = 0; i < kArgoStateLength; i++) argo[i] = 0x0;
// Argo Message. Store MSB left.
// Default message:
@@ -91,8 +76,8 @@ void IRArgoAC::stateReset() {
this->off();
this->setTemp(20);
this->setRoomTemp(25);
- this->setCoolMode(ARGO_COOL_AUTO);
- this->setFan(ARGO_FAN_AUTO);
+ this->setCoolMode(kArgoCoolAuto);
+ this->setFan(kArgoFanAuto);
}
uint8_t* IRArgoAC::getRaw() {
@@ -123,9 +108,7 @@ void IRArgoAC::setPower(bool state) {
off();
}
-uint8_t IRArgoAC::getPower() {
- return ac_state;
-}
+uint8_t IRArgoAC::getPower() { return ac_state; }
void IRArgoAC::setMax(bool state) {
max_mode = state;
@@ -135,17 +118,15 @@ void IRArgoAC::setMax(bool state) {
argo[9] &= 0b11110111;
}
-bool IRArgoAC::getMax() {
- return max_mode;
-}
+bool IRArgoAC::getMax() { return max_mode; }
// Set the temp in deg C
// Sending 0 equals +4
void IRArgoAC::setTemp(uint8_t temp) {
- if (temp < ARGO_MIN_TEMP)
- temp = ARGO_MIN_TEMP;
- else if (temp > ARGO_MAX_TEMP)
- temp = ARGO_MAX_TEMP;
+ if (temp < kArgoMinTemp)
+ temp = kArgoMinTemp;
+ else if (temp > kArgoMaxTemp)
+ temp = kArgoMaxTemp;
// Store in attributes
set_temp = temp;
@@ -161,9 +142,7 @@ void IRArgoAC::setTemp(uint8_t temp) {
argo[3] += temp >> 2; // remove lowest to bits and append in 0-2
}
-uint8_t IRArgoAC::getTemp() {
- return set_temp;
-}
+uint8_t IRArgoAC::getTemp() { return set_temp; }
// Set the speed of the fan
void IRArgoAC::setFan(uint8_t fan) {
@@ -175,18 +154,14 @@ void IRArgoAC::setFan(uint8_t fan) {
argo[3] += fan << 3;
}
-uint8_t IRArgoAC::getFan() {
- return fan_mode;
-}
+uint8_t IRArgoAC::getFan() { return fan_mode; }
void IRArgoAC::setFlap(uint8_t flap) {
flap_mode = flap;
// TODO(kaschmo): set correct bits for flap mode
}
-uint8_t IRArgoAC::getFlap() {
- return flap_mode;
-}
+uint8_t IRArgoAC::getFlap() { return flap_mode; }
uint8_t IRArgoAC::getMode() {
// return cooling 0, heating 1
@@ -203,9 +178,7 @@ void IRArgoAC::setCoolMode(uint8_t mode) {
argo[2] += mode << 3;
}
-uint8_t IRArgoAC::getCoolMode() {
- return cool_mode;
-}
+uint8_t IRArgoAC::getCoolMode() { return cool_mode; }
void IRArgoAC::setHeatMode(uint8_t mode) {
ac_mode = 1; // Set ac mode to heating
@@ -218,9 +191,7 @@ void IRArgoAC::setHeatMode(uint8_t mode) {
argo[2] += mode << 3;
}
-uint8_t IRArgoAC::getHeatMode() {
- return heat_mode;
-}
+uint8_t IRArgoAC::getHeatMode() { return heat_mode; }
void IRArgoAC::setNight(bool state) {
night_mode = state;
@@ -231,9 +202,7 @@ void IRArgoAC::setNight(bool state) {
argo[9] &= 0b11111011;
}
-bool IRArgoAC::getNight() {
- return night_mode;
-}
+bool IRArgoAC::getNight() { return night_mode; }
void IRArgoAC::setiFeel(bool state) {
ifeel_mode = state;
@@ -244,9 +213,7 @@ void IRArgoAC::setiFeel(bool state) {
argo[9] &= 0b01111111;
}
-bool IRArgoAC::getiFeel() {
- return ifeel_mode;
-}
+bool IRArgoAC::getiFeel() { return ifeel_mode; }
void IRArgoAC::setTime() {
// TODO(kaschmo): use function call from checksum to set time first
@@ -261,4 +228,3 @@ void IRArgoAC::setRoomTemp(uint8_t temp) {
argo[3] += temp << 5; // Append to bit 5,6,7
argo[4] += temp >> 3; // Remove lowest 3 bits and append in 0,1
}
-#endif // SEND_ARGO
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Argo.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Argo.h
similarity index 51%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Argo.h
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Argo.h
index a25199208d63..b49fc35177cd 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Argo.h
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Argo.h
@@ -29,40 +29,59 @@
// Constants. Store MSB left.
-#define ARGO_COOL_ON 0U // 0b000
-#define ARGO_COOL_OFF 3U // 0b110
-#define ARGO_COOL_AUTO 2U // 0b010
-#define ARGO_COOl_HUM 1U // 0b100
+const uint8_t kArgoCoolOn = 0; // 0b000
+const uint8_t kArgoCoolOff = 3; // 0b110
+const uint8_t kArgoCoolAuto = 2; // 0b010
+const uint8_t kArgoCoolHum = 1; // 0b100
+const uint8_t kArgoHeatOn = 0; // 0b001
+const uint8_t kArgoHeatAuto = 1; // 0b101
+const uint8_t kArgoHeatBlink = 2; // 0b011 // ??no idea what mode that is
+const uint8_t kArgoMinTemp = 10; // Celsius offset +4
+const uint8_t kArgoMaxTemp = 32; // Celsius
+const uint8_t kArgoFanAuto = 0; // 0b00
+const uint8_t kArgoFan3 = 3; // 0b11
+const uint8_t kArgoFan2 = 2; // 0b01
+const uint8_t kArgoFan1 = 1; // 0b10
+const uint8_t kArgoFlapAuto = 0; // 0b000
+const uint8_t kArgoFlap1 = 1; // 0b100
+const uint8_t kArgoFlap2 = 2; // 0b010
+const uint8_t kArgoFlap3 = 3; // 0b110
+const uint8_t kArgoFlap4 = 4; // 0b001
+const uint8_t kArgoFlap5 = 5; // 0b101
+const uint8_t kArgoFlap6 = 6; // 0b011
+const uint8_t kArgoFlapFull = 7; // 0b111
+
+// Legacy defines. (Deperecated)
+#define ARGO_COOL_ON kArgoCoolOn
+#define ARGO_COOL_OFF kArgoCoolOff
+#define ARGO_COOL_AUTO kArgoCoolAuto
+#define ARGO_COOl_HUM kArgoCoolHum
+#define ARGO_HEAT_ON kArgoHeatOn
+#define ARGO_HEAT_AUTO kArgoHeatAuto
+#define ARGO_HEAT_BLINK kArgoHeatBlink
+#define ARGO_MIN_TEMP kArgoMinTemp
+#define ARGO_MAX_TEMP kArgoMaxTemp
+#define ARGO_FAN_AUTO kArgoFanAuto
+#define ARGO_FAN_3 kArgoFan3
+#define ARGO_FAN_2 kArgoFan2
+#define ARGO_FAN_1 kArgoFan1
+#define ARGO_FLAP_AUTO kArgoFlapAuto
+#define ARGO_FLAP_1 kArgoFlap1
+#define ARGO_FLAP_2 kArgoFlap2
+#define ARGO_FLAP_3 kArgoFlap3
+#define ARGO_FLAP_4 kArgoFlap4
+#define ARGO_FLAP_5 kArgoFlap5
+#define ARGO_FLAP_6 kArgoFlap6
+#define ARGO_FLAP_FULL kArgoFlapFull
-#define ARGO_HEAT_ON 0U // 0b001
-#define ARGO_HEAT_AUTO 1U // 0b101
-#define ARGO_HEAT_BLINK 2U // 0b011 // ??no idea what mode that is
-
-#define ARGO_MIN_TEMP 10U // Celsius offset +4
-#define ARGO_MAX_TEMP 32U // Celsius
-
-#define ARGO_FAN_AUTO 0U // 0b00
-#define ARGO_FAN_3 3U // 0b11
-#define ARGO_FAN_2 2U // 0b01
-#define ARGO_FAN_1 1U // 0b10
-
-#define ARGO_FLAP_AUTO 0U // 0b000
-#define ARGO_FLAP_1 1U // 0b100
-#define ARGO_FLAP_2 2U // 0b010
-#define ARGO_FLAP_3 3U // 0b110
-#define ARGO_FLAP_4 4U // 0b001
-#define ARGO_FLAP_5 5U // 0b101
-#define ARGO_FLAP_6 6U // 0b011
-#define ARGO_FLAP_FULL 7U // 0b111
-
-
-#if SEND_ARGO
class IRArgoAC {
public:
explicit IRArgoAC(uint16_t pin);
+#if SEND_ARGO
void send();
+#endif // SEND_ARGO
void begin();
void on();
void off();
@@ -102,7 +121,7 @@ class IRArgoAC {
private:
// # of bytes per command
- uint8_t argo[ARGO_COMMAND_LENGTH]; // Defined in IRremoteESP8266.h
+ uint8_t argo[kArgoStateLength]; // Defined in IRremoteESP8266.h
void stateReset();
void checksum();
IRsend _irsend; // instance of the IR send class
@@ -119,6 +138,5 @@ class IRArgoAC {
uint8_t max_mode; // on/off
uint8_t ifeel_mode; // on/off
};
-#endif // SEND_ARGO
#endif // IR_ARGO_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Carrier.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Carrier.cpp
new file mode 100644
index 000000000000..350d61cc1ec3
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Carrier.cpp
@@ -0,0 +1,111 @@
+// Copyright 2018 David Conran
+
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// CCCCC AAA RRRRRR RRRRRR IIIII EEEEEEE RRRRRR
+// CC C AAAAA RR RR RR RR III EE RR RR
+// CC AA AA RRRRRR RRRRRR III EEEEE RRRRRR
+// CC C AAAAAAA RR RR RR RR III EE RR RR
+// CCCCC AA AA RR RR RR RR IIIII EEEEEEE RR RR
+
+// Suits Carrier/Surrey HVAC models:
+// 42QG5A55970 (remote)
+// 619EGX0090E0 / 619EGX0120E0 / 619EGX0180E0 / 619EGX0220E0 (indoor units)
+// 53NGK009/012 (inverter)
+
+// Constants
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/385
+const uint16_t kCarrierAcHdrMark = 8532;
+const uint16_t kCarrierAcHdrSpace = 4228;
+const uint16_t kCarrierAcBitMark = 628;
+const uint16_t kCarrierAcOneSpace = 1320;
+const uint16_t kCarrierAcZeroSpace = 532;
+const uint16_t kCarrierAcGap = 20000;
+
+#if SEND_CARRIER_AC
+// Send a Carrier HVAC formatted message.
+//
+// Args:
+// data: The message to be sent.
+// nbits: The bit size of the message being sent. typically kCarrierAcBits.
+// repeat: The number of times the message is to be repeated.
+//
+// Status: BETA / Appears to work on real devices.
+//
+void IRsend::sendCarrierAC(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ for (uint16_t r = 0; r <= repeat; r++) {
+ uint64_t temp_data = data;
+ // Carrier sends the data block three times. normal + inverted + normal.
+ for (uint16_t i = 0; i < 3; i++) {
+ sendGeneric(kCarrierAcHdrMark, kCarrierAcHdrSpace, kCarrierAcBitMark,
+ kCarrierAcOneSpace, kCarrierAcBitMark, kCarrierAcZeroSpace,
+ kCarrierAcBitMark, kCarrierAcGap, temp_data, nbits, 38, true,
+ 0, kDutyDefault);
+ temp_data = invertBits(temp_data, nbits);
+ }
+ }
+}
+#endif
+
+#if DECODE_CARRIER_AC
+// Decode the supplied Carrier HVAC message.
+// Carrier HVAC messages contain only 32 bits, but it is sent three(3) times.
+// i.e. normal + inverted + normal
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of bits to expect in the data portion.
+// Typically kCarrierAcBits.
+// strict: Flag to indicate if we strictly adhere to the specification.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: ALPHA / Untested.
+//
+bool IRrecv::decodeCarrierAC(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < ((2 * nbits + kHeader + kFooter) * 3) - 1)
+ return false; // Can't possibly be a valid Carrier message.
+ if (strict && nbits != kCarrierAcBits)
+ return false; // We expect Carrier to be 32 bits of message.
+
+ uint64_t data = 0;
+ uint64_t prev_data = 0;
+ uint16_t offset = kStartOffset;
+
+ for (uint8_t i = 0; i < 3; i++) {
+ prev_data = data;
+ // Header
+ if (!matchMark(results->rawbuf[offset++], kCarrierAcHdrMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kCarrierAcHdrSpace))
+ return false;
+ // Data
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), nbits, kCarrierAcBitMark,
+ kCarrierAcOneSpace, kCarrierAcBitMark, kCarrierAcZeroSpace);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kCarrierAcBitMark)) return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kCarrierAcGap))
+ return false;
+ // Compliance.
+ if (strict) {
+ // Check if the data is an inverted copy of the previous data.
+ if (i > 0 && prev_data != invertBits(data, nbits)) return false;
+ }
+ }
+
+ // Success
+ results->bits = nbits;
+ results->value = data;
+ results->decode_type = CARRIER_AC;
+ results->address = data >> 16;
+ results->command = data & 0xFFFF;
+ return true;
+}
+#endif
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Coolix.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Coolix.cpp
new file mode 100644
index 000000000000..ee539af25660
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Coolix.cpp
@@ -0,0 +1,423 @@
+// Copyright bakrus
+// Copyright 2017 David Conran
+
+#include "ir_Coolix.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// CCCCC OOOOO OOOOO LL IIIII XX XX
+// CC C OO OO OO OO LL III XX XX
+// CC OO OO OO OO LL III XXXX
+// CC C OO OO OO OO LL III XX XX
+// CCCCC OOOO0 OOOO0 LLLLLLL IIIII XX XX
+
+// Coolix A/C / heatpump added by (send) bakrus & (decode) crankyoldgit
+//
+// Supports:
+// RG57K7(B)/BGEF remote control for Beko BINR 070/071 split-type aircon.
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/484
+
+// Constants
+// Pulse parms are *50-100 for the Mark and *50+100 for the space
+// First MARK is the one after the long gap
+// pulse parameters in usec
+const uint16_t kCoolixTick = 560; // Approximately 21 cycles at 38kHz
+const uint16_t kCoolixBitMarkTicks = 1;
+const uint16_t kCoolixBitMark = kCoolixBitMarkTicks * kCoolixTick;
+const uint16_t kCoolixOneSpaceTicks = 3;
+const uint16_t kCoolixOneSpace = kCoolixOneSpaceTicks * kCoolixTick;
+const uint16_t kCoolixZeroSpaceTicks = 1;
+const uint16_t kCoolixZeroSpace = kCoolixZeroSpaceTicks * kCoolixTick;
+const uint16_t kCoolixHdrMarkTicks = 8;
+const uint16_t kCoolixHdrMark = kCoolixHdrMarkTicks * kCoolixTick;
+const uint16_t kCoolixHdrSpaceTicks = 8;
+const uint16_t kCoolixHdrSpace = kCoolixHdrSpaceTicks * kCoolixTick;
+const uint16_t kCoolixMinGapTicks = kCoolixHdrMarkTicks + kCoolixZeroSpaceTicks;
+const uint16_t kCoolixMinGap = kCoolixMinGapTicks * kCoolixTick;
+
+#if SEND_COOLIX
+// Send a Coolix message
+//
+// Args:
+// data: Contents of the message to be sent.
+// nbits: Nr. of bits of data to be sent. Typically kCoolixBits.
+// repeat: Nr. of additional times the message is to be sent.
+//
+// Status: BETA / Probably works.
+//
+// Ref:
+// https://github.com/z3t0/Arduino-IRremote/blob/master/ir_COOLIX.cpp
+// TODO(anyone): Verify repeat functionality against a real unit.
+void IRsend::sendCOOLIX(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ if (nbits % 8 != 0) return; // nbits is required to be a multiple of 8.
+
+ // Set IR carrier frequency
+ enableIROut(38);
+
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // Header
+ mark(kCoolixHdrMark);
+ space(kCoolixHdrSpace);
+
+ // Data
+ // Break data into byte segments, starting at the Most Significant
+ // Byte. Each byte then being sent normal, then followed inverted.
+ for (uint16_t i = 8; i <= nbits; i += 8) {
+ // Grab a bytes worth of data.
+ uint8_t segment = (data >> (nbits - i)) & 0xFF;
+ // Normal
+ sendData(kCoolixBitMark, kCoolixOneSpace, kCoolixBitMark,
+ kCoolixZeroSpace, segment, 8, true);
+ // Inverted.
+ sendData(kCoolixBitMark, kCoolixOneSpace, kCoolixBitMark,
+ kCoolixZeroSpace, segment ^ 0xFF, 8, true);
+ }
+
+ // Footer
+ mark(kCoolixBitMark);
+ space(kCoolixMinGap); // Pause before repeating
+ }
+}
+#endif
+
+// IRCoolixAC class
+// Supports:
+// RG57K7(B)/BGEF remote control for Beko BINR 070/071 split-type aircon.
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/484
+IRCoolixAC::IRCoolixAC(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRCoolixAC::stateReset() { remote_state = kCoolixDefaultState; }
+
+void IRCoolixAC::begin() { _irsend.begin(); }
+
+#if SEND_COOLIX
+void IRCoolixAC::send() { _irsend.sendCOOLIX(remote_state); }
+#endif // SEND_COOLIX
+
+uint32_t IRCoolixAC::getRaw() { return remote_state; }
+
+void IRCoolixAC::setRaw(const uint32_t new_code) { remote_state = new_code; }
+
+void IRCoolixAC::setTempRaw(const uint8_t code) {
+ remote_state &= ~kCoolixTempMask; // Clear the old temp.
+ remote_state |= (code << 4);
+}
+
+uint8_t IRCoolixAC::getTempRaw() {
+ return (remote_state & kCoolixTempMask) >> 4;
+}
+
+void IRCoolixAC::setTemp(const uint8_t desired) {
+ // Range check.
+ uint8_t temp = std::min(desired, kCoolixTempMax);
+ temp = std::max(temp, kCoolixTempMin);
+ setTempRaw(kCoolixTempMap[temp - kCoolixTempMin]);
+}
+
+uint8_t IRCoolixAC::getTemp() {
+ uint8_t code = getTempRaw();
+ uint8_t i;
+ for (i = 0; i < kCoolixTempRange; i++)
+ if (kCoolixTempMap[i] == code) return kCoolixTempMin + i;
+ return kCoolixUnknown; // Not a temp we expected.
+}
+
+void IRCoolixAC::setSensorTempRaw(const uint8_t code) {
+ remote_state &= ~kCoolixSensorTempMask; // Clear previous sensor temp.
+ remote_state |= ((code & 0xF) << 8);
+}
+
+void IRCoolixAC::setSensorTemp(const uint8_t desired) {
+ uint8_t temp = desired;
+ temp = std::min(temp, kCoolixSensorTempMax);
+ temp = std::max(temp, kCoolixSensorTempMin);
+ setSensorTempRaw(temp - kCoolixSensorTempMin);
+ setZoneFollow(true); // Setting a Sensor temp means you want to Zone Follow.
+}
+
+uint8_t IRCoolixAC::getSensorTemp() {
+ return ((remote_state & kCoolixSensorTempMask) >> 8) + kCoolixSensorTempMin;
+}
+
+bool IRCoolixAC::getPower() {
+ // There is only an off state. Everything else is "on".
+ return remote_state != kCoolixOff;
+}
+
+void IRCoolixAC::setPower(const bool power) {
+ if (!power) remote_state = kCoolixOff;
+ // There really is no distinct "on" setting, so do nothing.
+}
+
+bool IRCoolixAC::getSwing() { return remote_state == kCoolixSwing; }
+
+void IRCoolixAC::setSwing() {
+ // Assumes that repeated sending "swing" toggles the action on the device.
+ remote_state = kCoolixSwing;
+}
+
+bool IRCoolixAC::getSleep() { return remote_state == kCoolixSleep; }
+
+void IRCoolixAC::setSleep() { remote_state = kCoolixSleep; }
+
+bool IRCoolixAC::getTurbo() { return remote_state == kCoolixTurbo; }
+
+void IRCoolixAC::setTurbo() {
+ // Assumes that repeated sending "turbo" toggles the action on the device.
+ remote_state = kCoolixTurbo;
+}
+
+bool IRCoolixAC::getLed() { return remote_state == kCoolixLed; }
+
+void IRCoolixAC::setLed() {
+ // Assumes that repeated sending "Led" toggles the action on the device.
+ remote_state = kCoolixLed;
+}
+
+bool IRCoolixAC::getClean() { return remote_state == kCoolixClean; }
+
+void IRCoolixAC::setClean() { remote_state = kCoolixClean; }
+
+bool IRCoolixAC::getZoneFollow() {
+ return remote_state & kCoolixZoneFollowMask;
+}
+
+// Internal use only.
+void IRCoolixAC::setZoneFollow(bool state) {
+ if (state) {
+ remote_state |= kCoolixZoneFollowMask;
+ } else {
+ remote_state &= ~kCoolixZoneFollowMask;
+ }
+}
+
+void IRCoolixAC::clearSensorTemp() {
+ setZoneFollow(false);
+ setSensorTempRaw(kCoolixSensorTempIgnoreCode);
+}
+
+void IRCoolixAC::setMode(const uint8_t mode) {
+ uint32_t actualmode = mode;
+ // Fan mode is a special case of Dry.
+ if (mode == kCoolixFan) actualmode = kCoolixDry;
+ switch (actualmode) {
+ case kCoolixCool:
+ case kCoolixAuto:
+ case kCoolixHeat:
+ case kCoolixDry:
+ remote_state = (remote_state & ~kCoolixModeMask) | (actualmode << 2);
+ // Force the temp into a known-good state.
+ setTemp(getTemp());
+ }
+ if (mode == kCoolixFan) setTempRaw(kCoolixFanTempCode);
+}
+
+uint8_t IRCoolixAC::getMode() {
+ uint8_t mode = (remote_state & kCoolixModeMask) >> 2;
+ if (mode == kCoolixDry)
+ if (getTempRaw() == kCoolixFanTempCode) return kCoolixFan;
+ return mode;
+}
+
+uint8_t IRCoolixAC::getFan() { return (remote_state & kCoolixFanMask) >> 13; }
+
+void IRCoolixAC::setFan(const uint8_t speed) {
+ uint8_t newspeed = speed;
+ switch (speed) {
+ case kCoolixFanMin:
+ case kCoolixFanMed:
+ case kCoolixFanMax:
+ case kCoolixFanAuto:
+ case kCoolixFanZoneFollow:
+ case kCoolixFanFixed:
+ break;
+ default: // Unknown speed requested.
+ newspeed = kCoolixFanAuto;
+ }
+ remote_state &= ~kCoolixFanMask;
+ remote_state |= ((newspeed << 13) & kCoolixFanMask);
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRCoolixAC::toString() {
+ String result = "";
+#else
+std::string IRCoolixAC::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower()) {
+ result += "On";
+ } else {
+ result += "Off";
+ return result; // If it's off, there is no other info.
+ }
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kCoolixFanAuto:
+ result += " (AUTO)";
+ break;
+ case kCoolixFanMax:
+ result += " (MAX)";
+ break;
+ case kCoolixFanMin:
+ result += " (MIN)";
+ break;
+ case kCoolixFanMed:
+ result += " (MED)";
+ break;
+ case kCoolixFanZoneFollow:
+ result += " (ZONEFOLLOW)";
+ break;
+ case kCoolixFanFixed:
+ result += " (FIXED)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ // Special modes.
+ if (getSwing()) {
+ result += ", Swing: Toggle";
+ return result;
+ }
+ if (getSleep()) {
+ result += ", Sleep: Toggle";
+ return result;
+ }
+ if (getTurbo()) {
+ result += ", Turbo: Toggle";
+ return result;
+ }
+ if (getLed()) {
+ result += ", Led: Toggle";
+ return result;
+ }
+ if (getClean()) {
+ result += ", Mode: Self clean";
+ return result;
+ }
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kCoolixAuto:
+ result += " (AUTO)";
+ break;
+ case kCoolixCool:
+ result += " (COOL)";
+ break;
+ case kCoolixHeat:
+ result += " (HEAT)";
+ break;
+ case kCoolixDry:
+ result += " (DRY)";
+ break;
+ case kCoolixFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ if (getMode() != kCoolixFan) // Fan mode doesn't have a temperature.
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Zone Follow: ";
+ if (getZoneFollow())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Sensor Temp: ";
+ if (getSensorTemp() > kCoolixSensorTempMax)
+ result += "Ignored";
+ else
+ result += uint64ToString(getSensorTemp()) + "C";
+ return result;
+}
+
+#if DECODE_COOLIX
+// Decode the supplied Coolix message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kCoolixBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Probably working.
+bool IRrecv::decodeCOOLIX(decode_results *results, uint16_t nbits,
+ bool strict) {
+ // The protocol sends the data normal + inverted, alternating on
+ // each byte. Hence twice the number of expected data bits.
+ if (results->rawlen < 2 * 2 * nbits + kHeader + kFooter - 1)
+ return false; // Can't possibly be a valid COOLIX message.
+ if (strict && nbits != kCoolixBits)
+ return false; // Not strictly a COOLIX message.
+ if (nbits % 8 != 0) // nbits has to be a multiple of nr. of bits in a byte.
+ return false;
+
+ uint64_t data = 0;
+ uint64_t inverted = 0;
+ uint16_t offset = kStartOffset;
+
+ if (nbits > sizeof(data) * 8)
+ return false; // We can't possibly capture a Coolix packet that big.
+
+ // Header
+ if (!matchMark(results->rawbuf[offset], kCoolixHdrMark)) return false;
+ // Calculate how long the common tick time is based on the header mark.
+ uint32_t m_tick = results->rawbuf[offset++] * kRawTick / kCoolixHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kCoolixHdrSpace)) return false;
+ // Calculate how long the common tick time is based on the header space.
+ uint32_t s_tick = results->rawbuf[offset++] * kRawTick / kCoolixHdrSpaceTicks;
+
+ // Data
+ // Twice as many bits as there are normal plus inverted bits.
+ for (uint16_t i = 0; i < nbits * 2; i++, offset++) {
+ bool flip = (i / 8) % 2;
+ if (!matchMark(results->rawbuf[offset++], kCoolixBitMarkTicks * m_tick))
+ return false;
+ if (matchSpace(results->rawbuf[offset], kCoolixOneSpaceTicks * s_tick)) {
+ if (flip)
+ inverted = (inverted << 1) | 1;
+ else
+ data = (data << 1) | 1;
+ } else if (matchSpace(results->rawbuf[offset],
+ kCoolixZeroSpaceTicks * s_tick)) {
+ if (flip)
+ inverted <<= 1;
+ else
+ data <<= 1;
+ } else {
+ return false;
+ }
+ }
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kCoolixBitMarkTicks * m_tick))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kCoolixMinGapTicks * s_tick))
+ return false;
+
+ // Compliance
+ uint64_t orig = data; // Save a copy of the data.
+ if (strict) {
+ for (uint16_t i = 0; i < nbits; i += 8, data >>= 8, inverted >>= 8)
+ if ((data & 0xFF) != ((inverted & 0xFF) ^ 0xFF)) return false;
+ }
+
+ // Success
+ results->decode_type = COOLIX;
+ results->bits = nbits;
+ results->value = orig;
+ results->address = 0;
+ results->command = 0;
+ return true;
+}
+#endif
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Coolix.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Coolix.h
new file mode 100644
index 000000000000..ee455207485c
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Coolix.h
@@ -0,0 +1,139 @@
+// Coolix A/C
+//
+// Copyright 2018 David Conran
+
+#ifndef IR_COOLIX_H_
+#define IR_COOLIX_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifndef UNIT_TEST
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// CCCCC OOOOO OOOOO LL IIIII XX XX
+// CC C OO OO OO OO LL III XX XX
+// CC OO OO OO OO LL III XXXX
+// CC C OO OO OO OO LL III XX XX
+// CCCCC OOOO0 OOOO0 LLLLLLL IIIII XX XX
+
+// Supports:
+// RG57K7(B)/BGEF remote control for Beko BINR 070/071 split-type aircon.
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/484
+// Kudos:
+// Hamper: For the breakdown and mapping of the bit values.
+
+// Constants
+// Modes
+const uint8_t kCoolixCool = 0b00;
+const uint8_t kCoolixDry = 0b01;
+const uint8_t kCoolixAuto = 0b10;
+const uint8_t kCoolixHeat = 0b11;
+const uint8_t kCoolixFan = 4; // Synthetic.
+const uint32_t kCoolixModeMask = 0b000000000000000000001100; // 0xC
+const uint32_t kCoolixZoneFollowMask = 0b000010000000000000000000; // 0x80000
+// Fan Control
+const uint8_t kCoolixFanMin = 0b100;
+const uint8_t kCoolixFanMed = 0b010;
+const uint8_t kCoolixFanMax = 0b001;
+const uint8_t kCoolixFanAuto = 0b101;
+const uint8_t kCoolixFanZoneFollow = 0b110;
+const uint8_t kCoolixFanFixed = 0b111;
+const uint32_t kCoolixFanMask = 0b000000001110000000000000; // 0x00E000
+// Temperature
+const uint8_t kCoolixTempMin = 17; // Celsius
+const uint8_t kCoolixTempMax = 30; // Celsius
+const uint8_t kCoolixTempRange = kCoolixTempMax - kCoolixTempMin + 1;
+const uint8_t kCoolixFanTempCode = 0b1110; // Part of Fan Mode.
+const uint32_t kCoolixTempMask = 0b11110000;
+const uint8_t kCoolixTempMap[kCoolixTempRange] = {
+ 0b0000, // 17C
+ 0b0001, // 18c
+ 0b0011, // 19C
+ 0b0010, // 20C
+ 0b0110, // 21C
+ 0b0111, // 22C
+ 0b0101, // 23C
+ 0b0100, // 24C
+ 0b1100, // 25C
+ 0b1101, // 26C
+ 0b1001, // 27C
+ 0b1000, // 28C
+ 0b1010, // 29C
+ 0b1011 // 30C
+};
+const uint8_t kCoolixSensorTempMin = 16; // Celsius
+const uint8_t kCoolixSensorTempMax = 30; // Celsius
+const uint8_t kCoolixSensorTempIgnoreCode = 0b1111;
+const uint32_t kCoolixSensorTempMask = 0b000000000000111100000000; // 0xF00
+// Fixed states/messages.
+const uint8_t kCoolixPrefix = 0b1011; // 0xB
+const uint8_t kCoolixUnknown = 0xFF;
+const uint32_t kCoolixOff = 0b101100100111101111100000; // 0xB27BE0
+const uint32_t kCoolixSwing = 0b101100100110101111100000; // 0xB26BE0
+const uint32_t kCoolixSleep = 0b101100101110000000000011; // 0xB2E003
+const uint32_t kCoolixTurbo = 0b101101011111010110100010; // 0xB5F5A2
+const uint32_t kCoolixLed = 0b101101011111010110100101; // 0xB5F5A5
+const uint32_t kCoolixClean = 0b101101011111010110101010; // 0xB5F5AA
+// On, 25C, Mode: Auto, Fan: Auto, Zone Follow: Off, Sensor Temp: Ignore.
+const uint32_t kCoolixDefaultState = 0b101100101011111111001000; // 0xB2BFC8
+
+// Classes
+class IRCoolixAC {
+ public:
+ explicit IRCoolixAC(uint16_t pin);
+
+ void stateReset();
+#if SEND_COOLIX
+ void send();
+#endif // SEND_COOLIX
+ void begin();
+ void on();
+ void off();
+ void setPower(const bool state);
+ bool getPower();
+ void setTemp(const uint8_t temp);
+ uint8_t getTemp();
+ void setSensorTemp(const uint8_t desired);
+ uint8_t getSensorTemp();
+ void clearSensorTemp();
+ void setFan(const uint8_t fan);
+ uint8_t getFan();
+ void setMode(const uint8_t mode);
+ uint8_t getMode();
+ void setSwing();
+ bool getSwing();
+ void setSleep();
+ bool getSleep();
+ void setTurbo();
+ bool getTurbo();
+ void setLed();
+ bool getLed();
+ void setClean();
+ bool getClean();
+ bool getZoneFollow();
+ uint32_t getRaw();
+ void setRaw(const uint32_t new_code);
+
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
+
+ private:
+ // The state of the IR remote in IR code form.
+ uint32_t remote_state;
+ IRsend _irsend;
+ void setTempRaw(const uint8_t code);
+ uint8_t getTempRaw();
+ void setSensorTempRaw(const uint8_t code);
+ void setZoneFollow(const bool state);
+};
+
+#endif // IR_COOLIX_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Daikin.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Daikin.cpp
new file mode 100644
index 000000000000..b94b4a63aa00
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Daikin.cpp
@@ -0,0 +1,750 @@
+/*
+An Arduino sketch to emulate IR Daikin ARC433** remote control unit
+Read more at:
+http://harizanov.com/2012/02/control-daikin-air-conditioner-over-the-internet/
+
+Copyright 2016 sillyfrog
+Copyright 2017 sillyfrog, crankyoldgit
+*/
+
+#include "ir_Daikin.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// DDDDD AAA IIIII KK KK IIIII NN NN
+// DD DD AAAAA III KK KK III NNN NN
+// DD DD AA AA III KKKK III NN N NN
+// DD DD AAAAAAA III KK KK III NN NNN
+// DDDDDD AA AA IIIII KK KK IIIII NN NN
+
+// Constants
+// Ref:
+// https://github.com/mharizanov/Daikin-AC-remote-control-over-the-Internet/tree/master/IRremote
+// http://rdlab.cdmt.vn/project-2013/daikin-ir-protocol
+
+#if SEND_DAIKIN
+// Original header
+// static uint8_t header1[DAIKIN_HEADER1_LENGTH];
+// header1[0] = 0b00010001;
+// header1[1] = 0b11011010;
+// header1[2] = 0b00100111;
+// header1[3] = 0b00000000;
+// header1[4] = 0b11000101;
+// header1[5] = 0b00000000;
+// header1[6] = 0b00000000;
+// header1[7] = 0b11010111;
+
+// Send a Daikin A/C message.
+//
+// Args:
+// data: An array of kDaikinStateLength bytes containing the IR command.
+//
+// Status: STABLE
+//
+// Ref:
+// IRDaikinESP.cpp
+// https://github.com/mharizanov/Daikin-AC-remote-control-over-the-Internet/tree/master/IRremote
+void IRsend::sendDaikin(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kDaikinStateLength)
+ return; // Not enough bytes to send a proper message.
+
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // Send the header, 0b00000
+ sendGeneric(0, 0, // No header for the header
+ kDaikinBitMark, kDaikinOneSpace, kDaikinBitMark,
+ kDaikinZeroSpace, kDaikinBitMark, kDaikinZeroSpace + kDaikinGap,
+ (uint64_t)0b00000, 5, 38, false, 0, 50);
+ // Leading header
+ // Do this as a constant to save RAM and keep in flash memory
+ sendGeneric(kDaikinHdrMark, kDaikinHdrSpace, kDaikinBitMark,
+ kDaikinOneSpace, kDaikinBitMark, kDaikinZeroSpace,
+ kDaikinBitMark, kDaikinZeroSpace + kDaikinGap,
+ kDaikinFirstHeader64, 64, 38, false, 0, 50);
+ // Data #1
+ sendGeneric(kDaikinHdrMark, kDaikinHdrSpace, kDaikinBitMark,
+ kDaikinOneSpace, kDaikinBitMark, kDaikinZeroSpace,
+ kDaikinBitMark, kDaikinZeroSpace + kDaikinGap, data, 8, 38,
+ false, 0, 50);
+ // Data #2
+ sendGeneric(kDaikinHdrMark, kDaikinHdrSpace, kDaikinBitMark,
+ kDaikinOneSpace, kDaikinBitMark, kDaikinZeroSpace,
+ kDaikinBitMark, kDaikinZeroSpace + kDaikinGap, data + 8,
+ nbytes - 8, 38, false, 0, 50);
+ }
+}
+#endif // SEND_DAIKIN
+
+IRDaikinESP::IRDaikinESP(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRDaikinESP::begin() { _irsend.begin(); }
+
+#if SEND_DAIKIN
+void IRDaikinESP::send() {
+ checksum();
+ _irsend.sendDaikin(daikin);
+}
+#endif // SEND_DAIKIN
+
+// Calculate the checksum for a given data block.
+// Args:
+// block: Ptr to the start of the data block.
+// length: Nr. of bytes to checksum.
+// Returns:
+// A byte containing the calculated checksum.
+uint8_t IRDaikinESP::calcBlockChecksum(const uint8_t *block,
+ const uint16_t length) {
+ uint8_t sum = 0;
+ // Daikin checksum is just the addition of all the data bytes
+ // in the block but capped to 8 bits.
+ for (uint16_t i = 0; i < length; i++, block++) sum += *block;
+ return sum & 0xFFU;
+}
+
+// Verify the checksum is valid for a given state.
+// Args:
+// state: The array to verify the checksum of.
+// length: The size of the state.
+// Returns:
+// A boolean.
+bool IRDaikinESP::validChecksum(const uint8_t state[], const uint16_t length) {
+ if (length < 8 || state[7] != calcBlockChecksum(state, 7)) return false;
+ if (length < 10 ||
+ state[length - 1] != calcBlockChecksum(state + 8, length - 9))
+ return false;
+ return true;
+}
+
+// Calculate and set the checksum values for the internal state.
+void IRDaikinESP::checksum() {
+ daikin[7] = calcBlockChecksum(daikin, 7);
+ daikin[26] = calcBlockChecksum(daikin + 8, 17);
+}
+
+void IRDaikinESP::stateReset() {
+ for (uint8_t i = 0; i < kDaikinStateLength; i++) daikin[i] = 0x0;
+
+ daikin[0] = 0x11;
+ daikin[1] = 0xDA;
+ daikin[2] = 0x27;
+ daikin[4] = 0x42;
+ // daikin[7] is a checksum byte, it will be set by checksum().
+ daikin[8] = 0x11;
+ daikin[9] = 0xDA;
+ daikin[10] = 0x27;
+ daikin[13] = 0x49;
+ daikin[14] = 0x1E;
+ daikin[16] = 0xB0;
+ daikin[19] = 0x06;
+ daikin[20] = 0x60;
+ daikin[23] = 0xC0;
+ // daikin[26] is a checksum byte, it will be set by checksum().
+ checksum();
+}
+
+uint8_t *IRDaikinESP::getRaw() {
+ checksum(); // Ensure correct settings before sending.
+ return daikin;
+}
+
+void IRDaikinESP::setRaw(uint8_t new_code[]) {
+ for (uint8_t i = 0; i < kDaikinStateLength; i++) daikin[i] = new_code[i];
+}
+
+void IRDaikinESP::on() {
+ // state = ON;
+ setBit(kDaikinBytePower, kDaikinBitPower);
+}
+
+void IRDaikinESP::off() {
+ // state = OFF;
+ clearBit(kDaikinBytePower, kDaikinBitPower);
+}
+
+void IRDaikinESP::setPower(bool state) {
+ if (state)
+ on();
+ else
+ off();
+}
+
+bool IRDaikinESP::getPower() {
+ return (getBit(kDaikinBytePower, kDaikinBitPower) > 0);
+}
+
+// Set the temp in deg C
+void IRDaikinESP::setTemp(uint8_t temp) {
+ if (temp < kDaikinMinTemp)
+ temp = kDaikinMinTemp;
+ else if (temp > kDaikinMaxTemp)
+ temp = kDaikinMaxTemp;
+ daikin[14] = temp * 2;
+}
+
+uint8_t IRDaikinESP::getTemp() { return daikin[14] / 2; }
+
+// Set the speed of the fan, 1-5 or kDaikinFanAuto or kDaikinFanQuiet
+void IRDaikinESP::setFan(uint8_t fan) {
+ // Set the fan speed bits, leave low 4 bits alone
+ uint8_t fanset;
+ if (fan == kDaikinFanQuiet || fan == kDaikinFanAuto)
+ fanset = fan;
+ else if (fan < kDaikinFanMin || fan > kDaikinFanMax)
+ fanset = kDaikinFanAuto;
+ else
+ fanset = 2 + fan;
+ daikin[16] &= 0x0F;
+ daikin[16] |= (fanset << 4);
+}
+
+uint8_t IRDaikinESP::getFan() {
+ uint8_t fan = daikin[16] >> 4;
+ if (fan != kDaikinFanQuiet && fan != kDaikinFanAuto) fan -= 2;
+ return fan;
+}
+
+uint8_t IRDaikinESP::getMode() {
+ /*
+ kDaikinCool
+ kDaikinHeat
+ kDaikinFan
+ kDaikinAuto
+ kDaikinDry
+ */
+ return daikin[13] >> 4;
+}
+
+void IRDaikinESP::setMode(uint8_t mode) {
+ switch (mode) {
+ case kDaikinCool:
+ case kDaikinHeat:
+ case kDaikinFan:
+ case kDaikinDry:
+ break;
+ default:
+ mode = kDaikinAuto;
+ }
+ mode <<= 4;
+ daikin[13] &= 0b10001111;
+ daikin[13] |= mode;
+}
+
+void IRDaikinESP::setSwingVertical(bool state) {
+ if (state)
+ daikin[16] |= 0x0F;
+ else
+ daikin[16] &= 0xF0;
+}
+
+bool IRDaikinESP::getSwingVertical() { return daikin[16] & 0x01; }
+
+void IRDaikinESP::setSwingHorizontal(bool state) {
+ if (state)
+ daikin[17] |= 0x0F;
+ else
+ daikin[17] &= 0xF0;
+}
+
+bool IRDaikinESP::getSwingHorizontal() { return daikin[17] & 0x01; }
+
+void IRDaikinESP::setQuiet(bool state) {
+ if (state) {
+ setBit(kDaikinByteSilent, kDaikinBitSilent);
+ // Powerful & Quiet mode being on are mutually exclusive.
+ setPowerful(false);
+ } else {
+ clearBit(kDaikinByteSilent, kDaikinBitSilent);
+ }
+}
+
+bool IRDaikinESP::getQuiet() {
+ return (getBit(kDaikinByteSilent, kDaikinBitSilent) > 0);
+}
+
+void IRDaikinESP::setPowerful(bool state) {
+ if (state) {
+ setBit(kDaikinBytePowerful, kDaikinBitPowerful);
+ // Powerful, Quiet, & Econo mode being on are mutually exclusive.
+ setQuiet(false);
+ setEcono(false);
+ } else {
+ clearBit(kDaikinBytePowerful, kDaikinBitPowerful);
+ }
+}
+
+bool IRDaikinESP::getPowerful() {
+ return (getBit(kDaikinBytePowerful, kDaikinBitPowerful) > 0);
+}
+
+void IRDaikinESP::setSensor(bool state) {
+ if (state)
+ setBit(kDaikinByteSensor, kDaikinBitSensor);
+ else
+ clearBit(kDaikinByteSensor, kDaikinBitSensor);
+}
+
+bool IRDaikinESP::getSensor() {
+ return (getBit(kDaikinByteSensor, kDaikinBitSensor) > 0);
+}
+
+void IRDaikinESP::setEcono(bool state) {
+ if (state) {
+ setBit(kDaikinByteEcono, kDaikinBitEcono);
+ // Powerful & Econo mode being on are mutually exclusive.
+ setPowerful(false);
+ } else {
+ clearBit(kDaikinByteEcono, kDaikinBitEcono);
+ }
+}
+
+bool IRDaikinESP::getEcono() {
+ return (getBit(kDaikinByteEcono, kDaikinBitEcono) > 0);
+}
+
+void IRDaikinESP::setEye(bool state) {
+ if (state)
+ setBit(kDaikinByteEye, kDaikinBitEye);
+ else
+ clearBit(kDaikinByteEye, kDaikinBitEye);
+}
+
+bool IRDaikinESP::getEye() {
+ return (getBit(kDaikinByteEye, kDaikinBitEye) > 0);
+}
+
+void IRDaikinESP::setMold(bool state) {
+ if (state)
+ setBit(kDaikinByteMold, kDaikinBitMold);
+ else
+ clearBit(kDaikinByteMold, kDaikinBitMold);
+}
+
+bool IRDaikinESP::getMold() {
+ return (getBit(kDaikinByteMold, kDaikinBitMold) > 0);
+}
+
+void IRDaikinESP::setBit(uint8_t byte, uint8_t bitmask) {
+ daikin[byte] |= bitmask;
+}
+
+void IRDaikinESP::clearBit(uint8_t byte, uint8_t bitmask) {
+ bitmask = ~bitmask;
+ daikin[byte] &= bitmask;
+}
+
+uint8_t IRDaikinESP::getBit(uint8_t byte, uint8_t bitmask) {
+ return daikin[byte] & bitmask;
+}
+
+// starttime: Number of minutes after midnight, in 10 minutes increments
+void IRDaikinESP::enableOnTimer(uint16_t starttime) {
+ setBit(kDaikinByteOnTimer, kDaikinBitOnTimer);
+ daikin[18] = (uint8_t)(starttime & 0x00FF);
+ // only keep 4 bits
+ daikin[19] &= 0xF0;
+ daikin[19] |= (uint8_t)((starttime >> 8) & 0x0F);
+}
+
+void IRDaikinESP::disableOnTimer() {
+ enableOnTimer(0x600);
+ clearBit(kDaikinByteOnTimer, kDaikinBitOnTimer);
+}
+
+uint16_t IRDaikinESP::getOnTime() {
+ uint16_t ret;
+ ret = daikin[19] & 0x0F;
+ ret = ret << 8;
+ ret += daikin[18];
+ return ret;
+}
+
+bool IRDaikinESP::getOnTimerEnabled() {
+ return getBit(kDaikinByteOnTimer, kDaikinBitOnTimer);
+}
+
+// endtime: Number of minutes after midnight, in 10 minutes increments
+void IRDaikinESP::enableOffTimer(uint16_t endtime) {
+ setBit(kDaikinByteOffTimer, kDaikinBitOffTimer);
+ daikin[20] = (uint8_t)((endtime >> 4) & 0xFF);
+ daikin[19] &= 0x0F;
+ daikin[19] |= (uint8_t)((endtime & 0x000F) << 4);
+}
+
+void IRDaikinESP::disableOffTimer() {
+ enableOffTimer(0x600);
+ clearBit(kDaikinByteOffTimer, kDaikinBitOffTimer);
+}
+
+uint16_t IRDaikinESP::getOffTime() {
+ uint16_t ret, tmp;
+ ret = daikin[20];
+ ret <<= 4;
+ tmp = daikin[19] & 0xF0;
+ tmp >>= 4;
+ ret += tmp;
+ return ret;
+}
+
+bool IRDaikinESP::getOffTimerEnabled() {
+ return getBit(kDaikinByteOffTimer, kDaikinBitOffTimer);
+}
+
+void IRDaikinESP::setCurrentTime(uint16_t numMins) {
+ if (numMins > 24 * 60) numMins = 0; // If > 23:59, set to 00:00
+ daikin[5] = (uint8_t)(numMins & 0x00FF);
+ // only keep 4 bits
+ daikin[6] &= 0xF0;
+ daikin[6] |= (uint8_t)((numMins >> 8) & 0x0F);
+}
+
+uint16_t IRDaikinESP::getCurrentTime() {
+ uint16_t ret;
+ ret = daikin[6] & 0x0F;
+ ret <<= 8;
+ ret += daikin[5];
+ return ret;
+}
+
+#ifdef ARDUINO
+String IRDaikinESP::renderTime(uint16_t timemins) {
+ String ret;
+#else // ARDUINO
+std::string IRDaikinESP::renderTime(uint16_t timemins) {
+ std::string ret;
+#endif // ARDUINO
+ uint16_t hours, mins;
+ hours = timemins / 60;
+ ret = uint64ToString(hours) + ":";
+ mins = timemins - (hours * 60);
+ if (mins < 10) ret += "0";
+ ret += uint64ToString(mins);
+ return ret;
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRDaikinESP::toString() {
+ String result = "";
+#else // ARDUINO
+std::string IRDaikinESP::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kDaikinAuto:
+ result += " (AUTO)";
+ break;
+ case kDaikinCool:
+ result += " (COOL)";
+ break;
+ case kDaikinHeat:
+ result += " (HEAT)";
+ break;
+ case kDaikinDry:
+ result += " (DRY)";
+ break;
+ case kDaikinFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kDaikinFanAuto:
+ result += " (AUTO)";
+ break;
+ case kDaikinFanQuiet:
+ result += " (QUIET)";
+ break;
+ case kDaikinFanMin:
+ result += " (MIN)";
+ break;
+ case kDaikinFanMax:
+ result += " (MAX)";
+ break;
+ }
+ result += ", Powerful: ";
+ if (getPowerful())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Quiet: ";
+ if (getQuiet())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Sensor: ";
+ if (getSensor())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Eye: ";
+ if (getEye())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mold: ";
+ if (getMold())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Swing (Horizontal): ";
+ if (getSwingHorizontal())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Swing (Vertical): ";
+ if (getSwingVertical())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Current Time: " + renderTime(getCurrentTime());
+ result += ", On Time: ";
+ if (getOnTimerEnabled())
+ result += renderTime(getOnTime());
+ else
+ result += "Off";
+ result += ", Off Time: ";
+ if (getOffTimerEnabled())
+ result += renderTime(getOffTime());
+ else
+ result += "Off";
+
+ return result;
+}
+
+#if DAIKIN_DEBUG
+// Print what we have
+void IRDaikinESP::printState() {
+#ifdef ARDUINO
+ String strbits;
+#else // ARDUINO
+ std::string strbits;
+#endif // ARDUINO
+ DPRINTLN("Raw Bits:");
+ for (uint8_t i = 0; i < kDaikinStateLength; i++) {
+ strbits = uint64ToString(daikin[i], BIN);
+ while (strbits.length() < 8) strbits = "0" + strbits;
+ DPRINT(strbits);
+ DPRINT(" ");
+ }
+ DPRINTLN("");
+ DPRINTLN(toString());
+}
+#endif // DAIKIN_DEBUG
+
+/*
+ * Return most important bits to allow replay
+ * layout is:
+ * 0: Power
+ * 1-3: Mode
+ * 4-7: Fan speed/mode
+ * 8-14: Target Temperature
+ * 15: Econo
+ * 16: Powerful
+ * 17: Quiet
+ * 18: Sensor
+ * 19: Swing Vertical
+ * 20-31: Current time (mins since midnight)
+ * */
+uint32_t IRDaikinESP::getCommand() {
+ uint32_t ret = 0;
+ uint32_t tmp = 0;
+ if (getPower()) ret |= 0b00000000000000000000000000000001;
+ tmp = getMode();
+ tmp = tmp << 1;
+ ret |= tmp;
+
+ tmp = getFan();
+ tmp <<= 4;
+ ret |= tmp;
+
+ tmp = getTemp();
+ tmp <<= 8;
+ ret |= tmp;
+
+ if (getEcono()) ret |= 0b00000000000000001000000000000000;
+ if (getPowerful()) ret |= 0b00000000000000010000000000000000;
+ if (getQuiet()) ret |= 0b00000000000000100000000000000000;
+ if (getSensor()) ret |= 0b00000000000001000000000000000000;
+ if (getSwingVertical()) ret |= 0b00000000000010000000000000000000;
+ ret |= (getCurrentTime() << 20);
+ return ret;
+}
+
+void IRDaikinESP::setCommand(uint32_t value) {
+ uint32_t tmp = 0;
+ if (value & 0b00000000000000000000000000000001) setPower(true);
+ tmp = value & 0b00000000000000000000000000001110;
+ tmp >>= 1;
+ setMode(tmp);
+
+ tmp = value & 0b00000000000000000000000011110000;
+ tmp >>= 4;
+ setFan(tmp);
+
+ tmp = value & 0b00000000000000000111111100000000;
+ tmp >>= 8;
+ setTemp(tmp);
+
+ if (value & 0b00000000000000001000000000000000) setEcono(true);
+ if (value & 0b00000000000000010000000000000000) setPowerful(true);
+ if (value & 0b00000000000000100000000000000000) setQuiet(true);
+ if (value & 0b00000000000001000000000000000000) setSensor(true);
+ if (value & 0b00000000000010000000000000000000) setSwingVertical(true);
+
+ value >>= 20;
+ setCurrentTime(value);
+}
+
+#if DECODE_DAIKIN
+
+void addbit(bool val, unsigned char data[]) {
+ uint8_t curbit = data[kDaikinCurBit];
+ uint8_t curindex = data[kDaikinCurIndex];
+ if (val) {
+ unsigned char bit = 1;
+ bit = bit << curbit;
+ data[curindex] |= bit;
+ }
+ curbit++;
+ if (curbit == 8) {
+ curbit = 0;
+ curindex++;
+ }
+ data[kDaikinCurBit] = curbit;
+ data[kDaikinCurIndex] = curindex;
+}
+
+bool checkheader(decode_results *results, uint16_t *offset) {
+ if (!IRrecv::matchMark(results->rawbuf[(*offset)++], kDaikinBitMark,
+ kDaikinTolerance, kDaikinMarkExcess))
+ return false;
+ if (!IRrecv::matchSpace(results->rawbuf[(*offset)++],
+ kDaikinZeroSpace + kDaikinGap, kDaikinTolerance,
+ kDaikinMarkExcess))
+ return false;
+ if (!IRrecv::matchMark(results->rawbuf[(*offset)++], kDaikinHdrMark,
+ kDaikinTolerance, kDaikinMarkExcess))
+ return false;
+ if (!IRrecv::matchSpace(results->rawbuf[(*offset)++], kDaikinHdrSpace,
+ kDaikinTolerance, kDaikinMarkExcess))
+ return false;
+
+ return true;
+}
+
+bool readbits(decode_results *results, uint16_t *offset,
+ unsigned char daikin_code[], uint16_t countbits) {
+ for (uint16_t i = 0; i < countbits && *offset < results->rawlen - 1;
+ i++, (*offset)++) {
+ if (!IRrecv::matchMark(results->rawbuf[(*offset)++], kDaikinBitMark,
+ kDaikinTolerance, kDaikinMarkExcess))
+ return false;
+ if (IRrecv::matchSpace(results->rawbuf[*offset], kDaikinOneSpace,
+ kDaikinTolerance, kDaikinMarkExcess))
+ addbit(1, daikin_code);
+ else if (IRrecv::matchSpace(results->rawbuf[*offset], kDaikinZeroSpace,
+ kDaikinTolerance, kDaikinMarkExcess))
+ addbit(0, daikin_code);
+ else
+ return false;
+ }
+ return true;
+}
+
+// Decode the supplied Daikin A/C message.
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of bits to expect in the data portion. (kDaikinRawBits)
+// strict: Flag to indicate if we strictly adhere to the specification.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Should be working.
+//
+// Notes:
+// If DAIKIN_DEBUG enabled, will print all the set options and values.
+//
+// Ref:
+// https://github.com/mharizanov/Daikin-AC-remote-control-over-the-Internet/tree/master/IRremote
+bool IRrecv::decodeDaikin(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < kDaikinRawBits) return false;
+
+ // Compliance
+ if (strict && nbits != kDaikinRawBits) return false;
+
+ uint16_t offset = kStartOffset;
+ unsigned char daikin_code[kDaikinStateLength + 2];
+ for (uint8_t i = 0; i < kDaikinStateLength + 2; i++) daikin_code[i] = 0;
+
+ // Header (#1)
+ for (uint8_t i = 0; i < 10; i++) {
+ if (!matchMark(results->rawbuf[offset++], kDaikinBitMark)) return false;
+ }
+ if (!checkheader(results, &offset)) return false;
+
+ // Data (#1)
+ if (!readbits(results, &offset, daikin_code, 8 * 8)) return false;
+
+ // Ignore everything that has just been captured as it is not needed.
+ // Some remotes may not send this portion, my remote did, but it's not
+ // required.
+ for (uint8_t i = 0; i < kDaikinStateLength + 2; i++) daikin_code[i] = 0;
+
+ // Header (#2)
+ if (!checkheader(results, &offset)) return false;
+
+ // Data (#2)
+ if (!readbits(results, &offset, daikin_code, 8 * 8)) return false;
+
+ // Header (#3)
+ if (!checkheader(results, &offset)) return false;
+
+ // Data (#3), read up everything else
+ if (!readbits(results, &offset, daikin_code, kDaikinBits - (8 * 8)))
+ return false;
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kDaikinBitMark)) return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kDaikinGap))
+ return false;
+
+ // Compliance
+ if (strict) {
+ if (!IRDaikinESP::validChecksum(daikin_code)) return false;
+ }
+
+ // Success
+#if DAIKIN_DEBUG
+ IRDaikinESP dako = IRDaikinESP(0);
+ dako.setRaw(daikin_code);
+#ifdef ARDUINO
+ yield();
+#endif // ARDUINO
+ dako.printState();
+#endif // DAIKIN_DEBUG
+
+ // Copy across the bits to state
+ for (uint8_t i = 0; i < kDaikinStateLength; i++)
+ results->state[i] = daikin_code[i];
+ results->bits = kDaikinStateLength * 8;
+ results->decode_type = DAIKIN;
+ return true;
+}
+#endif // DECODE_DAIKIN
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Daikin.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Daikin.h
new file mode 100644
index 000000000000..7094990d85a4
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Daikin.h
@@ -0,0 +1,208 @@
+// Copyright 2016 sillyfrog
+// Copyright 2017 sillyfrog, crankyoldgit
+#ifndef IR_DAIKIN_H_
+#define IR_DAIKIN_H_
+
+#ifndef UNIT_TEST
+#include
+#else
+#include
+#endif
+#include "IRrecv.h"
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// Option to disable the additional Daikin debug info to conserve memory
+#define DAIKIN_DEBUG false
+
+// DDDDD AAA IIIII KK KK IIIII NN NN
+// DD DD AAAAA III KK KK III NNN NN
+// DD DD AA AA III KKKK III NN N NN
+// DD DD AAAAAAA III KK KK III NN NNN
+// DDDDDD AA AA IIIII KK KK IIIII NN NN
+
+/*
+ Daikin AC map
+ byte 5=Current time, mins past midnight, low bits
+ byte 6
+ b0-b3=Current time, mins past midnight, high bits
+ byte 7= checksum of the first part (and last byte before a 29ms pause)
+ byte 13=mode
+ b7 = 0
+ b6+b5+b4 = Mode
+ Modes: b6+b5+b4
+ 011 = Cool
+ 100 = Heat (temp 23)
+ 110 = FAN (temp not shown, but 25)
+ 000 = Fully Automatic (temp 25)
+ 010 = DRY (temp 0xc0 = 96 degrees c)
+ b3 = 1
+ b2 = OFF timer set
+ b1 = ON timer set
+ b0 = Air Conditioner ON
+ byte 14=temp*2 (Temp should be between 10 - 32)
+ byte 16=Fan
+ FAN control
+ b7+b6+b5+b4 = Fan speed
+ Fan: b7+b6+b5+b4
+ 0×3 = 1 bar
+ 0×4 = 2 bar
+ 0×5 = 3 bar
+ 0×6 = 4 bar
+ 0×7 = 5 bar
+ 0xa = Auto
+ 0xb = Quite
+ b3+b2+b1+b0 = Swing control up/down
+ Swing control up/down:
+ 0000 = Swing up/down off
+ 1111 = Swing up/down on
+ byte 17
+ Swing control left/right:
+ 0000 = Swing left/right off
+ 1111 = Swing left/right on
+ byte 18=On timer mins past midnight, low bits
+ byte 19
+ b0-b3=On timer mins past midnight, high bits
+ b4-b7=Off timer mins past midnight, low bits
+ byte 20=Off timer mins past midnight, high bits
+ byte 21=Aux -> Powerful (bit 1), Silent (bit 5)
+ byte 24=Aux2
+ b1: Sensor
+ b2: Econo mode
+ b7: Intelligent eye on
+ byte 25=Aux3
+ b1: Mold Proof
+ byte 26= checksum of the second part
+*/
+
+// Constants
+const uint8_t kDaikinAuto = 0b000;
+const uint8_t kDaikinDry = 0b010;
+const uint8_t kDaikinCool = 0b011;
+const uint8_t kDaikinHeat = 0b100;
+const uint8_t kDaikinFan = 0b110;
+const uint8_t kDaikinMinTemp = 10; // Celsius
+const uint8_t kDaikinMaxTemp = 32; // Celsius
+const uint8_t kDaikinFanMin = 1;
+const uint8_t kDaikinFanMax = 5;
+const uint8_t kDaikinFanAuto = 0b1010;
+const uint8_t kDaikinFanQuiet = 0b1011;
+const uint8_t kDaikinBytePower = 13;
+const uint8_t kDaikinBitPower = 0b00000001;
+const uint8_t kDaikinBytePowerful = 21;
+const uint8_t kDaikinBitPowerful = 0b00000001;
+const uint8_t kDaikinByteSilent = 21;
+const uint8_t kDaikinBitSilent = 0b00100000;
+const uint8_t kDaikinByteSensor = 24;
+const uint8_t kDaikinBitSensor = 0b00000010;
+const uint8_t kDaikinByteEcono = 24;
+const uint8_t kDaikinBitEcono = 0b00000100;
+const uint8_t kDaikinByteEye = 24;
+const uint8_t kDaikinBitEye = 0b10000000;
+const uint8_t kDaikinByteMold = 25;
+const uint8_t kDaikinBitMold = 0b00000010;
+const uint8_t kDaikinByteOffTimer = 13;
+const uint8_t kDaikinBitOffTimer = 0b00000100;
+const uint8_t kDaikinByteOnTimer = 13;
+const uint8_t kDaikinBitOnTimer = 0b00000010;
+const uint8_t kDaikinCurBit = kDaikinStateLength;
+const uint8_t kDaikinCurIndex = kDaikinStateLength + 1;
+const uint8_t kDaikinTolerance = 35;
+const uint16_t kDaikinMarkExcess = kMarkExcess;
+const uint16_t kDaikinHdrMark = 3650; // kDaikinBitMark * 8
+const uint16_t kDaikinHdrSpace = 1623; // kDaikinBitMark * 4
+const uint16_t kDaikinBitMark = 428;
+const uint16_t kDaikinZeroSpace = 428;
+const uint16_t kDaikinOneSpace = 1280;
+const uint16_t kDaikinGap = 29000;
+// Note bits in each octet swapped so can be sent as a single value
+const uint64_t kDaikinFirstHeader64 =
+ 0b1101011100000000000000001100010100000000001001111101101000010001;
+
+// Legacy defines.
+#define DAIKIN_COOL kDaikinCool
+#define DAIKIN_HEAT kDaikinHeat
+#define DAIKIN_FAN kDaikinFan
+#define DAIKIN_AUTO kDaikinAuto
+#define DAIKIN_DRY kDaikinDry
+#define DAIKIN_MIN_TEMP kDaikinMinTemp
+#define DAIKIN_MAX_TEMP kDaikinMaxTemp
+#define DAIKIN_FAN_MIN kDaikinFanMin
+#define DAIKIN_FAN_MAX kDaikinFanMax
+#define DAIKIN_FAN_AUTO kDaikinFanAuto
+#define DAIKIN_FAN_QUIET kDaikinFanQuiet
+
+class IRDaikinESP {
+ public:
+ explicit IRDaikinESP(uint16_t pin);
+
+#if SEND_DAIKIN
+ void send();
+#endif
+ void begin();
+ void on();
+ void off();
+ void setPower(bool state);
+ bool getPower();
+ void setTemp(uint8_t temp);
+ uint8_t getTemp();
+ void setFan(uint8_t fan);
+ uint8_t getFan();
+ uint8_t getMode();
+ void setMode(uint8_t mode);
+ void setSwingVertical(bool state);
+ bool getSwingVertical();
+ void setSwingHorizontal(bool state);
+ bool getSwingHorizontal();
+ bool getQuiet();
+ void setQuiet(bool state);
+ bool getPowerful();
+ void setPowerful(bool state);
+ void setSensor(bool state);
+ bool getSensor();
+ void setEcono(bool state);
+ bool getEcono();
+ void setEye(bool state);
+ bool getEye();
+ void setMold(bool state);
+ bool getMold();
+ void enableOnTimer(uint16_t starttime);
+ void disableOnTimer();
+ uint16_t getOnTime();
+ bool getOnTimerEnabled();
+ void enableOffTimer(uint16_t endtime);
+ void disableOffTimer();
+ uint16_t getOffTime();
+ bool getOffTimerEnabled();
+ void setCurrentTime(uint16_t time);
+ uint16_t getCurrentTime();
+ uint8_t* getRaw();
+ void setRaw(uint8_t new_code[]);
+#if DAIKIN_DEBUG
+ void printState();
+#endif // DAIKIN_DEBUG
+ uint32_t getCommand();
+ void setCommand(uint32_t value);
+ static bool validChecksum(const uint8_t state[],
+ const uint16_t length = kDaikinStateLength);
+#ifdef ARDUINO
+ String toString();
+ static String renderTime(uint16_t timemins);
+#else
+ std::string toString();
+ static std::string renderTime(uint16_t timemins);
+#endif
+
+ private:
+ // # of bytes per command
+ uint8_t daikin[kDaikinStateLength];
+ void stateReset();
+ static uint8_t calcBlockChecksum(const uint8_t* block, const uint16_t length);
+ void checksum();
+ void setBit(uint8_t byte, uint8_t bitmask);
+ void clearBit(uint8_t byte, uint8_t bitmask);
+ uint8_t getBit(uint8_t byte, uint8_t bitmask);
+ IRsend _irsend;
+};
+
+#endif // IR_DAIKIN_H_
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Denon.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Denon.cpp
similarity index 59%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Denon.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Denon.cpp
index 538e5af101c4..6798e022e3d1 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Denon.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Denon.cpp
@@ -4,7 +4,6 @@
#include
#include "IRrecv.h"
#include "IRsend.h"
-#include "IRtimer.h"
#include "IRutils.h"
// DDDD EEEEE N N OOO N N
@@ -19,25 +18,25 @@
// Constants
// Ref:
// https://github.com/z3t0/Arduino-IRremote/blob/master/ir_Denon.cpp
-#define DENON_TICK 263U
-#define DENON_HDR_MARK_TICKS 1U
-#define DENON_HDR_MARK (DENON_HDR_MARK_TICKS * DENON_TICK)
-#define DENON_HDR_SPACE_TICKS 3U
-#define DENON_HDR_SPACE (DENON_HDR_SPACE_TICKS * DENON_TICK)
-#define DENON_BIT_MARK_TICKS 1U
-#define DENON_BIT_MARK (DENON_BIT_MARK_TICKS * DENON_TICK)
-#define DENON_ONE_SPACE_TICKS 7U
-#define DENON_ONE_SPACE (DENON_ONE_SPACE_TICKS * DENON_TICK)
-#define DENON_ZERO_SPACE_TICKS 3U
-#define DENON_ZERO_SPACE (DENON_ZERO_SPACE_TICKS * DENON_TICK)
-#define DENON_MIN_COMMAND_LENGTH_TICKS 510U
-#define DENON_MIN_COMMAND_LENGTH (DENON_MIN_COMMAND_LENGTH_TICKS * DENON_TICK)
-#define DENON_MIN_GAP_TICKS (DENON_MIN_COMMAND_LENGTH_TICKS - \
- (DENON_HDR_MARK_TICKS + DENON_HDR_SPACE_TICKS + \
- DENON_BITS * (DENON_BIT_MARK_TICKS + DENON_ONE_SPACE_TICKS) + \
- DENON_BIT_MARK_TICKS))
-#define DENON_MIN_GAP (DENON_MIN_GAP_TICKS * DENON_TICK)
-#define DENON_MANUFACTURER 0x2A4CULL
+const uint16_t kDenonTick = 263;
+const uint16_t kDenonHdrMarkTicks = 1;
+const uint16_t kDenonHdrMark = kDenonHdrMarkTicks * kDenonTick;
+const uint16_t kDenonHdrSpaceTicks = 3;
+const uint16_t kDenonHdrSpace = kDenonHdrSpaceTicks * kDenonTick;
+const uint16_t kDenonBitMarkTicks = 1;
+const uint16_t kDenonBitMark = kDenonBitMarkTicks * kDenonTick;
+const uint16_t kDenonOneSpaceTicks = 7;
+const uint16_t kDenonOneSpace = kDenonOneSpaceTicks * kDenonTick;
+const uint16_t kDenonZeroSpaceTicks = 3;
+const uint16_t kDenonZeroSpace = kDenonZeroSpaceTicks * kDenonTick;
+const uint16_t kDenonMinCommandLengthTicks = 510;
+const uint16_t kDenonMinGapTicks =
+ kDenonMinCommandLengthTicks -
+ (kDenonHdrMarkTicks + kDenonHdrSpaceTicks +
+ kDenonBits * (kDenonBitMarkTicks + kDenonOneSpaceTicks) +
+ kDenonBitMarkTicks);
+const uint32_t kDenonMinGap = kDenonMinGapTicks * kDenonTick;
+const uint64_t kDenonManufacturer = 0x2A4CULL;
#if SEND_DENON
// Send a Denon message
@@ -56,9 +55,9 @@
// https://github.com/z3t0/Arduino-IRremote/blob/master/ir_Denon.cpp
// http://assets.denon.com/documentmaster/us/denon%20master%20ir%20hex.xls
void IRsend::sendDenon(uint64_t data, uint16_t nbits, uint16_t repeat) {
- if (nbits >= PANASONIC_BITS) // Is this really Panasonic?
+ if (nbits >= kPanasonicBits) // Is this really Panasonic?
sendPanasonic64(data, nbits, repeat);
- else if (nbits == DENON_LEGACY_BITS)
+ else if (nbits == kDenonLegacyBits)
// Support legacy (broken) calls of sendDenon().
sendSharpRaw(data & (~0x2000ULL), nbits + 1, repeat);
else
@@ -85,7 +84,7 @@ bool IRrecv::decodeDenon(decode_results *results, uint16_t nbits, bool strict) {
switch (nbits) {
case DENON_BITS:
case DENON_48_BITS:
- case DENON_LEGACY_BITS:
+ case kDenonLegacyBits:
break;
default:
return false;
@@ -100,40 +99,36 @@ bool IRrecv::decodeDenon(decode_results *results, uint16_t nbits, bool strict) {
// manufacturer code.
if (!decodeSharp(results, nbits, true, false) &&
- !decodePanasonic(results, nbits, true, DENON_MANUFACTURER)) {
+ !decodePanasonic(results, nbits, true, kDenonManufacturer)) {
// We couldn't decode it as expected, so try the old legacy method.
// NOTE: I don't think this following protocol actually exists.
// Looks like a partial version of the Sharp protocol.
// Check we have enough data
- if (results->rawlen < 2 * nbits + HEADER + FOOTER - 1)
- return false;
- if (strict && nbits != DENON_LEGACY_BITS)
- return false;
+ if (results->rawlen < 2 * nbits + kHeader + kFooter - 1) return false;
+ if (strict && nbits != kDenonLegacyBits) return false;
uint64_t data = 0;
- uint16_t offset = OFFSET_START;
+ uint16_t offset = kStartOffset;
// Header
- if (!matchMark(results->rawbuf[offset], DENON_HDR_MARK)) return false;
+ if (!matchMark(results->rawbuf[offset], kDenonHdrMark)) return false;
// Calculate how long the common tick time is based on the header mark.
- uint32_t m_tick = results->rawbuf[offset++] * RAWTICK /
- DENON_HDR_MARK_TICKS;
- if (!matchSpace(results->rawbuf[offset], DENON_HDR_SPACE)) return false;
- uint32_t s_tick = results->rawbuf[offset++] * RAWTICK /
- DENON_HDR_SPACE_TICKS;
+ uint32_t m_tick = results->rawbuf[offset++] * kRawTick / kDenonHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kDenonHdrSpace)) return false;
+ uint32_t s_tick =
+ results->rawbuf[offset++] * kRawTick / kDenonHdrSpaceTicks;
// Data
- match_result_t data_result = matchData(&(results->rawbuf[offset]), nbits,
- DENON_BIT_MARK_TICKS * m_tick,
- DENON_ONE_SPACE_TICKS * s_tick,
- DENON_BIT_MARK_TICKS * m_tick,
- DENON_ZERO_SPACE_TICKS * s_tick);
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), nbits,
+ kDenonBitMarkTicks * m_tick, kDenonOneSpaceTicks * s_tick,
+ kDenonBitMarkTicks * m_tick, kDenonZeroSpaceTicks * s_tick);
if (data_result.success == false) return false;
data = data_result.data;
offset += data_result.used;
// Footer
- if (!matchMark(results->rawbuf[offset++], DENON_BIT_MARK_TICKS * m_tick))
+ if (!matchMark(results->rawbuf[offset++], kDenonBitMarkTicks * m_tick))
return false;
// Success
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Dish.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Dish.cpp
similarity index 59%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Dish.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Dish.cpp
index 4555db92ff6c..040aa3bf714c 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Dish.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Dish.cpp
@@ -3,7 +3,6 @@
#include "IRrecv.h"
#include "IRsend.h"
-#include "IRtimer.h"
#include "IRutils.h"
// DDDD IIIII SSSS H H
@@ -19,19 +18,19 @@
// Ref:
// https://github.com/marcosamarinho/IRremoteESP8266/blob/master/ir_Dish.cpp
// http://www.hifi-remote.com/wiki/index.php?title=Dish
-#define DISH_TICK 100U
-#define DISH_HDR_MARK_TICKS 4U
-#define DISH_HDR_MARK (DISH_HDR_MARK_TICKS * DISH_TICK)
-#define DISH_HDR_SPACE_TICKS 61U
-#define DISH_HDR_SPACE (DISH_HDR_SPACE_TICKS * DISH_TICK)
-#define DISH_BIT_MARK_TICKS 4U
-#define DISH_BIT_MARK (DISH_BIT_MARK_TICKS * DISH_TICK)
-#define DISH_ONE_SPACE_TICKS 17U
-#define DISH_ONE_SPACE (DISH_ONE_SPACE_TICKS * DISH_TICK)
-#define DISH_ZERO_SPACE_TICKS 28U
-#define DISH_ZERO_SPACE (DISH_ZERO_SPACE_TICKS * DISH_TICK)
-#define DISH_RPT_SPACE_TICKS DISH_HDR_SPACE_TICKS
-#define DISH_RPT_SPACE (DISH_RPT_SPACE_TICKS * DISH_TICK)
+const uint16_t kDishTick = 100;
+const uint16_t kDishHdrMarkTicks = 4;
+const uint16_t kDishHdrMark = kDishHdrMarkTicks * kDishTick;
+const uint16_t kDishHdrSpaceTicks = 61;
+const uint16_t kDishHdrSpace = kDishHdrSpaceTicks * kDishTick;
+const uint16_t kDishBitMarkTicks = 4;
+const uint16_t kDishBitMark = kDishBitMarkTicks * kDishTick;
+const uint16_t kDishOneSpaceTicks = 17;
+const uint16_t kDishOneSpace = kDishOneSpaceTicks * kDishTick;
+const uint16_t kDishZeroSpaceTicks = 28;
+const uint16_t kDishZeroSpace = kDishZeroSpaceTicks * kDishTick;
+const uint16_t kDishRptSpaceTicks = kDishHdrSpaceTicks;
+const uint16_t kDishRptSpace = kDishRptSpaceTicks * kDishTick;
#if SEND_DISH
// Send an IR command to a DISH NETWORK device.
@@ -56,20 +55,15 @@
// Ref:
// http://www.hifi-remote.com/wiki/index.php?title=Dish
void IRsend::sendDISH(uint64_t data, uint16_t nbits, uint16_t repeat) {
- // Set 57.6kHz IR carrier frequency, duty cycle is unknown.
- enableIROut(57600);
- // Header
- mark(DISH_HDR_MARK);
- space(DISH_HDR_SPACE);
- // We always send a command, even for repeat=0, hence '<= repeat'.
- for (uint16_t i = 0; i <= repeat; i++) {
- // Data
- sendData(DISH_BIT_MARK, DISH_ONE_SPACE, DISH_BIT_MARK, DISH_ZERO_SPACE,
- data, nbits, true);
- // Footer
- mark(DISH_BIT_MARK);
- space(DISH_RPT_SPACE);
- }
+ enableIROut(57600); // Set modulation freq. to 57.6kHz.
+ // Header is only ever sent once.
+ mark(kDishHdrMark);
+ space(kDishHdrSpace);
+
+ sendGeneric(0, 0, // No headers from here on in.
+ kDishBitMark, kDishOneSpace, kDishBitMark, kDishZeroSpace,
+ kDishBitMark, kDishRptSpace, data, nbits, 57600, true, repeat,
+ 50);
}
#endif
@@ -78,7 +72,7 @@ void IRsend::sendDISH(uint64_t data, uint16_t nbits, uint16_t repeat) {
//
// Args:
// results: Ptr to the data to decode and where to store the decode result.
-// nbits: Nr. of bits to expect in the data portion. Typically DISH_BITS.
+// nbits: Nr. of bits to expect in the data portion. Typically kDishBits.
// strict: Flag to indicate if we strictly adhere to the specification.
// Returns:
// boolean: True if it can decode it, false if it can't.
@@ -94,34 +88,32 @@ void IRsend::sendDISH(uint64_t data, uint16_t nbits, uint16_t repeat) {
// http://lirc.sourceforge.net/remotes/echostar/301_501_3100_5100_58xx_59xx
// https://github.com/marcosamarinho/IRremoteESP8266/blob/master/ir_Dish.cpp
bool IRrecv::decodeDISH(decode_results *results, uint16_t nbits, bool strict) {
- if (results->rawlen < 2 * nbits + HEADER + FOOTER - 1)
+ if (results->rawlen < 2 * nbits + kHeader + kFooter - 1)
return false; // Not enough entries to be valid.
- if (strict && nbits != DISH_BITS)
- return false; // Not strictly compliant.
+ if (strict && nbits != kDishBits) return false; // Not strictly compliant.
uint64_t data = 0;
- uint16_t offset = OFFSET_START;
+ uint16_t offset = kStartOffset;
// Header
- if (!match(results->rawbuf[offset], DISH_HDR_MARK)) return false;
+ if (!match(results->rawbuf[offset], kDishHdrMark)) return false;
// Calculate how long the common tick time is based on the header mark.
- uint32_t m_tick = results->rawbuf[offset++] * RAWTICK / DISH_HDR_MARK_TICKS;
- if (!matchSpace(results->rawbuf[offset], DISH_HDR_SPACE)) return false;
+ uint32_t m_tick = results->rawbuf[offset++] * kRawTick / kDishHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kDishHdrSpace)) return false;
// Calculate how long the common tick time is based on the header space.
- uint32_t s_tick = results->rawbuf[offset++] * RAWTICK / DISH_HDR_SPACE_TICKS;
+ uint32_t s_tick = results->rawbuf[offset++] * kRawTick / kDishHdrSpaceTicks;
// Data
- match_result_t data_result = matchData(&(results->rawbuf[offset]), nbits,
- DISH_BIT_MARK_TICKS * m_tick,
- DISH_ONE_SPACE_TICKS * s_tick,
- DISH_BIT_MARK_TICKS * m_tick,
- DISH_ZERO_SPACE_TICKS * s_tick);
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), nbits, kDishBitMarkTicks * m_tick,
+ kDishOneSpaceTicks * s_tick, kDishBitMarkTicks * m_tick,
+ kDishZeroSpaceTicks * s_tick);
if (data_result.success == false) return false;
data = data_result.data;
offset += data_result.used;
// Footer
- if (!matchMark(results->rawbuf[offset++], DISH_BIT_MARK_TICKS * m_tick))
+ if (!matchMark(results->rawbuf[offset++], kDishBitMarkTicks * m_tick))
return false;
// Compliance
@@ -129,7 +121,7 @@ bool IRrecv::decodeDISH(decode_results *results, uint16_t nbits, bool strict) {
// The DISH protocol calls for a repeated message, so strictly speaking
// there should be a code following this. Only require it if we are set to
// strict matching.
- if (!matchSpace(results->rawbuf[offset], DISH_RPT_SPACE_TICKS * s_tick))
+ if (!matchSpace(results->rawbuf[offset], kDishRptSpaceTicks * s_tick))
return false;
}
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Electra.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Electra.cpp
new file mode 100644
index 000000000000..df69be748dab
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Electra.cpp
@@ -0,0 +1,112 @@
+// Copyright 2018 David Conran
+
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// EEEEEEE LL EEEEEEE CCCCC TTTTTTT RRRRRR AAA
+// EE LL EE CC C TTT RR RR AAAAA
+// EEEEE LL EEEEE CC TTT RRRRRR AA AA
+// EE LL EE CC C TTT RR RR AAAAAAA
+// EEEEEEE LLLLLLL EEEEEEE CCCCC TTT RR RR AA AA
+
+// Electra A/C added by crankyoldgit
+//
+// Equipment it seems compatible with:
+// *
+
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/527
+
+// Constants
+const uint16_t kElectraAcHdrMark = 9166;
+const uint16_t kElectraAcBitMark = 646;
+const uint16_t kElectraAcHdrSpace = 4470;
+const uint16_t kElectraAcOneSpace = 1647;
+const uint16_t kElectraAcZeroSpace = 547;
+const uint32_t kElectraAcMessageGap = 100000; // Completely made-up guess.
+
+#if SEND_ELECTRA_AC
+// Send a Electra message
+//
+// Args:
+// data: Contents of the message to be sent. (Guessing MSBF order)
+// nbits: Nr. of bits of data to be sent. Typically kElectraAcBits.
+// repeat: Nr. of additional times the message is to be sent.
+//
+// Status: Alpha / Needs testing against a real device.
+//
+void IRsend::sendElectraAC(uint8_t data[], uint16_t nbytes, uint16_t repeat) {
+ for (uint16_t r = 0; r <= repeat; r++)
+ sendGeneric(kElectraAcHdrMark, kElectraAcHdrSpace, kElectraAcBitMark,
+ kElectraAcOneSpace, kElectraAcBitMark, kElectraAcZeroSpace,
+ kElectraAcBitMark, kElectraAcMessageGap, data, nbytes,
+ 38000, // Complete guess of the modulation frequency.
+ true, 0, 50);
+}
+#endif
+
+#if DECODE_ELECTRA_AC
+// Decode the supplied Electra A/C message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kElectraAcBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: Alpha / Needs testing against a real device.
+//
+bool IRrecv::decodeElectraAC(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (nbits % 8 != 0) // nbits has to be a multiple of nr. of bits in a byte.
+ return false;
+
+ if (strict) {
+ if (nbits != kElectraAcBits)
+ return false; // Not strictly a ELECTRA_AC message.
+ }
+
+ // The protocol sends the data normal + inverted, alternating on
+ // each byte. Hence twice the number of expected data bits.
+ if (results->rawlen < 2 * nbits + kHeader + kFooter - 1)
+ return false; // Can't possibly be a valid ELECTRA_AC message.
+
+ uint16_t offset = kStartOffset;
+
+ // Message Header
+ if (!matchMark(results->rawbuf[offset++], kElectraAcHdrMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kElectraAcHdrSpace)) return false;
+
+ // Data Section
+ match_result_t data_result;
+ uint16_t dataBitsSoFar = 0;
+ // Keep reading bytes until we either run out of section or state to fill.
+ for (uint16_t i = 0; offset <= results->rawlen - 16 && i < nbits / 8;
+ i++, dataBitsSoFar += 8, offset += data_result.used) {
+ data_result = matchData(&(results->rawbuf[offset]), 8, kElectraAcBitMark,
+ kElectraAcOneSpace, kElectraAcBitMark,
+ kElectraAcZeroSpace, kTolerance, 0, true);
+ if (data_result.success == false) return false; // Fail
+ results->state[i] = data_result.data;
+ }
+
+ // Message Footer
+ if (!matchMark(results->rawbuf[offset++], kElectraAcBitMark)) return false;
+ if (offset <= results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kElectraAcMessageGap))
+ return false;
+
+ // Compliance
+ if (strict && dataBitsSoFar != nbits) return false;
+
+ // Success
+ results->decode_type = ELECTRA_AC;
+ results->bits = dataBitsSoFar;
+ // No need to record the state as we stored it as we decoded it.
+ // As we use result->state, we don't record value, address, or command as it
+ // is a union data type.
+ return true;
+}
+#endif // DECODE_ELECTRA_AC
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Fujitsu.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Fujitsu.cpp
new file mode 100644
index 000000000000..7c1b998348b4
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Fujitsu.cpp
@@ -0,0 +1,519 @@
+// Copyright 2017 Jonny Graham, David Conran
+#include "ir_Fujitsu.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRsend.h"
+#include "IRutils.h"
+
+// Fujitsu A/C support added by Jonny Graham & David Conran
+
+// Equipment it seems compatible with:
+// * Fujitsu ASYG30LFCA with remote AR-RAH2E
+// * Fujitsu AST9RSGCW with remote AR-DB1
+// *
+
+// Ref:
+// These values are based on averages of measurements
+const uint16_t kFujitsuAcHdrMark = 3324;
+const uint16_t kFujitsuAcHdrSpace = 1574;
+const uint16_t kFujitsuAcBitMark = 448;
+const uint16_t kFujitsuAcOneSpace = 1182;
+const uint16_t kFujitsuAcZeroSpace = 390;
+const uint16_t kFujitsuAcMinGap = 8100;
+
+#if SEND_FUJITSU_AC
+// Send a Fujitsu A/C message.
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. Typically one of:
+// kFujitsuAcStateLength
+// kFujitsuAcStateLength - 1
+// kFujitsuAcStateLengthShort
+// kFujitsuAcStateLengthShort - 1
+// repeat: Nr. of times the message is to be repeated.
+// (Default = kFujitsuAcMinRepeat).
+//
+// Status: BETA / Appears to be working.
+//
+void IRsend::sendFujitsuAC(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ sendGeneric(kFujitsuAcHdrMark, kFujitsuAcHdrSpace, kFujitsuAcBitMark,
+ kFujitsuAcOneSpace, kFujitsuAcBitMark, kFujitsuAcZeroSpace,
+ kFujitsuAcBitMark, kFujitsuAcMinGap, data, nbytes, 38, false,
+ repeat, 50);
+}
+#endif // SEND_FUJITSU_AC
+
+// Code to emulate Fujitsu A/C IR remote control unit.
+
+// Initialise the object.
+IRFujitsuAC::IRFujitsuAC(uint16_t pin, fujitsu_ac_remote_model_t model)
+ : _irsend(pin) {
+ setModel(model);
+ stateReset();
+}
+
+void IRFujitsuAC::setModel(fujitsu_ac_remote_model_t model) {
+ _model = model;
+ switch (model) {
+ case ARDB1:
+ _state_length = kFujitsuAcStateLength - 1;
+ _state_length_short = kFujitsuAcStateLengthShort - 1;
+ break;
+ default:
+ _state_length = kFujitsuAcStateLength;
+ _state_length_short = kFujitsuAcStateLengthShort;
+ }
+}
+
+// Reset the state of the remote to a known good state/sequence.
+void IRFujitsuAC::stateReset() {
+ _temp = 24;
+ _fanSpeed = kFujitsuAcFanHigh;
+ _mode = kFujitsuAcModeCool;
+ _swingMode = kFujitsuAcSwingBoth;
+ _cmd = kFujitsuAcCmdTurnOn;
+ buildState();
+}
+
+// Configure the pin for output.
+void IRFujitsuAC::begin() { _irsend.begin(); }
+
+#if SEND_FUJITSU_AC
+// Send the current desired state to the IR LED.
+void IRFujitsuAC::send() {
+ getRaw();
+ _irsend.sendFujitsuAC(remote_state, getStateLength());
+}
+#endif // SEND_FUJITSU_AC
+
+void IRFujitsuAC::buildState() {
+ remote_state[0] = 0x14;
+ remote_state[1] = 0x63;
+ remote_state[2] = 0x00;
+ remote_state[3] = 0x10;
+ remote_state[4] = 0x10;
+ bool fullCmd = false;
+ switch (_cmd) {
+ case kFujitsuAcCmdTurnOff:
+ remote_state[5] = 0x02;
+ break;
+ case kFujitsuAcCmdStepHoriz:
+ remote_state[5] = 0x79;
+ break;
+ case kFujitsuAcCmdStepVert:
+ remote_state[5] = 0x6C;
+ break;
+ default:
+ switch (_model) {
+ case ARRAH2E:
+ remote_state[5] = 0xFE;
+ break;
+ case ARDB1:
+ remote_state[5] = 0xFC;
+ break;
+ }
+ fullCmd = true;
+ break;
+ }
+ if (fullCmd) { // long codes
+ uint8_t tempByte = _temp - kFujitsuAcMinTemp;
+ // Nr. of bytes in the message after this byte.
+ remote_state[6] = _state_length - 7;
+
+ remote_state[7] = 0x30;
+ remote_state[8] = (_cmd == kFujitsuAcCmdTurnOn) | (tempByte << 4);
+ remote_state[9] = _mode | 0 << 4; // timer off
+ remote_state[10] = _fanSpeed | _swingMode << 4;
+ remote_state[11] = 0; // timerOff values
+ remote_state[12] = 0; // timerOff/On values
+ remote_state[13] = 0; // timerOn values
+ if (_model == ARRAH2E)
+ remote_state[14] = 0x20;
+ else
+ remote_state[14] = 0x00;
+
+ uint8_t checksum = 0;
+ uint8_t checksum_complement = 0;
+ if (_model == ARRAH2E) {
+ checksum = sumBytes(remote_state + _state_length_short,
+ _state_length - _state_length_short - 1);
+ } else if (_model == ARDB1) {
+ checksum = sumBytes(remote_state, _state_length - 1);
+ checksum_complement = 0x9B;
+ }
+ // and negate the checksum and store it in the last byte.
+ remote_state[_state_length - 1] = checksum_complement - checksum;
+ } else { // short codes
+ if (_model == ARRAH2E)
+ // The last byte is the inverse of penultimate byte
+ remote_state[_state_length_short - 1] =
+ ~remote_state[_state_length_short - 2];
+ // Zero the rest of the state.
+ for (uint8_t i = _state_length_short; i < kFujitsuAcStateLength; i++)
+ remote_state[i] = 0;
+ }
+}
+
+uint8_t IRFujitsuAC::getStateLength() {
+ buildState(); // Force an update of the internal state.
+ if ((_model == ARRAH2E && remote_state[5] != 0xFE) ||
+ (_model == ARDB1 && remote_state[5] != 0xFC))
+ return _state_length_short;
+ else
+ return _state_length;
+}
+
+// Return a pointer to the internal state date of the remote.
+uint8_t* IRFujitsuAC::getRaw() {
+ buildState();
+ return remote_state;
+}
+
+void IRFujitsuAC::buildFromState(const uint16_t length) {
+ switch (length) {
+ case kFujitsuAcStateLength - 1:
+ case kFujitsuAcStateLengthShort - 1:
+ setModel(ARDB1);
+ break;
+ default:
+ setModel(ARRAH2E);
+ }
+ switch (remote_state[6]) {
+ case 8:
+ setModel(ARDB1);
+ break;
+ case 9:
+ setModel(ARRAH2E);
+ break;
+ }
+ setTemp((remote_state[8] >> 4) + kFujitsuAcMinTemp);
+ if (remote_state[8] & 0x1)
+ setCmd(kFujitsuAcCmdTurnOn);
+ else
+ setCmd(kFujitsuAcCmdStayOn);
+ setMode(remote_state[9] & 0b111);
+ setFanSpeed(remote_state[10] & 0b111);
+ setSwing(remote_state[10] >> 4);
+ switch (remote_state[5]) {
+ case kFujitsuAcCmdTurnOff:
+ case kFujitsuAcCmdStepHoriz:
+ case kFujitsuAcCmdStepVert:
+ setCmd(remote_state[5]);
+ break;
+ }
+}
+
+bool IRFujitsuAC::setRaw(const uint8_t newState[], const uint16_t length) {
+ if (length > kFujitsuAcStateLength) return false;
+ for (uint16_t i = 0; i < kFujitsuAcStateLength; i++) {
+ if (i < length)
+ remote_state[i] = newState[i];
+ else
+ remote_state[i] = 0;
+ }
+ buildFromState(length);
+ return true;
+}
+
+// Set the requested power state of the A/C to off.
+void IRFujitsuAC::off() { _cmd = kFujitsuAcCmdTurnOff; }
+
+void IRFujitsuAC::stepHoriz() {
+ switch (_model) {
+ case ARDB1:
+ break; // This remote doesn't have a horizontal option.
+ default:
+ _cmd = kFujitsuAcCmdStepHoriz;
+ }
+}
+
+void IRFujitsuAC::stepVert() { _cmd = kFujitsuAcCmdStepVert; }
+
+// Set the requested command of the A/C.
+void IRFujitsuAC::setCmd(uint8_t cmd) {
+ switch (cmd) {
+ case kFujitsuAcCmdTurnOff:
+ case kFujitsuAcCmdTurnOn:
+ case kFujitsuAcCmdStayOn:
+ case kFujitsuAcCmdStepVert:
+ _cmd = cmd;
+ break;
+ case kFujitsuAcCmdStepHoriz:
+ if (_model != ARDB1) // AR-DB1 remote doesn't have step horizontal.
+ _cmd = cmd;
+ // FALLTHRU
+ default:
+ _cmd = kFujitsuAcCmdStayOn;
+ break;
+ }
+}
+
+uint8_t IRFujitsuAC::getCmd() { return _cmd; }
+
+bool IRFujitsuAC::getPower() { return _cmd != kFujitsuAcCmdTurnOff; }
+
+// Set the temp. in deg C
+void IRFujitsuAC::setTemp(uint8_t temp) {
+ temp = std::max((uint8_t)kFujitsuAcMinTemp, temp);
+ temp = std::min((uint8_t)kFujitsuAcMaxTemp, temp);
+ _temp = temp;
+}
+
+uint8_t IRFujitsuAC::getTemp() { return _temp; }
+
+// Set the speed of the fan
+void IRFujitsuAC::setFanSpeed(uint8_t fanSpeed) {
+ if (fanSpeed > kFujitsuAcFanQuiet)
+ fanSpeed = kFujitsuAcFanHigh; // Set the fan to maximum if out of range.
+ _fanSpeed = fanSpeed;
+}
+uint8_t IRFujitsuAC::getFanSpeed() { return _fanSpeed; }
+
+// Set the requested climate operation mode of the a/c unit.
+void IRFujitsuAC::setMode(uint8_t mode) {
+ if (mode > kFujitsuAcModeHeat)
+ mode = kFujitsuAcModeHeat; // Set the mode to maximum if out of range.
+ _mode = mode;
+}
+
+uint8_t IRFujitsuAC::getMode() { return _mode; }
+// Set the requested swing operation mode of the a/c unit.
+void IRFujitsuAC::setSwing(uint8_t swingMode) {
+ switch (_model) {
+ case ARDB1:
+ // Set the mode to max if out of range
+ if (swingMode > kFujitsuAcSwingVert) swingMode = kFujitsuAcSwingVert;
+ break;
+ case ARRAH2E:
+ default:
+ // Set the mode to max if out of range
+ if (swingMode > kFujitsuAcSwingBoth) swingMode = kFujitsuAcSwingBoth;
+ }
+ _swingMode = swingMode;
+}
+
+uint8_t IRFujitsuAC::getSwing() { return _swingMode; }
+
+bool IRFujitsuAC::validChecksum(uint8_t state[], uint16_t length) {
+ uint8_t sum = 0;
+ uint8_t sum_complement = 0;
+ uint8_t checksum = state[length - 1];
+ switch (length) {
+ case kFujitsuAcStateLengthShort: // ARRAH2E
+ return state[length - 1] == (uint8_t)~state[length - 2];
+ case kFujitsuAcStateLength - 1: // ARDB1
+ sum = sumBytes(state, length - 1);
+ sum_complement = 0x9B;
+ break;
+ case kFujitsuAcStateLength: // ARRAH2E
+ sum = sumBytes(state + kFujitsuAcStateLengthShort,
+ length - 1 - kFujitsuAcStateLengthShort);
+ break;
+ default: // Includes ARDB1 short.
+ return true; // Assume the checksum is valid for other lengths.
+ }
+ return checksum == (uint8_t)(sum_complement - sum); // Does it match?
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRFujitsuAC::toString() {
+ String result = "";
+#else
+std::string IRFujitsuAC::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kFujitsuAcModeAuto:
+ result += " (AUTO)";
+ break;
+ case kFujitsuAcModeCool:
+ result += " (COOL)";
+ break;
+ case kFujitsuAcModeHeat:
+ result += " (HEAT)";
+ break;
+ case kFujitsuAcModeDry:
+ result += " (DRY)";
+ break;
+ case kFujitsuAcModeFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFanSpeed());
+ switch (getFanSpeed()) {
+ case kFujitsuAcFanAuto:
+ result += " (AUTO)";
+ break;
+ case kFujitsuAcFanHigh:
+ result += " (HIGH)";
+ break;
+ case kFujitsuAcFanMed:
+ result += " (MED)";
+ break;
+ case kFujitsuAcFanLow:
+ result += " (LOW)";
+ break;
+ case kFujitsuAcFanQuiet:
+ result += " (QUIET)";
+ break;
+ }
+ result += ", Swing: ";
+ switch (getSwing()) {
+ case kFujitsuAcSwingOff:
+ result += "Off";
+ break;
+ case kFujitsuAcSwingVert:
+ result += "Vert";
+ break;
+ case kFujitsuAcSwingHoriz:
+ result += "Horiz";
+ break;
+ case kFujitsuAcSwingBoth:
+ result += "Vert + Horiz";
+ break;
+ default:
+ result += "UNKNOWN";
+ }
+ result += ", Command: ";
+ switch (getCmd()) {
+ case kFujitsuAcCmdStepHoriz:
+ result += "Step vane horizontally";
+ break;
+ case kFujitsuAcCmdStepVert:
+ result += "Step vane vertically";
+ break;
+ default:
+ result += "N/A";
+ }
+ return result;
+}
+
+#if DECODE_FUJITSU_AC
+// Decode a Fujitsu AC IR message if possible.
+// Places successful decode information in the results pointer.
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kFujitsuAcBits.
+// strict: Flag to indicate if we strictly adhere to the specification.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: ALPHA / Untested.
+//
+// Ref:
+//
+bool IRrecv::decodeFujitsuAC(decode_results* results, uint16_t nbits,
+ bool strict) {
+ uint16_t offset = kStartOffset;
+ uint16_t dataBitsSoFar = 0;
+
+ // Have we got enough data to successfully decode?
+ if (results->rawlen < (2 * kFujitsuAcMinBits) + kHeader + kFooter - 1)
+ return false; // Can't possibly be a valid message.
+
+ // Compliance
+ if (strict) {
+ switch (nbits) {
+ case kFujitsuAcBits:
+ case kFujitsuAcBits - 8:
+ case kFujitsuAcMinBits:
+ case kFujitsuAcMinBits + 8:
+ break;
+ default:
+ return false; // Must be called with the correct nr. of bits.
+ }
+ }
+
+ // Header
+ if (!matchMark(results->rawbuf[offset++], kFujitsuAcHdrMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kFujitsuAcHdrSpace)) return false;
+
+ // Data (Fixed signature)
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), kFujitsuAcMinBits - 8,
+ kFujitsuAcBitMark, kFujitsuAcOneSpace, kFujitsuAcBitMark,
+ kFujitsuAcZeroSpace, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) return false; // Fail
+ if (data_result.data != 0x1010006314) return false; // Signature failed.
+ dataBitsSoFar += kFujitsuAcMinBits - 8;
+ offset += data_result.used;
+ results->state[0] = 0x14;
+ results->state[1] = 0x63;
+ results->state[2] = 0x00;
+ results->state[3] = 0x10;
+ results->state[4] = 0x10;
+
+ // Keep reading bytes until we either run out of message or state to fill.
+ for (uint16_t i = 5;
+ offset <= results->rawlen - 16 && i < kFujitsuAcStateLength;
+ i++, dataBitsSoFar += 8, offset += data_result.used) {
+ data_result = matchData(
+ &(results->rawbuf[offset]), 8, kFujitsuAcBitMark, kFujitsuAcOneSpace,
+ kFujitsuAcBitMark, kFujitsuAcZeroSpace, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) break; // Fail
+ results->state[i] = data_result.data;
+ }
+
+ // Footer
+ if (offset > results->rawlen ||
+ !matchMark(results->rawbuf[offset++], kFujitsuAcBitMark))
+ return false;
+ // The space is optional if we are out of capture.
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kFujitsuAcMinGap))
+ return false;
+
+ // Compliance
+ if (strict) {
+ if (dataBitsSoFar != nbits) return false;
+ }
+
+ results->decode_type = FUJITSU_AC;
+ results->bits = dataBitsSoFar;
+
+ // Compliance
+ switch (dataBitsSoFar) {
+ case kFujitsuAcMinBits:
+ // Check if this values indicate that this should have been a long state
+ // message.
+ if (results->state[5] == 0xFC) return false;
+ return true; // Success
+ case kFujitsuAcMinBits + 8:
+ // Check if this values indicate that this should have been a long state
+ // message.
+ if (results->state[5] == 0xFE) return false;
+ // The last byte needs to be the inverse of the penultimate byte.
+ if (results->state[5] != (uint8_t)~results->state[6]) return false;
+ return true; // Success
+ case kFujitsuAcBits - 8:
+ // Long messages of this size require this byte be correct.
+ if (results->state[5] != 0xFC) return false;
+ break;
+ case kFujitsuAcBits:
+ // Long messages of this size require this byte be correct.
+ if (results->state[5] != 0xFE) return false;
+ break;
+ default:
+ return false; // Unexpected size.
+ }
+ if (!IRFujitsuAC::validChecksum(results->state, dataBitsSoFar / 8))
+ return false;
+
+ // Success
+ return true; // All good.
+}
+#endif // DECODE_FUJITSU_AC
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Fujitsu.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Fujitsu.h
new file mode 100644
index 000000000000..bba634be622b
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Fujitsu.h
@@ -0,0 +1,123 @@
+// Copyright 2017 Jonny Graham
+// Copyright 2018 David Conran
+#ifndef IR_FUJITSU_H_
+#define IR_FUJITSU_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifdef ARDUINO
+#include
+#else
+#include
+#endif
+#include "IRrecv.h"
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// FUJITSU A/C support added by Jonny Graham
+
+// Constants
+const uint8_t kFujitsuAcModeAuto = 0x00;
+const uint8_t kFujitsuAcModeCool = 0x01;
+const uint8_t kFujitsuAcModeDry = 0x02;
+const uint8_t kFujitsuAcModeFan = 0x03;
+const uint8_t kFujitsuAcModeHeat = 0x04;
+
+const uint8_t kFujitsuAcCmdStayOn = 0x00;
+const uint8_t kFujitsuAcCmdTurnOn = 0x01;
+const uint8_t kFujitsuAcCmdTurnOff = 0x02;
+const uint8_t kFujitsuAcCmdStepHoriz = 0x79;
+const uint8_t kFujitsuAcCmdStepVert = 0x6C;
+
+const uint8_t kFujitsuAcFanAuto = 0x00;
+const uint8_t kFujitsuAcFanHigh = 0x01;
+const uint8_t kFujitsuAcFanMed = 0x02;
+const uint8_t kFujitsuAcFanLow = 0x03;
+const uint8_t kFujitsuAcFanQuiet = 0x04;
+
+const uint8_t kFujitsuAcMinTemp = 16; // 16C
+const uint8_t kFujitsuAcMaxTemp = 30; // 30C
+
+const uint8_t kFujitsuAcSwingOff = 0x00;
+const uint8_t kFujitsuAcSwingVert = 0x01;
+const uint8_t kFujitsuAcSwingHoriz = 0x02;
+const uint8_t kFujitsuAcSwingBoth = 0x03;
+
+// Legacy defines.
+#define FUJITSU_AC_MODE_AUTO kFujitsuAcModeAuto
+#define FUJITSU_AC_MODE_COOL kFujitsuAcModeCool
+#define FUJITSU_AC_MODE_DRY kFujitsuAcModeDry
+#define FUJITSU_AC_MODE_FAN kFujitsuAcModeFan
+#define FUJITSU_AC_MODE_HEAT kFujitsuAcModeHeat
+#define FUJITSU_AC_CMD_STAY_ON kFujitsuAcCmdStayOn
+#define FUJITSU_AC_CMD_TURN_ON kFujitsuAcCmdTurnOn
+#define FUJITSU_AC_CMD_TURN_OFF kFujitsuAcCmdTurnOff
+#define FUJITSU_AC_CMD_STEP_HORIZ kFujitsuAcCmdStepHoriz
+#define FUJITSU_AC_CMD_STEP_VERT kFujitsuAcCmdStepVert
+#define FUJITSU_AC_FAN_AUTO kFujitsuAcFanAuto
+#define FUJITSU_AC_FAN_HIGH kFujitsuAcFanHigh
+#define FUJITSU_AC_FAN_MED kFujitsuAcFanMed
+#define FUJITSU_AC_FAN_LOW kFujitsuAcFanLow
+#define FUJITSU_AC_FAN_QUIET kFujitsuAcFanQuiet
+#define FUJITSU_AC_MIN_TEMP kFujitsuAcMinTemp
+#define FUJITSU_AC_MAX_TEMP kFujitsuAcMaxTemp
+#define FUJITSU_AC_SWING_OFF kFujitsuAcSwingOff
+#define FUJITSU_AC_SWING_VERT kFujitsuAcSwingVert
+#define FUJITSU_AC_SWING_HORIZ kFujitsuAcSwingHoriz
+#define FUJITSU_AC_SWING_BOTH kFujitsuAcSwingBoth
+
+enum fujitsu_ac_remote_model_t {
+ ARRAH2E = 1,
+ ARDB1,
+};
+
+class IRFujitsuAC {
+ public:
+ explicit IRFujitsuAC(uint16_t pin, fujitsu_ac_remote_model_t model = ARRAH2E);
+
+ void setModel(fujitsu_ac_remote_model_t model);
+ void stateReset();
+#if SEND_FUJITSU_AC
+ void send();
+#endif // SEND_FUJITSU_AC
+ void begin();
+ void off();
+ void stepHoriz();
+ void stepVert();
+ void setCmd(uint8_t cmd);
+ uint8_t getCmd();
+ void setTemp(uint8_t temp);
+ uint8_t getTemp();
+ void setFanSpeed(uint8_t fan);
+ uint8_t getFanSpeed();
+ void setMode(uint8_t mode);
+ uint8_t getMode();
+ void setSwing(uint8_t mode);
+ uint8_t getSwing();
+ uint8_t* getRaw();
+ bool setRaw(const uint8_t newState[], const uint16_t length);
+ uint8_t getStateLength();
+ static bool validChecksum(uint8_t* state, uint16_t length);
+ bool getPower();
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
+
+ private:
+ uint8_t remote_state[kFujitsuAcStateLength];
+ IRsend _irsend;
+ uint8_t _temp;
+ uint8_t _fanSpeed;
+ uint8_t _mode;
+ uint8_t _swingMode;
+ uint8_t _cmd;
+ fujitsu_ac_remote_model_t _model;
+ uint8_t _state_length;
+ uint8_t _state_length_short;
+ void buildState();
+ void buildFromState(const uint16_t length);
+};
+
+#endif // IR_FUJITSU_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_GICable.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_GICable.cpp
new file mode 100644
index 000000000000..229e4e5bbcf4
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_GICable.cpp
@@ -0,0 +1,116 @@
+// Copyright 2018 David Conran
+
+#define __STDC_LIMIT_MACROS
+#include
+#include
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// GGGG IIIII CCCCC AAA BBBBB LL EEEEEEE
+// GG GG III CC C AAAAA BB B LL EE
+// GG III CC AA AA BBBBBB LL EEEEE
+// GG GG ... III ... CC C AAAAAAA BB BB LL EE
+// GGGGGG ... IIIII ... CCCCC AA AA BBBBBB LLLLLLL EEEEEEE
+//
+// Ref:
+// https://github.com/cyborg5/IRLib2/blob/master/IRLibProtocols/IRLib_P09_GICable.h
+// https://github.com/markszabo/IRremoteESP8266/issues/447
+
+// Constants
+const uint16_t kGicableHdrMark = 9000;
+const uint16_t kGicableHdrSpace = 4400;
+const uint16_t kGicableBitMark = 550;
+const uint16_t kGicableOneSpace = 4400;
+const uint16_t kGicableZeroSpace = 2200;
+const uint16_t kGicableRptSpace = 2200;
+const uint32_t kGicableMinCommandLength = 99600;
+const uint32_t kGicableMinGap =
+ kGicableMinCommandLength -
+ (kGicableHdrMark + kGicableHdrSpace +
+ kGicableBits * (kGicableBitMark + kGicableOneSpace) + kGicableBitMark);
+
+#if SEND_GICABLE
+// Send a raw G.I. Cable formatted message.
+//
+// Args:
+// data: The message to be sent.
+// nbits: The number of bits of the message to be sent.
+// Typically kGicableBits.
+// repeat: The number of times the command is to be repeated.
+//
+// Status: Alpha / Untested.
+//
+// Ref:
+void IRsend::sendGICable(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ sendGeneric(kGicableHdrMark, kGicableHdrSpace, kGicableBitMark,
+ kGicableOneSpace, kGicableBitMark, kGicableZeroSpace,
+ kGicableBitMark, kGicableMinGap, kGicableMinCommandLength, data,
+ nbits, 39, true, 0, // Repeats are handled later.
+ 50);
+ // Message repeat sequence.
+ if (repeat)
+ sendGeneric(kGicableHdrMark, kGicableRptSpace, 0, 0, 0,
+ 0, // No actual data sent.
+ kGicableBitMark, kGicableMinGap, kGicableMinCommandLength, 0,
+ 0, // No data to be sent.
+ 39, true, repeat - 1, 50);
+}
+#endif // SEND_GICABLE
+
+#if DECODE_GICABLE
+// Decode the supplied G.I. Cable message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kGicableBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: Alpha / Not tested against a real device.
+bool IRrecv::decodeGICable(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < 2 * (nbits + kHeader + kFooter) - 1)
+ return false; // Can't possibly be a valid GICABLE message.
+ if (strict && nbits != kGicableBits)
+ return false; // Not strictly an GICABLE message.
+
+ uint64_t data = 0;
+ uint16_t offset = kStartOffset;
+
+ // Header
+ if (!matchMark(results->rawbuf[offset++], kGicableHdrMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kGicableHdrSpace)) return false;
+
+ // Data
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), nbits, kGicableBitMark,
+ kGicableOneSpace, kGicableBitMark, kGicableZeroSpace);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kGicableBitMark)) return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kGicableMinGap))
+ return false;
+
+ // Compliance
+ if (strict) {
+ // We expect a repeat frame.
+ if (!matchMark(results->rawbuf[offset++], kGicableHdrMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kGicableRptSpace)) return false;
+ if (!matchMark(results->rawbuf[offset++], kGicableBitMark)) return false;
+ }
+
+ // Success
+ results->bits = nbits;
+ results->value = data;
+ results->decode_type = GICABLE;
+ results->command = 0;
+ results->address = 0;
+ return true;
+}
+#endif // DECODE_GICABLE
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_GlobalCache.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_GlobalCache.cpp
similarity index 66%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_GlobalCache.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_GlobalCache.cpp
index 019413b96112..daa9dd22c9a8 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_GlobalCache.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_GlobalCache.cpp
@@ -3,7 +3,6 @@
#include
#include "IRsend.h"
-#include "IRtimer.h"
// GGG L OOOO BBBB AA L CCCC AA CCCC H H EEEEEE
// G G L O O B B AAAA L C C AAAA C C H H E
@@ -15,12 +14,12 @@
// (http://www.hishamkhalifa.com)
// Constants
-#define GLOBALCACHE_MAX_REPEAT 50U
-#define GLOBALCACHE_MIN_USEC 80U
-#define GLOBALCACHE_FREQ_INDEX 0U
-#define GLOBALCACHE_RPT_INDEX GLOBALCACHE_FREQ_INDEX + 1U
-#define GLOBALCACHE_RPT_START_INDEX GLOBALCACHE_RPT_INDEX + 1U
-#define GLOBALCACHE_START_INDEX GLOBALCACHE_RPT_START_INDEX + 1U
+const uint16_t kGlobalCacheMaxRepeat = 50;
+const uint32_t kGlobalCacheMinUsec = 80;
+const uint8_t kGlobalCacheFreqIndex = 0;
+const uint8_t kGlobalCacheRptIndex = kGlobalCacheFreqIndex + 1;
+const uint8_t kGlobalCacheRptStartIndex = kGlobalCacheRptIndex + 1;
+const uint8_t kGlobalCacheStartIndex = kGlobalCacheRptStartIndex + 1;
#if SEND_GLOBALCACHE
// Send a shortened GlobalCache (GC) IRdb/control tower formatted message.
@@ -41,24 +40,23 @@
// Ref:
// https://irdb.globalcache.com/Home/Database
void IRsend::sendGC(uint16_t buf[], uint16_t len) {
- uint16_t hz = buf[GLOBALCACHE_FREQ_INDEX]; // GC frequency is in Hz.
+ uint16_t hz = buf[kGlobalCacheFreqIndex]; // GC frequency is in Hz.
enableIROut(hz);
uint32_t periodic_time = calcUSecPeriod(hz, false);
- uint8_t emits = std::min(buf[GLOBALCACHE_RPT_INDEX],
- (uint16_t) GLOBALCACHE_MAX_REPEAT);
+ uint8_t emits =
+ std::min(buf[kGlobalCacheRptIndex], (uint16_t)kGlobalCacheMaxRepeat);
// Repeat
for (uint8_t repeat = 0; repeat < emits; repeat++) {
- // First time through, start at the beginning (GLOBALCACHE_START_INDEX),
+ // First time through, start at the beginning (kGlobalCacheStartIndex),
// otherwise for repeats, we start a specified offset from that.
- uint16_t offset = GLOBALCACHE_START_INDEX;
- if (repeat)
- offset += buf[GLOBALCACHE_RPT_START_INDEX] - 1;
+ uint16_t offset = kGlobalCacheStartIndex;
+ if (repeat) offset += buf[kGlobalCacheRptStartIndex] - 1;
// Data
for (; offset < len; offset++) {
// Convert periodic units to microseconds.
- // Minimum is GLOBALCACHE_MIN_USEC for actual GC units.
- uint32_t microseconds = std::max(buf[offset] * periodic_time,
- GLOBALCACHE_MIN_USEC);
+ // Minimum is kGlobalCacheMinUsec for actual GC units.
+ uint32_t microseconds =
+ std::max(buf[offset] * periodic_time, kGlobalCacheMinUsec);
// These codes start at an odd index (not even as with sendRaw).
if (offset & 1) // Odd bit.
mark(microseconds);
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Gree.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Gree.cpp
new file mode 100644
index 000000000000..df8afada6fa9
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Gree.cpp
@@ -0,0 +1,478 @@
+// Copyright 2017 Ville Skyttä (scop)
+// Copyright 2017, 2018 David Conran
+//
+// Code to emulate Gree protocol compatible HVAC devices.
+// Should be compatible with:
+// * Heat pumps carrying the "Ultimate" brand name.
+// * EKOKAI air conditioners.
+//
+
+#include "ir_Gree.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+#include "IRutils.h"
+#include "ir_Kelvinator.h"
+
+// GGGG RRRRRR EEEEEEE EEEEEEE
+// GG GG RR RR EE EE
+// GG RRRRRR EEEEE EEEEE
+// GG GG RR RR EE EE
+// GGGGGG RR RR EEEEEEE EEEEEEE
+
+// Constants
+// Ref: https://github.com/ToniA/arduino-heatpumpir/blob/master/GreeHeatpumpIR.h
+const uint16_t kGreeHdrMark = 9000;
+const uint16_t kGreeHdrSpace = 4000;
+const uint16_t kGreeBitMark = 620;
+const uint16_t kGreeOneSpace = 1600;
+const uint16_t kGreeZeroSpace = 540;
+const uint16_t kGreeMsgSpace = 19000;
+const uint8_t kGreeBlockFooter = 0b010;
+const uint8_t kGreeBlockFooterBits = 3;
+
+#if SEND_GREE
+// Send a Gree Heat Pump message.
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kGreeStateLength)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: ALPHA / Untested.
+//
+// Ref:
+// https://github.com/ToniA/arduino-heatpumpir/blob/master/GreeHeatpumpIR.cpp
+void IRsend::sendGree(unsigned char data[], uint16_t nbytes, uint16_t repeat) {
+ if (nbytes < kGreeStateLength)
+ return; // Not enough bytes to send a proper message.
+
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // Block #1
+ sendGeneric(kGreeHdrMark, kGreeHdrSpace, kGreeBitMark, kGreeOneSpace,
+ kGreeBitMark, kGreeZeroSpace, 0, 0, // No Footer.
+ data, 4, 38, false, 0, 50);
+ // Footer #1
+ sendGeneric(0, 0, // No Header
+ kGreeBitMark, kGreeOneSpace, kGreeBitMark, kGreeZeroSpace,
+ kGreeBitMark, kGreeMsgSpace, 0b010, 3, 38, true, 0, false);
+
+ // Block #2
+ sendGeneric(0, 0, // No Header for Block #2
+ kGreeBitMark, kGreeOneSpace, kGreeBitMark, kGreeZeroSpace,
+ kGreeBitMark, kGreeMsgSpace, data + 4, nbytes - 4, 38, false, 0,
+ 50);
+ }
+}
+
+// Send a Gree Heat Pump message.
+//
+// Args:
+// data: The raw message to be sent.
+// nbits: Nr. of bits of data in the message. (Default is kGreeBits)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: ALPHA / Untested.
+//
+// Ref:
+// https://github.com/ToniA/arduino-heatpumpir/blob/master/GreeHeatpumpIR.cpp
+void IRsend::sendGree(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ if (nbits != kGreeBits)
+ return; // Wrong nr. of bits to send a proper message.
+ // Set IR carrier frequency
+ enableIROut(38);
+
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // Header
+ mark(kGreeHdrMark);
+ space(kGreeHdrSpace);
+
+ // Data
+ for (int16_t i = 8; i <= nbits; i += 8) {
+ sendData(kGreeBitMark, kGreeOneSpace, kGreeBitMark, kGreeZeroSpace,
+ (data >> (nbits - i)) & 0xFF, 8, false);
+ if (i == nbits / 2) {
+ // Send the mid-message Footer.
+ sendData(kGreeBitMark, kGreeOneSpace, kGreeBitMark, kGreeZeroSpace,
+ 0b010, 3);
+ mark(kGreeBitMark);
+ space(kGreeMsgSpace);
+ }
+ }
+ // Footer
+ mark(kGreeBitMark);
+ space(kGreeMsgSpace);
+ }
+}
+#endif // SEND_GREE
+
+IRGreeAC::IRGreeAC(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRGreeAC::stateReset() {
+ // This resets to a known-good state to Power Off, Fan Auto, Mode Auto, 25C.
+ for (uint8_t i = 0; i < kGreeStateLength; i++) remote_state[i] = 0x0;
+ remote_state[1] = 0x09;
+ remote_state[2] = 0x20;
+ remote_state[3] = 0x50;
+ remote_state[5] = 0x20;
+ remote_state[7] = 0x50;
+}
+
+void IRGreeAC::fixup() {
+ checksum(); // Calculate the checksums
+}
+
+void IRGreeAC::begin() { _irsend.begin(); }
+
+#if SEND_GREE
+void IRGreeAC::send() {
+ fixup(); // Ensure correct settings before sending.
+ _irsend.sendGree(remote_state);
+}
+#endif // SEND_GREE
+
+uint8_t* IRGreeAC::getRaw() {
+ fixup(); // Ensure correct settings before sending.
+ return remote_state;
+}
+
+void IRGreeAC::setRaw(uint8_t new_code[]) {
+ for (uint8_t i = 0; i < kGreeStateLength; i++) {
+ remote_state[i] = new_code[i];
+ }
+}
+
+void IRGreeAC::checksum(const uint16_t length) {
+ // Gree uses the same checksum alg. as Kelvinator's block checksum.
+ uint8_t sum = IRKelvinatorAC::calcBlockChecksum(remote_state, length);
+ remote_state[length - 1] = (sum << 4) | (remote_state[length - 1] & 0xFU);
+}
+
+// Verify the checksum is valid for a given state.
+// Args:
+// state: The array to verify the checksum of.
+// length: The size of the state.
+// Returns:
+// A boolean.
+bool IRGreeAC::validChecksum(const uint8_t state[], const uint16_t length) {
+ // Top 4 bits of the last byte in the state is the state's checksum.
+ if (state[length - 1] >> 4 ==
+ IRKelvinatorAC::calcBlockChecksum(state, length))
+ return true;
+ else
+ return false;
+}
+
+void IRGreeAC::on() {
+ remote_state[0] |= kGreePower1Mask;
+ remote_state[2] |= kGreePower2Mask;
+}
+
+void IRGreeAC::off() {
+ remote_state[0] &= ~kGreePower1Mask;
+ remote_state[2] &= ~kGreePower2Mask;
+}
+
+void IRGreeAC::setPower(const bool state) {
+ if (state)
+ on();
+ else
+ off();
+}
+
+bool IRGreeAC::getPower() {
+ return (remote_state[0] & kGreePower1Mask) &&
+ (remote_state[2] & kGreePower2Mask);
+}
+
+// Set the temp. in deg C
+void IRGreeAC::setTemp(const uint8_t temp) {
+ uint8_t new_temp = std::max((uint8_t)kGreeMinTemp, temp);
+ new_temp = std::min((uint8_t)kGreeMaxTemp, new_temp);
+ if (getMode() == kGreeAuto) new_temp = 25;
+ remote_state[1] = (remote_state[1] & 0xF0U) | (new_temp - kGreeMinTemp);
+}
+
+// Return the set temp. in deg C
+uint8_t IRGreeAC::getTemp() {
+ return ((remote_state[1] & 0xFU) + kGreeMinTemp);
+}
+
+// Set the speed of the fan, 0-3, 0 is auto, 1-3 is the speed
+void IRGreeAC::setFan(const uint8_t speed) {
+ uint8_t fan = std::min((uint8_t)kGreeFanMax, speed); // Bounds check
+
+ if (getMode() == kGreeDry) fan = 1; // DRY mode is always locked to fan 1.
+ // Set the basic fan values.
+ remote_state[0] &= ~kGreeFanMask;
+ remote_state[0] |= (fan << 4);
+}
+
+uint8_t IRGreeAC::getFan() { return ((remote_state[0] & kGreeFanMask) >> 4); }
+
+void IRGreeAC::setMode(const uint8_t new_mode) {
+ uint8_t mode = new_mode;
+ switch (mode) {
+ case kGreeAuto:
+ // AUTO is locked to 25C
+ setTemp(25);
+ break;
+ case kGreeDry:
+ // DRY always sets the fan to 1.
+ setFan(1);
+ break;
+ case kGreeCool:
+ case kGreeFan:
+ case kGreeHeat:
+ break;
+ default:
+ // If we get an unexpected mode, default to AUTO.
+ mode = kGreeAuto;
+ }
+ remote_state[0] &= ~kGreeModeMask;
+ remote_state[0] |= mode;
+}
+
+uint8_t IRGreeAC::getMode() { return (remote_state[0] & kGreeModeMask); }
+
+void IRGreeAC::setLight(const bool state) {
+ remote_state[2] &= ~kGreeLightMask;
+ remote_state[2] |= (state << 5);
+}
+
+bool IRGreeAC::getLight() { return remote_state[2] & kGreeLightMask; }
+
+void IRGreeAC::setXFan(const bool state) {
+ remote_state[2] &= ~kGreeXfanMask;
+ remote_state[2] |= (state << 7);
+}
+
+bool IRGreeAC::getXFan() { return remote_state[2] & kGreeXfanMask; }
+
+void IRGreeAC::setSleep(const bool state) {
+ remote_state[0] &= ~kGreeSleepMask;
+ remote_state[0] |= (state << 7);
+}
+
+bool IRGreeAC::getSleep() { return remote_state[0] & kGreeSleepMask; }
+
+void IRGreeAC::setTurbo(const bool state) {
+ remote_state[2] &= ~kGreeTurboMask;
+ remote_state[2] |= (state << 4);
+}
+
+bool IRGreeAC::getTurbo() { return remote_state[2] & kGreeTurboMask; }
+
+void IRGreeAC::setSwingVertical(const bool automatic, const uint8_t position) {
+ remote_state[0] &= ~kGreeSwingAutoMask;
+ remote_state[0] |= (automatic << 6);
+ uint8_t new_position = position;
+ if (!automatic) {
+ switch (position) {
+ case kGreeSwingUp:
+ case kGreeSwingMiddleUp:
+ case kGreeSwingMiddle:
+ case kGreeSwingMiddleDown:
+ case kGreeSwingDown:
+ break;
+ default:
+ new_position = kGreeSwingLastPos;
+ }
+ } else {
+ switch (position) {
+ case kGreeSwingAuto:
+ case kGreeSwingDownAuto:
+ case kGreeSwingMiddleAuto:
+ case kGreeSwingUpAuto:
+ break;
+ default:
+ new_position = kGreeSwingAuto;
+ }
+ }
+ remote_state[4] &= ~kGreeSwingPosMask;
+ remote_state[4] |= new_position;
+}
+
+bool IRGreeAC::getSwingVerticalAuto() {
+ return remote_state[0] & kGreeSwingAutoMask;
+}
+
+uint8_t IRGreeAC::getSwingVerticalPosition() {
+ return remote_state[4] & kGreeSwingPosMask;
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRGreeAC::toString() {
+ String result = "";
+#else
+std::string IRGreeAC::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kGreeAuto:
+ result += " (AUTO)";
+ break;
+ case kGreeCool:
+ result += " (COOL)";
+ break;
+ case kGreeHeat:
+ result += " (HEAT)";
+ break;
+ case kGreeDry:
+ result += " (DRY)";
+ break;
+ case kGreeFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case 0:
+ result += " (AUTO)";
+ break;
+ case kGreeFanMax:
+ result += " (MAX)";
+ break;
+ }
+ result += ", Turbo: ";
+ if (getTurbo())
+ result += "On";
+ else
+ result += "Off";
+ result += ", XFan: ";
+ if (getXFan())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Light: ";
+ if (getLight())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Sleep: ";
+ if (getSleep())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Swing Vertical Mode: ";
+ if (getSwingVerticalAuto())
+ result += "Auto";
+ else
+ result += "Manual";
+ result +=
+ ", Swing Vertical Pos: " + uint64ToString(getSwingVerticalPosition());
+ switch (getSwingVerticalPosition()) {
+ case kGreeSwingLastPos:
+ result += " (Last Pos)";
+ break;
+ case kGreeSwingAuto:
+ result += " (Auto)";
+ break;
+ }
+ return result;
+}
+
+#if DECODE_GREE
+// Decode the supplied Gree message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kGreeBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: ALPHA / Untested.
+bool IRrecv::decodeGree(decode_results* results, uint16_t nbits, bool strict) {
+ if (results->rawlen <
+ 2 * (nbits + kGreeBlockFooterBits) + (kHeader + kFooter + 1))
+ return false; // Can't possibly be a valid Gree message.
+ if (strict && nbits != kGreeBits)
+ return false; // Not strictly a Gree message.
+
+ uint32_t data;
+ uint16_t offset = kStartOffset;
+
+ // There are two blocks back-to-back in a full Gree IR message
+ // sequence.
+ int8_t state_pos = 0;
+ match_result_t data_result;
+
+ // Header
+ if (!matchMark(results->rawbuf[offset++], kGreeHdrMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kGreeHdrSpace)) return false;
+ // Data Block #1 (32 bits)
+ data_result =
+ matchData(&(results->rawbuf[offset]), 32, kGreeBitMark, kGreeOneSpace,
+ kGreeBitMark, kGreeZeroSpace, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+
+ // Record Data Block #1 in the state.
+ for (uint16_t i = 0; i < 4; i++, data >>= 8)
+ results->state[state_pos + i] = data & 0xFF;
+ state_pos += 4;
+
+ // Block #1 footer (3 bits, B010)
+ data_result = matchData(&(results->rawbuf[offset]), kGreeBlockFooterBits,
+ kGreeBitMark, kGreeOneSpace, kGreeBitMark,
+ kGreeZeroSpace, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) return false;
+ if (data_result.data != kGreeBlockFooter) return false;
+ offset += data_result.used;
+
+ // Inter-block gap.
+ if (!matchMark(results->rawbuf[offset++], kGreeBitMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kGreeMsgSpace)) return false;
+
+ // Data Block #2 (32 bits)
+ data_result =
+ matchData(&(results->rawbuf[offset]), 32, kGreeBitMark, kGreeOneSpace,
+ kGreeBitMark, kGreeZeroSpace, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+
+ // Record Data Block #2 in the state.
+ for (uint16_t i = 0; i < 4; i++, data >>= 8)
+ results->state[state_pos + i] = data & 0xFF;
+ state_pos += 4;
+
+ // Footer.
+ if (!matchMark(results->rawbuf[offset++], kGreeBitMark)) return false;
+ if (offset <= results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kGreeMsgSpace))
+ return false;
+
+ // Compliance
+ if (strict) {
+ // Correct size/length)
+ if (state_pos != kGreeStateLength) return false;
+ // Verify the message's checksum is correct.
+ if (!IRGreeAC::validChecksum(results->state)) return false;
+ }
+
+ // Success
+ results->decode_type = GREE;
+ results->bits = state_pos * 8;
+ // No need to record the state as we stored it as we decoded it.
+ // As we use result->state, we don't record value, address, or command as it
+ // is a union data type.
+ return true;
+}
+#endif // DECODE_GREE
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Gree.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Gree.h
new file mode 100644
index 000000000000..73f69eb31b47
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Gree.h
@@ -0,0 +1,130 @@
+// Kelvinator A/C
+//
+// Copyright 2016 David Conran
+
+#ifndef IR_GREE_H_
+#define IR_GREE_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifndef UNIT_TEST
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// GGGG RRRRRR EEEEEEE EEEEEEE
+// GG GG RR RR EE EE
+// GG RRRRRR EEEEE EEEEE
+// GG GG RR RR EE EE
+// GGGGGG RR RR EEEEEEE EEEEEEE
+
+// Constants
+const uint8_t kGreeAuto = 0;
+const uint8_t kGreeCool = 1;
+const uint8_t kGreeDry = 2;
+const uint8_t kGreeFan = 3;
+const uint8_t kGreeHeat = 4;
+
+// Byte 0
+const uint8_t kGreeModeMask = 0b00000111;
+const uint8_t kGreePower1Mask = 0b00001000;
+const uint8_t kGreeFanMask = 0b00110000;
+const uint8_t kGreeSwingAutoMask = 0b01000000;
+const uint8_t kGreeSleepMask = 0b10000000;
+// Byte 2
+const uint8_t kGreeTurboMask = 0b00010000;
+const uint8_t kGreeLightMask = 0b00100000;
+const uint8_t kGreePower2Mask = 0b01000000;
+const uint8_t kGreeXfanMask = 0b10000000;
+// Byte 4
+const uint8_t kGreeSwingPosMask = 0b00001111;
+
+const uint8_t kGreeMinTemp = 16; // Celsius
+const uint8_t kGreeMaxTemp = 30; // Celsius
+const uint8_t kGreeFanMax = 3;
+
+const uint8_t kGreeSwingLastPos = 0b00000000;
+const uint8_t kGreeSwingAuto = 0b00000001;
+const uint8_t kGreeSwingUp = 0b00000010;
+const uint8_t kGreeSwingMiddleUp = 0b00000011;
+const uint8_t kGreeSwingMiddle = 0b00000100;
+const uint8_t kGreeSwingMiddleDown = 0b00000101;
+const uint8_t kGreeSwingDown = 0b00000110;
+const uint8_t kGreeSwingDownAuto = 0b00000111;
+const uint8_t kGreeSwingMiddleAuto = 0b00001001;
+const uint8_t kGreeSwingUpAuto = 0b00001011;
+
+// Legacy defines.
+#define GREE_AUTO kGreeAuto
+#define GREE_COOL kGreeCool
+#define GREE_DRY kGreeDry
+#define GREE_FAN kGreeFan
+#define GREE_HEAT kGreeHeat
+#define GREE_MIN_TEMP kGreeMinTemp
+#define GREE_MAX_TEMP kGreeMaxTemp
+#define GREE_FAN_MAX kGreeFanMax
+#define GREE_SWING_LAST_POS kGreeSwingLastPos
+#define GREE_SWING_AUTO kGreeSwingAuto
+#define GREE_SWING_UP kGreeSwingUp
+#define GREE_SWING_MIDDLE_UP kGreeSwingMiddleUp
+#define GREE_SWING_MIDDLE kGreeSwingMiddle
+#define GREE_SWING_MIDDLE_DOWN kGreeSwingMiddleDown
+#define GREE_SWING_DOWN kGreeSwingDown
+#define GREE_SWING_DOWN_AUTO kGreeSwingDownAuto
+#define GREE_SWING_MIDDLE_AUTO kGreeSwingMiddleAuto
+#define GREE_SWING_UP_AUTO kGreeSwingUpAuto
+
+// Classes
+class IRGreeAC {
+ public:
+ explicit IRGreeAC(uint16_t pin);
+
+ void stateReset();
+#if SEND_GREE
+ void send();
+#endif // SEND_GREE
+ void begin();
+ void on();
+ void off();
+ void setPower(const bool state);
+ bool getPower();
+ void setTemp(const uint8_t temp);
+ uint8_t getTemp();
+ void setFan(const uint8_t speed);
+ uint8_t getFan();
+ void setMode(const uint8_t new_mode);
+ uint8_t getMode();
+ void setLight(const bool state);
+ bool getLight();
+ void setXFan(const bool state);
+ bool getXFan();
+ void setSleep(const bool state);
+ bool getSleep();
+ void setTurbo(const bool state);
+ bool getTurbo();
+ void setSwingVertical(const bool automatic, const uint8_t position);
+ bool getSwingVerticalAuto();
+ uint8_t getSwingVerticalPosition();
+
+ uint8_t* getRaw();
+ void setRaw(uint8_t new_code[]);
+ static bool validChecksum(const uint8_t state[],
+ const uint16_t length = kGreeStateLength);
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
+
+ private:
+ // The state of the IR remote in IR code form.
+ uint8_t remote_state[kGreeStateLength];
+ void checksum(const uint16_t length = kGreeStateLength);
+ void fixup();
+ IRsend _irsend;
+};
+
+#endif // IR_GREE_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Haier.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Haier.cpp
new file mode 100644
index 000000000000..2c47e4eac2a5
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Haier.cpp
@@ -0,0 +1,865 @@
+// Copyright 2018 crankyoldgit
+// The specifics of reverse engineering the protocols details:
+// * HSU07-HEA03 by kuzin2006.
+// * YR-W02/HSU-09HMC203 by non7top.
+
+#include "ir_Haier.h"
+#ifndef UNIT_TEST
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRutils.h"
+
+// HH HH AAA IIIII EEEEEEE RRRRRR
+// HH HH AAAAA III EE RR RR
+// HHHHHHH AA AA III EEEEE RRRRRR
+// HH HH AAAAAAA III EE RR RR
+// HH HH AA AA IIIII EEEEEEE RR RR
+
+// Supported devices:
+// * Haier HSU07-HEA03 Remote control.
+// * Haier YR-W02 Remote control
+// * Haier HSU-09HMC203 A/C unit.
+
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/404
+// https://www.dropbox.com/s/mecyib3lhdxc8c6/IR%20data%20reverse%20engineering.xlsx?dl=0
+// https://github.com/markszabo/IRremoteESP8266/issues/485
+// https://www.dropbox.com/sh/w0bt7egp0fjger5/AADRFV6Wg4wZskJVdFvzb8Z0a?dl=0&preview=haer2.ods
+
+// Constants
+const uint16_t kHaierAcHdr = 3000;
+const uint16_t kHaierAcHdrGap = 4300;
+const uint16_t kHaierAcBitMark = 520;
+const uint16_t kHaierAcOneSpace = 1650;
+const uint16_t kHaierAcZeroSpace = 650;
+const uint32_t kHaierAcMinGap = 150000; // Completely made up value.
+
+#if (SEND_HAIER_AC || SEND_HAIER_AC_YRW02)
+// Send a Haier A/C message. (HSU07-HEA03 remote)
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kHaierACStateLength)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: Beta / Probably working.
+//
+void IRsend::sendHaierAC(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kHaierACStateLength) return;
+
+ for (uint16_t r = 0; r <= repeat; r++) {
+ enableIROut(38000);
+ mark(kHaierAcHdr);
+ space(kHaierAcHdr);
+ sendGeneric(kHaierAcHdr, kHaierAcHdrGap, kHaierAcBitMark, kHaierAcOneSpace,
+ kHaierAcBitMark, kHaierAcZeroSpace, kHaierAcBitMark,
+ kHaierAcMinGap, data, nbytes, 38, true,
+ 0, // Repeats handled elsewhere
+ 50);
+ }
+}
+#endif // (SEND_HAIER_AC || SEND_HAIER_AC_YRW02)
+
+#if SEND_HAIER_AC_YRW02
+// Send a Haier YR-W02 remote A/C message.
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kHaierACYRW02StateLength)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: Alpha / Untested on a real device.
+//
+void IRsend::sendHaierACYRW02(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes >= kHaierACYRW02StateLength) sendHaierAC(data, nbytes, repeat);
+}
+#endif // SEND_HAIER_AC_YRW02
+
+// Class for emulating a Haier HSU07-HEA03 remote
+IRHaierAC::IRHaierAC(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRHaierAC::begin() { _irsend.begin(); }
+
+#if SEND_HAIER_AC
+void IRHaierAC::send() {
+ checksum();
+ _irsend.sendHaierAC(remote_state);
+}
+#endif // SEND_HAIER_AC
+
+void IRHaierAC::checksum() {
+ remote_state[8] = sumBytes(remote_state, kHaierACStateLength - 1);
+}
+
+bool IRHaierAC::validChecksum(uint8_t state[], const uint16_t length) {
+ if (length < 2) return false; // 1 byte of data can't have a checksum.
+ return (state[length - 1] == sumBytes(state, length - 1));
+}
+
+void IRHaierAC::stateReset() {
+ for (uint8_t i = 1; i < kHaierACStateLength; i++) remote_state[i] = 0x0;
+ remote_state[0] = kHaierAcPrefix;
+ remote_state[2] = 0b00100000;
+
+ setTemp(kHaierAcDefTemp);
+ setFan(kHaierAcFanAuto);
+ setMode(kHaierAcAuto);
+ setCommand(kHaierAcCmdOn);
+}
+
+uint8_t* IRHaierAC::getRaw() {
+ checksum();
+ return remote_state;
+}
+
+void IRHaierAC::setRaw(uint8_t new_code[]) {
+ for (uint8_t i = 0; i < kHaierACStateLength; i++) {
+ remote_state[i] = new_code[i];
+ }
+}
+
+void IRHaierAC::setCommand(uint8_t state) {
+ remote_state[1] &= 0b11110000;
+ switch (state) {
+ case kHaierAcCmdOff:
+ case kHaierAcCmdOn:
+ case kHaierAcCmdMode:
+ case kHaierAcCmdFan:
+ case kHaierAcCmdTempUp:
+ case kHaierAcCmdTempDown:
+ case kHaierAcCmdSleep:
+ case kHaierAcCmdTimerSet:
+ case kHaierAcCmdTimerCancel:
+ case kHaierAcCmdHealth:
+ case kHaierAcCmdSwing:
+ remote_state[1] |= (state & 0b00001111);
+ }
+}
+
+uint8_t IRHaierAC::getCommand() { return remote_state[1] & (0b00001111); }
+
+void IRHaierAC::setFan(uint8_t speed) {
+ uint8_t new_speed = kHaierAcFanAuto;
+ switch (speed) {
+ case kHaierAcFanLow:
+ new_speed = 3;
+ break;
+ case kHaierAcFanMed:
+ new_speed = 1;
+ break;
+ case kHaierAcFanHigh:
+ new_speed = 2;
+ break;
+ default:
+ new_speed = kHaierAcFanAuto; // Default to auto for anything else.
+ }
+
+ if (speed != getFan()) setCommand(kHaierAcCmdFan);
+ remote_state[5] &= 0b11111100;
+ remote_state[5] |= new_speed;
+}
+
+uint8_t IRHaierAC::getFan() {
+ switch (remote_state[5] & 0b00000011) {
+ case 1:
+ return kHaierAcFanMed;
+ case 2:
+ return kHaierAcFanHigh;
+ case 3:
+ return kHaierAcFanLow;
+ default:
+ return kHaierAcFanAuto;
+ }
+}
+
+void IRHaierAC::setMode(uint8_t mode) {
+ uint8_t new_mode = mode;
+ setCommand(kHaierAcCmdMode);
+ if (mode > kHaierAcFan) // If out of range, default to auto mode.
+ new_mode = kHaierAcAuto;
+ remote_state[7] &= 0b00011111;
+ remote_state[7] |= (new_mode << 5);
+}
+
+uint8_t IRHaierAC::getMode() { return (remote_state[7] & 0b11100000) >> 5; }
+
+void IRHaierAC::setTemp(const uint8_t celsius) {
+ uint8_t temp = celsius;
+ if (temp < kHaierAcMinTemp)
+ temp = kHaierAcMinTemp;
+ else if (temp > kHaierAcMaxTemp)
+ temp = kHaierAcMaxTemp;
+
+ uint8_t old_temp = getTemp();
+ if (old_temp == temp) return;
+ if (old_temp > temp)
+ setCommand(kHaierAcCmdTempDown);
+ else
+ setCommand(kHaierAcCmdTempUp);
+
+ remote_state[1] &= 0b00001111; // Clear the previous temp.
+ remote_state[1] |= ((temp - kHaierAcMinTemp) << 4);
+}
+
+uint8_t IRHaierAC::getTemp() {
+ return ((remote_state[1] & 0b11110000) >> 4) + kHaierAcMinTemp;
+}
+
+void IRHaierAC::setHealth(bool state) {
+ setCommand(kHaierAcCmdHealth);
+ remote_state[4] &= 0b11011111;
+ remote_state[4] |= (state << 5);
+}
+
+bool IRHaierAC::getHealth(void) { return remote_state[4] & (1 << 5); }
+
+void IRHaierAC::setSleep(bool state) {
+ setCommand(kHaierAcCmdSleep);
+ remote_state[7] &= 0b10111111;
+ remote_state[7] |= (state << 6);
+}
+
+bool IRHaierAC::getSleep(void) { return remote_state[7] & 0b01000000; }
+
+uint16_t IRHaierAC::getTime(const uint8_t ptr[]) {
+ return (ptr[0] & 0b00011111) * 60 + (ptr[1] & 0b00111111);
+}
+
+int16_t IRHaierAC::getOnTimer() {
+ if (remote_state[3] & 0b10000000) // Check if the timer is turned on.
+ return getTime(remote_state + 6);
+ else
+ return -1;
+}
+
+int16_t IRHaierAC::getOffTimer() {
+ if (remote_state[3] & 0b01000000) // Check if the timer is turned on.
+ return getTime(remote_state + 4);
+ else
+ return -1;
+}
+
+uint16_t IRHaierAC::getCurrTime() { return getTime(remote_state + 2); }
+
+void IRHaierAC::setTime(uint8_t ptr[], const uint16_t nr_mins) {
+ uint16_t mins = nr_mins;
+ if (nr_mins > kHaierAcMaxTime) mins = kHaierAcMaxTime;
+
+ // Hours
+ ptr[0] &= 0b11100000;
+ ptr[0] |= (mins / 60);
+ // Minutes
+ ptr[1] &= 0b11000000;
+ ptr[1] |= (mins % 60);
+}
+
+void IRHaierAC::setOnTimer(const uint16_t nr_mins) {
+ setCommand(kHaierAcCmdTimerSet);
+ remote_state[3] |= 0b10000000;
+ setTime(remote_state + 6, nr_mins);
+}
+
+void IRHaierAC::setOffTimer(const uint16_t nr_mins) {
+ setCommand(kHaierAcCmdTimerSet);
+ remote_state[3] |= 0b01000000;
+ setTime(remote_state + 4, nr_mins);
+}
+
+void IRHaierAC::cancelTimers() {
+ setCommand(kHaierAcCmdTimerCancel);
+ remote_state[3] &= 0b00111111;
+}
+
+void IRHaierAC::setCurrTime(const uint16_t nr_mins) {
+ setTime(remote_state + 2, nr_mins);
+}
+
+uint8_t IRHaierAC::getSwing() { return (remote_state[2] & 0b11000000) >> 6; }
+
+void IRHaierAC::setSwing(const uint8_t state) {
+ if (state == getSwing()) return; // Nothing to do.
+ setCommand(kHaierAcCmdSwing);
+ switch (state) {
+ case kHaierAcSwingOff:
+ case kHaierAcSwingUp:
+ case kHaierAcSwingDown:
+ case kHaierAcSwingChg:
+ remote_state[2] &= 0b00111111;
+ remote_state[2] |= (state << 6);
+ break;
+ }
+}
+
+// Convert a Haier time into a human readable string.
+#ifdef ARDUINO
+String IRHaierAC::timeToString(const uint16_t nr_mins) {
+ String result = "";
+#else
+std::string IRHaierAC::timeToString(const uint16_t nr_mins) {
+ std::string result = "";
+#endif // ARDUINO
+
+ if (nr_mins / 24 < 10) result += "0"; // Zero pad.
+ result += uint64ToString(nr_mins / 60);
+ result += ":";
+ if (nr_mins % 60 < 10) result += "0"; // Zero pad.
+ result += uint64ToString(nr_mins % 60);
+ return result;
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRHaierAC::toString() {
+ String result = "";
+#else
+std::string IRHaierAC::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ uint8_t cmd = getCommand();
+ result += "Command: " + uint64ToString(cmd) + " (";
+ switch (cmd) {
+ case kHaierAcCmdOff:
+ result += "Off";
+ break;
+ case kHaierAcCmdOn:
+ result += "On";
+ break;
+ case kHaierAcCmdMode:
+ result += "Mode";
+ break;
+ case kHaierAcCmdFan:
+ result += "Fan";
+ break;
+ case kHaierAcCmdTempUp:
+ result += "Temp Up";
+ break;
+ case kHaierAcCmdTempDown:
+ result += "Temp Down";
+ break;
+ case kHaierAcCmdSleep:
+ result += "Sleep";
+ break;
+ case kHaierAcCmdTimerSet:
+ result += "Timer Set";
+ break;
+ case kHaierAcCmdTimerCancel:
+ result += "Timer Cancel";
+ break;
+ case kHaierAcCmdHealth:
+ result += "Health";
+ break;
+ case kHaierAcCmdSwing:
+ result += "Swing";
+ break;
+ default:
+ result += "Unknown";
+ }
+ result += ")";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kHaierAcAuto:
+ result += " (AUTO)";
+ break;
+ case kHaierAcCool:
+ result += " (COOL)";
+ break;
+ case kHaierAcHeat:
+ result += " (HEAT)";
+ break;
+ case kHaierAcDry:
+ result += " (DRY)";
+ break;
+ case kHaierAcFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kHaierAcFanAuto:
+ result += " (AUTO)";
+ break;
+ case kHaierAcFanHigh:
+ result += " (MAX)";
+ break;
+ }
+ result += ", Swing: " + uint64ToString(getSwing()) + " (";
+ switch (getSwing()) {
+ case kHaierAcSwingOff:
+ result += "Off";
+ break;
+ case kHaierAcSwingUp:
+ result += "Up";
+ break;
+ case kHaierAcSwingDown:
+ result += "Down";
+ break;
+ case kHaierAcSwingChg:
+ result += "Chg";
+ break;
+ default:
+ result += "Unknown";
+ }
+ result += ")";
+ result += ", Sleep: ";
+ if (getSleep())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Health: ";
+ if (getHealth())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Current Time: " + timeToString(getCurrTime());
+ result += ", On Timer: ";
+ if (getOnTimer() >= 0)
+ result += timeToString(getOnTimer());
+ else
+ result += "Off";
+ result += ", Off Timer: ";
+ if (getOffTimer() >= 0)
+ result += timeToString(getOffTimer());
+ else
+ result += "Off";
+
+ return result;
+}
+// End of IRHaierAC class.
+
+// Class for emulating a Haier YRW02 remote
+IRHaierACYRW02::IRHaierACYRW02(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRHaierACYRW02::begin() { _irsend.begin(); }
+
+#if SEND_HAIER_AC_YRW02
+void IRHaierACYRW02::send() {
+ checksum();
+ _irsend.sendHaierACYRW02(remote_state);
+}
+#endif // SEND_HAIER_AC_YRW02
+
+void IRHaierACYRW02::checksum() {
+ remote_state[kHaierACYRW02StateLength - 1] =
+ sumBytes(remote_state, kHaierACYRW02StateLength - 1);
+}
+
+bool IRHaierACYRW02::validChecksum(uint8_t state[], const uint16_t length) {
+ if (length < 2) return false; // 1 byte of data can't have a checksum.
+ return (state[length - 1] == sumBytes(state, length - 1));
+}
+
+void IRHaierACYRW02::stateReset() {
+ for (uint8_t i = 1; i < kHaierACYRW02StateLength; i++) remote_state[i] = 0x0;
+ remote_state[0] = kHaierAcYrw02Prefix;
+
+ setTemp(kHaierAcDefTemp);
+ setHealth(true);
+ setTurbo(kHaierAcYrw02TurboOff);
+ setSleep(false);
+ setFan(kHaierAcYrw02FanAuto);
+ setSwing(kHaierAcYrw02SwingOff);
+ setMode(kHaierAcYrw02Auto);
+ setPower(true);
+}
+
+uint8_t* IRHaierACYRW02::getRaw() {
+ checksum();
+ return remote_state;
+}
+
+void IRHaierACYRW02::setRaw(uint8_t new_code[]) {
+ for (uint8_t i = 0; i < kHaierACYRW02StateLength; i++) {
+ remote_state[i] = new_code[i];
+ }
+}
+
+void IRHaierACYRW02::setButton(uint8_t button) {
+ switch (button) {
+ case kHaierAcYrw02ButtonTempUp:
+ case kHaierAcYrw02ButtonTempDown:
+ case kHaierAcYrw02ButtonSwing:
+ case kHaierAcYrw02ButtonFan:
+ case kHaierAcYrw02ButtonPower:
+ case kHaierAcYrw02ButtonMode:
+ case kHaierAcYrw02ButtonHealth:
+ case kHaierAcYrw02ButtonTurbo:
+ case kHaierAcYrw02ButtonSleep:
+ remote_state[12] &= 0b11110000;
+ remote_state[12] |= (button & 0b00001111);
+ }
+}
+
+uint8_t IRHaierACYRW02::getButton() { return remote_state[12] & (0b00001111); }
+
+void IRHaierACYRW02::setMode(uint8_t mode) {
+ uint8_t new_mode = mode;
+ setButton(kHaierAcYrw02ButtonMode);
+ switch (mode) {
+ case kHaierAcYrw02Auto:
+ case kHaierAcYrw02Cool:
+ case kHaierAcYrw02Dry:
+ case kHaierAcYrw02Heat:
+ case kHaierAcYrw02Fan:
+ break;
+ default: // If unexpected, default to auto mode.
+ new_mode = kHaierAcYrw02Auto;
+ }
+ remote_state[7] &= 0b0001111;
+ remote_state[7] |= (new_mode << 4);
+}
+
+uint8_t IRHaierACYRW02::getMode() { return remote_state[7] >> 4; }
+
+void IRHaierACYRW02::setTemp(const uint8_t celcius) {
+ uint8_t temp = celcius;
+ if (temp < kHaierAcMinTemp)
+ temp = kHaierAcMinTemp;
+ else if (temp > kHaierAcMaxTemp)
+ temp = kHaierAcMaxTemp;
+
+ uint8_t old_temp = getTemp();
+ if (old_temp == temp) return;
+ if (old_temp > temp)
+ setButton(kHaierAcYrw02ButtonTempDown);
+ else
+ setButton(kHaierAcYrw02ButtonTempUp);
+
+ remote_state[1] &= 0b00001111; // Clear the previous temp.
+ remote_state[1] |= ((temp - kHaierAcMinTemp) << 4);
+}
+
+uint8_t IRHaierACYRW02::getTemp() {
+ return ((remote_state[1] & 0b11110000) >> 4) + kHaierAcMinTemp;
+}
+
+void IRHaierACYRW02::setHealth(bool state) {
+ setButton(kHaierAcYrw02ButtonHealth);
+ remote_state[3] &= 0b11111101;
+ remote_state[3] |= (state << 1);
+}
+
+bool IRHaierACYRW02::getHealth(void) { return remote_state[3] & 0b00000010; }
+
+bool IRHaierACYRW02::getPower() { return remote_state[4] & kHaierAcYrw02Power; }
+
+void IRHaierACYRW02::setPower(bool state) {
+ setButton(kHaierAcYrw02ButtonPower);
+ if (state)
+ remote_state[4] |= kHaierAcYrw02Power;
+ else
+ remote_state[4] &= ~kHaierAcYrw02Power;
+}
+
+void IRHaierACYRW02::on() { setPower(true); }
+
+void IRHaierACYRW02::off() { setPower(false); }
+
+bool IRHaierACYRW02::getSleep() { return remote_state[8] & kHaierAcYrw02Sleep; }
+
+void IRHaierACYRW02::setSleep(bool state) {
+ setButton(kHaierAcYrw02ButtonSleep);
+ if (state)
+ remote_state[8] |= kHaierAcYrw02Sleep;
+ else
+ remote_state[8] &= ~kHaierAcYrw02Sleep;
+}
+
+uint8_t IRHaierACYRW02::getTurbo() { return remote_state[6] >> 6; }
+
+void IRHaierACYRW02::setTurbo(uint8_t speed) {
+ switch (speed) {
+ case kHaierAcYrw02TurboOff:
+ case kHaierAcYrw02TurboLow:
+ case kHaierAcYrw02TurboHigh:
+ remote_state[6] &= 0b00111111;
+ remote_state[6] |= (speed << 6);
+ setButton(kHaierAcYrw02ButtonTurbo);
+ }
+}
+
+uint8_t IRHaierACYRW02::getFan() { return remote_state[5] >> 4; }
+
+void IRHaierACYRW02::setFan(uint8_t speed) {
+ switch (speed) {
+ case kHaierAcYrw02FanLow:
+ case kHaierAcYrw02FanMed:
+ case kHaierAcYrw02FanHigh:
+ case kHaierAcYrw02FanAuto:
+ remote_state[5] &= 0b00001111;
+ remote_state[5] |= (speed << 4);
+ setButton(kHaierAcYrw02ButtonFan);
+ }
+}
+
+uint8_t IRHaierACYRW02::getSwing() { return remote_state[1] & 0b00001111; }
+
+void IRHaierACYRW02::setSwing(uint8_t state) {
+ uint8_t newstate = state;
+ switch (state) {
+ case kHaierAcYrw02SwingOff:
+ case kHaierAcYrw02SwingAuto:
+ case kHaierAcYrw02SwingTop:
+ case kHaierAcYrw02SwingMiddle:
+ case kHaierAcYrw02SwingBottom:
+ case kHaierAcYrw02SwingDown:
+ setButton(kHaierAcYrw02ButtonSwing);
+ break;
+ default:
+ return; // Unexpected value so don't do anything.
+ }
+
+ // Heat mode has no MIDDLE setting, use BOTTOM instead.
+ if (state == kHaierAcYrw02SwingMiddle && getMode() == kHaierAcYrw02Heat)
+ newstate = kHaierAcYrw02SwingBottom;
+
+ // BOTTOM is only allowed if we are in Heat mode, otherwise MIDDLE.
+ if (state == kHaierAcYrw02SwingBottom && getMode() != kHaierAcYrw02Heat)
+ newstate = kHaierAcYrw02SwingMiddle;
+
+ remote_state[1] &= 0b11110000;
+ remote_state[1] |= newstate;
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRHaierACYRW02::toString() {
+ String result = "";
+#else
+std::string IRHaierACYRW02::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ uint8_t cmd = getButton();
+ result += ", Button: " + uint64ToString(cmd) + " (";
+ switch (cmd) {
+ case kHaierAcYrw02ButtonPower:
+ result += "Power";
+ break;
+ case kHaierAcYrw02ButtonMode:
+ result += "Mode";
+ break;
+ case kHaierAcYrw02ButtonFan:
+ result += "Fan";
+ break;
+ case kHaierAcYrw02ButtonTempUp:
+ result += "Temp Up";
+ break;
+ case kHaierAcYrw02ButtonTempDown:
+ result += "Temp Down";
+ break;
+ case kHaierAcYrw02ButtonSleep:
+ result += "Sleep";
+ break;
+ case kHaierAcYrw02ButtonHealth:
+ result += "Health";
+ break;
+ case kHaierAcYrw02ButtonSwing:
+ result += "Swing";
+ break;
+ case kHaierAcYrw02ButtonTurbo:
+ result += "Turbo";
+ break;
+ default:
+ result += "Unknown";
+ }
+ result += ")";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kHaierAcYrw02Auto:
+ result += " (Auto)";
+ break;
+ case kHaierAcYrw02Cool:
+ result += " (Cool)";
+ break;
+ case kHaierAcYrw02Heat:
+ result += " (Heat)";
+ break;
+ case kHaierAcYrw02Dry:
+ result += " (Dry)";
+ break;
+ case kHaierAcYrw02Fan:
+ result += " (Fan)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kHaierAcYrw02FanAuto:
+ result += " (Auto)";
+ break;
+ case kHaierAcYrw02FanHigh:
+ result += " (High)";
+ break;
+ case kHaierAcYrw02FanLow:
+ result += " (Low)";
+ break;
+ case kHaierAcYrw02FanMed:
+ result += " (Med)";
+ break;
+ default:
+ result += " (Unknown)";
+ }
+ result += ", Turbo: " + uint64ToString(getTurbo()) + " (";
+ switch (getTurbo()) {
+ case kHaierAcYrw02TurboOff:
+ result += "Off";
+ break;
+ case kHaierAcYrw02TurboLow:
+ result += "Low";
+ break;
+ case kHaierAcYrw02TurboHigh:
+ result += "High";
+ break;
+ default:
+ result += "Unknown";
+ }
+ result += ")";
+ result += ", Swing: " + uint64ToString(getSwing()) + " (";
+ switch (getSwing()) {
+ case kHaierAcYrw02SwingOff:
+ result += "Off";
+ break;
+ case kHaierAcYrw02SwingAuto:
+ result += "Auto";
+ break;
+ case kHaierAcYrw02SwingBottom:
+ result += "Bottom";
+ break;
+ case kHaierAcYrw02SwingDown:
+ result += "Down";
+ break;
+ case kHaierAcYrw02SwingTop:
+ result += "Top";
+ break;
+ case kHaierAcYrw02SwingMiddle:
+ result += "Middle";
+ break;
+ default:
+ result += "Unknown";
+ }
+ result += ")";
+ result += ", Sleep: ";
+ if (getSleep())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Health: ";
+ if (getHealth())
+ result += "On";
+ else
+ result += "Off";
+
+ return result;
+}
+// End of IRHaierACYRW02 class.
+
+#if (DECODE_HAIER_AC || DECODE_HAIER_AC_YRW02)
+// Decode the supplied Haier HSU07-HEA03 remote message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kHaierACBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Appears to be working.
+//
+bool IRrecv::decodeHaierAC(decode_results* results, uint16_t nbits,
+ bool strict) {
+ if (nbits % 8 != 0) // nbits has to be a multiple of nr. of bits in a byte.
+ return false;
+
+ if (strict) {
+ if (nbits != kHaierACBits)
+ return false; // Not strictly a HAIER_AC message.
+ }
+
+ if (results->rawlen < (2 * nbits + kHeader) + kFooter - 1)
+ return false; // Can't possibly be a valid HAIER_AC message.
+
+ uint16_t offset = kStartOffset;
+
+ // Header
+ if (!matchMark(results->rawbuf[offset++], kHaierAcHdr)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kHaierAcHdr)) return false;
+ if (!matchMark(results->rawbuf[offset++], kHaierAcHdr)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kHaierAcHdrGap)) return false;
+
+ // Data
+ for (uint16_t i = 0; i < nbits / 8; i++) {
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), 8, kHaierAcBitMark,
+ kHaierAcOneSpace, kHaierAcBitMark, kHaierAcZeroSpace);
+ if (data_result.success == false) return false;
+ offset += data_result.used;
+ results->state[i] = (uint8_t)data_result.data;
+ }
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kHaierAcBitMark)) return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kHaierAcMinGap))
+ return false;
+
+ // Compliance
+ if (strict) {
+ if (results->state[0] != kHaierAcPrefix) return false;
+ if (!IRHaierAC::validChecksum(results->state, nbits / 8)) return false;
+ }
+
+ // Success
+ results->decode_type = HAIER_AC;
+ results->bits = nbits;
+ return true;
+}
+#endif // (DECODE_HAIER_AC || DECODE_HAIER_AC_YRW02)
+
+#if DECODE_HAIER_AC_YRW02
+// Decode the supplied Haier YR-W02 remote A/C message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kHaierACYRW02Bits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Appears to be working.
+//
+bool IRrecv::decodeHaierACYRW02(decode_results* results, uint16_t nbits,
+ bool strict) {
+ if (strict) {
+ if (nbits != kHaierACYRW02Bits)
+ return false; // Not strictly a HAIER_AC_YRW02 message.
+ }
+
+ // The protocol is almost exactly the same as HAIER_AC
+ if (!decodeHaierAC(results, nbits, false)) return false;
+
+ // Compliance
+ if (strict) {
+ if (results->state[0] != kHaierAcYrw02Prefix) return false;
+ if (!IRHaierACYRW02::validChecksum(results->state, nbits / 8)) return false;
+ }
+
+ // Success
+ // It looks correct, but we haven't check the checksum etc.
+ results->decode_type = HAIER_AC_YRW02;
+ return true;
+}
+#endif // DECODE_HAIER_AC_YRW02
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Haier.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Haier.h
new file mode 100644
index 000000000000..fdc15a3a8ebe
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Haier.h
@@ -0,0 +1,297 @@
+// Copyright 2018 crankyoldgit
+// The specifics of reverse engineering the protocol details by kuzin2006
+
+#ifndef IR_HAIER_H_
+#define IR_HAIER_H_
+
+#ifndef UNIT_TEST
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// HH HH AAA IIIII EEEEEEE RRRRRR
+// HH HH AAAAA III EE RR RR
+// HHHHHHH AA AA III EEEEE RRRRRR
+// HH HH AAAAAAA III EE RR RR
+// HH HH AA AA IIIII EEEEEEE RR RR
+
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/404
+// https://www.dropbox.com/s/mecyib3lhdxc8c6/IR%20data%20reverse%20engineering.xlsx?dl=0
+// https://github.com/markszabo/IRremoteESP8266/issues/485
+// https://www.dropbox.com/sh/w0bt7egp0fjger5/AADRFV6Wg4wZskJVdFvzb8Z0a?dl=0&preview=haer2.ods
+
+// Constants
+
+// Haier HSU07-HEA03 remote
+// Byte 0
+const uint8_t kHaierAcPrefix = 0b10100101;
+
+// Byte 1
+const uint8_t kHaierAcMinTemp = 16;
+const uint8_t kHaierAcDefTemp = 25;
+const uint8_t kHaierAcMaxTemp = 30;
+const uint8_t kHaierAcCmdOff = 0b00000000;
+const uint8_t kHaierAcCmdOn = 0b00000001;
+const uint8_t kHaierAcCmdMode = 0b00000010;
+const uint8_t kHaierAcCmdFan = 0b00000011;
+const uint8_t kHaierAcCmdTempUp = 0b00000110;
+const uint8_t kHaierAcCmdTempDown = 0b00000111;
+const uint8_t kHaierAcCmdSleep = 0b00001000;
+const uint8_t kHaierAcCmdTimerSet = 0b00001001;
+const uint8_t kHaierAcCmdTimerCancel = 0b00001010;
+const uint8_t kHaierAcCmdHealth = 0b00001100;
+const uint8_t kHaierAcCmdSwing = 0b00001101;
+
+// Byte 2
+const uint8_t kHaierAcSwingOff = 0b00000000;
+const uint8_t kHaierAcSwingUp = 0b00000001;
+const uint8_t kHaierAcSwingDown = 0b00000010;
+const uint8_t kHaierAcSwingChg = 0b00000011;
+
+// Byte 6
+const uint8_t kHaierAcAuto = 0;
+const uint8_t kHaierAcCool = 1;
+const uint8_t kHaierAcDry = 2;
+const uint8_t kHaierAcHeat = 3;
+const uint8_t kHaierAcFan = 4;
+
+const uint8_t kHaierAcFanAuto = 0;
+const uint8_t kHaierAcFanLow = 1;
+const uint8_t kHaierAcFanMed = 2;
+const uint8_t kHaierAcFanHigh = 3;
+
+const uint16_t kHaierAcMaxTime = (23 * 60) + 59;
+
+// Legacy Haier AC defines.
+#define HAIER_AC_MIN_TEMP kHaierAcMinTemp
+#define HAIER_AC_DEF_TEMP kHaierAcDefTemp
+#define HAIER_AC_MAX_TEMP kHaierAcMaxTemp
+#define HAIER_AC_CMD_OFF kHaierAcCmdOff
+#define HAIER_AC_CMD_ON kHaierAcCmdOn
+#define HAIER_AC_CMD_MODE kHaierAcCmdMode
+#define HAIER_AC_CMD_FAN kHaierAcCmdFan
+#define HAIER_AC_CMD_TEMP_UP kHaierAcCmdTempUp
+#define HAIER_AC_CMD_TEMP_DOWN kHaierAcCmdTempDown
+#define HAIER_AC_CMD_SLEEP kHaierAcCmdSleep
+#define HAIER_AC_CMD_TIMER_SET kHaierAcCmdTimerSet
+#define HAIER_AC_CMD_TIMER_CANCEL kHaierAcCmdTimerCancel
+#define HAIER_AC_CMD_HEALTH kHaierAcCmdHealth
+#define HAIER_AC_CMD_SWING kHaierAcCmdSwing
+#define HAIER_AC_SWING_OFF kHaierAcSwingOff
+#define HAIER_AC_SWING_UP kHaierAcSwingUp
+#define HAIER_AC_SWING_DOWN kHaierAcSwingDown
+#define HAIER_AC_SWING_CHG kHaierAcSwingChg
+#define HAIER_AC_AUTO kHaierAcAuto
+#define HAIER_AC_COOL kHaierAcCool
+#define HAIER_AC_DRY kHaierAcDry
+#define HAIER_AC_HEAT kHaierAcHeat
+#define HAIER_AC_FAN kHaierAcFan
+#define HAIER_AC_FAN_AUTO kHaierAcFanAuto
+#define HAIER_AC_FAN_LOW kHaierAcFanLow
+#define HAIER_AC_FAN_MED kHaierAcFanMed
+#define HAIER_AC_FAN_HIGH kHaierAcFanHigh
+
+// Haier YRW02 remote
+// Byte 0
+const uint8_t kHaierAcYrw02Prefix = 0xA6;
+
+// Byte 1
+// Bits 0-3
+// 0x0 = 16DegC, ... 0xE = 30DegC
+// Bits 4-7 - Swing
+const uint8_t kHaierAcYrw02SwingOff = 0x0;
+const uint8_t kHaierAcYrw02SwingTop = 0x1;
+const uint8_t kHaierAcYrw02SwingMiddle = 0x2; // Not available in heat mode.
+const uint8_t kHaierAcYrw02SwingBottom = 0x3; // Only available in heat mode.
+const uint8_t kHaierAcYrw02SwingDown = 0xA;
+const uint8_t kHaierAcYrw02SwingAuto = 0xC; // Airflow
+
+// Byte 3
+// Bit 7 - Health mode
+
+// Byte 4
+const uint8_t kHaierAcYrw02Power = 0b01000000;
+
+// Byte 5
+// Bits 0-3
+const uint8_t kHaierAcYrw02FanHigh = 0x2;
+const uint8_t kHaierAcYrw02FanMed = 0x4;
+const uint8_t kHaierAcYrw02FanLow = 0x6;
+const uint8_t kHaierAcYrw02FanAuto = 0xA;
+
+// Byte 6
+// Bits 0-1
+const uint8_t kHaierAcYrw02TurboOff = 0x0;
+const uint8_t kHaierAcYrw02TurboHigh = 0x1;
+const uint8_t kHaierAcYrw02TurboLow = 0x2;
+
+// Byte 7
+// Bits 0-3
+const uint8_t kHaierAcYrw02Auto = 0x0;
+const uint8_t kHaierAcYrw02Cool = 0x2;
+const uint8_t kHaierAcYrw02Dry = 0x4;
+const uint8_t kHaierAcYrw02Heat = 0x8;
+const uint8_t kHaierAcYrw02Fan = 0xC;
+
+// Byte 8
+const uint8_t kHaierAcYrw02Sleep = 0b10000000;
+
+// Byte 12
+// Bits 4-7
+const uint8_t kHaierAcYrw02ButtonTempUp = 0x0;
+const uint8_t kHaierAcYrw02ButtonTempDown = 0x1;
+const uint8_t kHaierAcYrw02ButtonSwing = 0x2;
+const uint8_t kHaierAcYrw02ButtonFan = 0x4;
+const uint8_t kHaierAcYrw02ButtonPower = 0x5;
+const uint8_t kHaierAcYrw02ButtonMode = 0x6;
+const uint8_t kHaierAcYrw02ButtonHealth = 0x7;
+const uint8_t kHaierAcYrw02ButtonTurbo = 0x8;
+const uint8_t kHaierAcYrw02ButtonSleep = 0xB;
+
+// Legacy Haier YRW02 remote defines.
+#define HAIER_AC_YRW02_SWING_OFF kHaierAcYrw02SwingOff
+#define HAIER_AC_YRW02_SWING_TOP kHaierAcYrw02SwingTop
+#define HAIER_AC_YRW02_SWING_MIDDLE kHaierAcYrw02SwingMiddle
+#define HAIER_AC_YRW02_SWING_BOTTOM kHaierAcYrw02SwingBottom
+#define HAIER_AC_YRW02_SWING_DOWN kHaierAcYrw02SwingDown
+#define HAIER_AC_YRW02_SWING_AUTO kHaierAcYrw02SwingAuto
+#define HAIER_AC_YRW02_FAN_HIGH kHaierAcYrw02FanHigh
+#define HAIER_AC_YRW02_FAN_MED kHaierAcYrw02FanMed
+#define HAIER_AC_YRW02_FAN_LOW kHaierAcYrw02FanLow
+#define HAIER_AC_YRW02_FAN_AUTO kHaierAcYrw02FanAuto
+#define HAIER_AC_YRW02_TURBO_OFF kHaierAcYrw02TurboOff
+#define HAIER_AC_YRW02_TURBO_HIGH kHaierAcYrw02TurboHigh
+#define HAIER_AC_YRW02_TURBO_LOW kHaierAcYrw02TurboLow
+#define HAIER_AC_YRW02_AUTO kHaierAcYrw02Auto
+#define HAIER_AC_YRW02_COOL kHaierAcYrw02Cool
+#define HAIER_AC_YRW02_DRY kHaierAcYrw02Dry
+#define HAIER_AC_YRW02_HEAT kHaierAcYrw02Heat
+#define HAIER_AC_YRW02_FAN kHaierAcYrw02Fan
+#define HAIER_AC_YRW02_BUTTON_TEMP_UP kHaierAcYrw02ButtonTempUp
+#define HAIER_AC_YRW02_BUTTON_TEMP_DOWN kHaierAcYrw02ButtonTempDown
+#define HAIER_AC_YRW02_BUTTON_SWING kHaierAcYrw02ButtonSwing
+#define HAIER_AC_YRW02_BUTTON_FAN kHaierAcYrw02ButtonFan
+#define HAIER_AC_YRW02_BUTTON_POWER kHaierAcYrw02ButtonPower
+#define HAIER_AC_YRW02_BUTTON_MODE kHaierAcYrw02ButtonMode
+#define HAIER_AC_YRW02_BUTTON_HEALTH kHaierAcYrw02ButtonHealth
+#define HAIER_AC_YRW02_BUTTON_TURBO kHaierAcYrw02ButtonTurbo
+#define HAIER_AC_YRW02_BUTTON_SLEEP kHaierAcYrw02ButtonSleep
+
+class IRHaierAC {
+ public:
+ explicit IRHaierAC(uint16_t pin);
+
+#if SEND_HAIER_AC
+ void send();
+#endif // SEND_HAIER_AC
+ void begin();
+
+ void setCommand(const uint8_t command);
+ uint8_t getCommand();
+
+ void setTemp(const uint8_t temp);
+ uint8_t getTemp();
+
+ void setFan(const uint8_t speed);
+ uint8_t getFan();
+
+ uint8_t getMode();
+ void setMode(const uint8_t mode);
+
+ bool getSleep();
+ void setSleep(const bool state);
+ bool getHealth();
+ void setHealth(const bool state);
+
+ int16_t getOnTimer();
+ void setOnTimer(const uint16_t mins);
+ int16_t getOffTimer();
+ void setOffTimer(const uint16_t mins);
+ void cancelTimers();
+
+ uint16_t getCurrTime();
+ void setCurrTime(const uint16_t mins);
+
+ uint8_t getSwing();
+ void setSwing(const uint8_t state);
+
+ uint8_t* getRaw();
+ void setRaw(uint8_t new_code[]);
+ static bool validChecksum(uint8_t state[],
+ const uint16_t length = kHaierACStateLength);
+#ifdef ARDUINO
+ String toString();
+ static String timeToString(const uint16_t nr_mins);
+#else
+ std::string toString();
+ static std::string timeToString(const uint16_t nr_mins);
+#endif
+
+ private:
+ uint8_t remote_state[kHaierACStateLength];
+ void stateReset();
+ void checksum();
+ static uint16_t getTime(const uint8_t ptr[]);
+ static void setTime(uint8_t ptr[], const uint16_t nr_mins);
+ IRsend _irsend;
+};
+
+class IRHaierACYRW02 {
+ public:
+ explicit IRHaierACYRW02(uint16_t pin);
+
+#if SEND_HAIER_AC_YRW02
+ void send();
+#endif // SEND_HAIER_AC_YRW02
+ void begin();
+
+ void setButton(const uint8_t button);
+ uint8_t getButton();
+
+ void setTemp(const uint8_t temp);
+ uint8_t getTemp();
+
+ void setFan(const uint8_t speed);
+ uint8_t getFan();
+
+ uint8_t getMode();
+ void setMode(const uint8_t mode);
+
+ bool getPower();
+ void setPower(const bool state);
+ void on();
+ void off();
+
+ bool getSleep();
+ void setSleep(const bool state);
+ bool getHealth();
+ void setHealth(const bool state);
+
+ uint8_t getTurbo();
+ void setTurbo(const uint8_t speed);
+
+ uint8_t getSwing();
+ void setSwing(const uint8_t state);
+
+ uint8_t* getRaw();
+ void setRaw(uint8_t new_code[]);
+ static bool validChecksum(uint8_t state[],
+ const uint16_t length = kHaierACYRW02StateLength);
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
+
+ private:
+ uint8_t remote_state[kHaierACYRW02StateLength];
+ void stateReset();
+ void checksum();
+ IRsend _irsend;
+};
+
+#endif // IR_HAIER_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Hitachi.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Hitachi.cpp
new file mode 100644
index 000000000000..111051974c84
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Hitachi.cpp
@@ -0,0 +1,424 @@
+// Copyright 2018 David Conran
+//
+// Code to emulate Hitachi protocol compatible devices.
+// Should be compatible with:
+// * Hitachi RAS-35THA6 remote
+//
+
+#include "ir_Hitachi.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// HH HH IIIII TTTTTTT AAA CCCCC HH HH IIIII
+// HH HH III TTT AAAAA CC C HH HH III
+// HHHHHHH III TTT AA AA CC HHHHHHH III
+// HH HH III TTT AAAAAAA CC C HH HH III
+// HH HH IIIII TTT AA AA CCCCC HH HH IIIII
+
+// Constants
+// Ref: https://github.com/markszabo/IRremoteESP8266/issues/417
+const uint16_t kHitachiAcHdrMark = 3300;
+const uint16_t kHitachiAcHdrSpace = 1700;
+const uint16_t kHitachiAc1HdrMark = 3400;
+const uint16_t kHitachiAc1HdrSpace = 3400;
+const uint16_t kHitachiAcBitMark = 400;
+const uint16_t kHitachiAcOneSpace = 1250;
+const uint16_t kHitachiAcZeroSpace = 500;
+const uint32_t kHitachiAcMinGap = 100000; // Completely made up value.
+
+#if (SEND_HITACHI_AC || SEND_HITACHI_AC2)
+// Send a Hitachi A/C message.
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kHitachiAcStateLength)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: ALPHA / Untested.
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/417
+void IRsend::sendHitachiAC(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kHitachiAcStateLength)
+ return; // Not enough bytes to send a proper message.
+ sendGeneric(kHitachiAcHdrMark, kHitachiAcHdrSpace, kHitachiAcBitMark,
+ kHitachiAcOneSpace, kHitachiAcBitMark, kHitachiAcZeroSpace,
+ kHitachiAcBitMark, kHitachiAcMinGap, data, nbytes, 38, true,
+ repeat, 50);
+}
+#endif // (SEND_HITACHI_AC || SEND_HITACHI_AC2)
+
+#if SEND_HITACHI_AC1
+// Send a Hitachi A/C 13-byte message.
+//
+// For devices:
+// Hitachi A/C Series VI (Circa 2007) / Remote: LT0541-HTA
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kHitachiAc1StateLength)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: BETA / Appears to work.
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/453
+// Basically the same as sendHitatchiAC() except different size and header.
+void IRsend::sendHitachiAC1(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kHitachiAc1StateLength)
+ return; // Not enough bytes to send a proper message.
+ sendGeneric(kHitachiAc1HdrMark, kHitachiAc1HdrSpace, kHitachiAcBitMark,
+ kHitachiAcOneSpace, kHitachiAcBitMark, kHitachiAcZeroSpace,
+ kHitachiAcBitMark, kHitachiAcMinGap, data, nbytes, 38, true,
+ repeat, 50);
+}
+#endif // SEND_HITACHI_AC1
+
+#if SEND_HITACHI_AC2
+// Send a Hitachi A/C 53-byte message.
+//
+// For devices:
+// Hitachi A/C Series VI (Circa 2007) / Remote: LT0541-HTA
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kHitachiAc2StateLength)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: BETA / Appears to work.
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/417
+// Basically the same as sendHitatchiAC() except different size.
+void IRsend::sendHitachiAC2(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kHitachiAc2StateLength)
+ return; // Not enough bytes to send a proper message.
+ sendHitachiAC(data, nbytes, repeat);
+}
+#endif // SEND_HITACHI_AC2
+
+// Class for handling the remote control oh a Hitachi 28 byte A/C message.
+// Inspired by:
+// https://github.com/ToniA/arduino-heatpumpir/blob/master/HitachiHeatpumpIR.cpp
+
+IRHitachiAc::IRHitachiAc(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRHitachiAc::stateReset() {
+ remote_state[0] = 0x80;
+ remote_state[1] = 0x08;
+ remote_state[2] = 0x0C;
+ remote_state[3] = 0x02;
+ remote_state[4] = 0xFD;
+ remote_state[5] = 0x80;
+ remote_state[6] = 0x7F;
+ remote_state[7] = 0x88;
+ remote_state[8] = 0x48;
+ remote_state[9] = 0x10;
+ for (uint8_t i = 10; i < kHitachiAcStateLength; i++) remote_state[i] = 0x00;
+ remote_state[14] = 0x60;
+ remote_state[15] = 0x60;
+ remote_state[24] = 0x80;
+ setTemp(23);
+}
+
+void IRHitachiAc::begin() { _irsend.begin(); }
+
+uint8_t IRHitachiAc::calcChecksum(const uint8_t state[],
+ const uint16_t length) {
+ int8_t sum = 62;
+ for (uint16_t i = 0; i < length - 1; i++) sum -= reverseBits(state[i], 8);
+ return reverseBits((uint8_t)sum, 8);
+}
+
+void IRHitachiAc::checksum(const uint16_t length) {
+ remote_state[length - 1] = calcChecksum(remote_state, length);
+}
+
+bool IRHitachiAc::validChecksum(const uint8_t state[], const uint16_t length) {
+ if (length < 2) return true; // Assume true for lengths that are too short.
+ return (state[length - 1] == calcChecksum(state, length));
+}
+
+uint8_t *IRHitachiAc::getRaw() {
+ checksum();
+ return remote_state;
+}
+
+void IRHitachiAc::setRaw(const uint8_t new_code[], const uint16_t length) {
+ for (uint8_t i = 0; i < length && i < kHitachiAcStateLength; i++)
+ remote_state[i] = new_code[i];
+}
+
+#if SEND_HITACHI_AC
+void IRHitachiAc::send() {
+ checksum();
+ _irsend.sendHitachiAC(remote_state);
+}
+#endif // SEND_HITACHI_AC
+
+bool IRHitachiAc::getPower() { return (remote_state[17] & 0x01); }
+
+void IRHitachiAc::setPower(const bool on) {
+ if (on)
+ remote_state[17] |= 0x01;
+ else
+ remote_state[17] &= 0xFE;
+}
+
+void IRHitachiAc::on() { setPower(true); }
+
+void IRHitachiAc::off() { setPower(false); }
+
+uint8_t IRHitachiAc::getMode() { return reverseBits(remote_state[10], 8); }
+
+void IRHitachiAc::setMode(const uint8_t mode) {
+ uint8_t newmode = mode;
+ switch (mode) {
+ case kHitachiAcFan:
+ // Fan mode sets a special temp.
+ setTemp(64);
+ break;
+ case kHitachiAcAuto:
+ case kHitachiAcHeat:
+ case kHitachiAcCool:
+ case kHitachiAcDry:
+ break;
+ default:
+ newmode = kHitachiAcAuto;
+ }
+ remote_state[10] = reverseBits(newmode, 8);
+ if (mode != kHitachiAcFan) setTemp(_previoustemp);
+ setFan(getFan()); // Reset the fan speed after the mode change.
+}
+
+uint8_t IRHitachiAc::getTemp() { return reverseBits(remote_state[11], 8) >> 1; }
+
+void IRHitachiAc::setTemp(const uint8_t celsius) {
+ uint8_t temp;
+ if (celsius != 64) _previoustemp = celsius;
+ switch (celsius) {
+ case 64:
+ temp = celsius;
+ break;
+ default:
+ temp = std::min(celsius, kHitachiAcMaxTemp);
+ temp = std::max(temp, kHitachiAcMinTemp);
+ }
+ remote_state[11] = reverseBits(temp << 1, 8);
+ if (temp == kHitachiAcMinTemp)
+ remote_state[9] = 0x90;
+ else
+ remote_state[9] = 0x10;
+}
+
+uint8_t IRHitachiAc::getFan() { return reverseBits(remote_state[13], 8); }
+
+void IRHitachiAc::setFan(const uint8_t speed) {
+ uint8_t fanmin = kHitachiAcFanAuto;
+ uint8_t fanmax = kHitachiAcFanHigh;
+ switch (getMode()) {
+ case kHitachiAcDry: // Only 2 x low speeds in Dry mode.
+ fanmin = kHitachiAcFanLow;
+ fanmax = kHitachiAcFanLow + 1;
+ break;
+ case kHitachiAcFan:
+ fanmin = kHitachiAcFanLow; // No Auto in Fan mode.
+ break;
+ }
+ uint8_t newspeed = std::max(speed, fanmin);
+ newspeed = std::min(newspeed, fanmax);
+ remote_state[13] = reverseBits(newspeed, 8);
+}
+
+bool IRHitachiAc::getSwingVertical() { return remote_state[14] & 0x80; }
+
+void IRHitachiAc::setSwingVertical(const bool on) {
+ if (on)
+ remote_state[14] |= 0x80;
+ else
+ remote_state[14] &= 0x7F;
+}
+
+bool IRHitachiAc::getSwingHorizontal() { return remote_state[15] & 0x80; }
+
+void IRHitachiAc::setSwingHorizontal(const bool on) {
+ if (on)
+ remote_state[15] |= 0x80;
+ else
+ remote_state[15] &= 0x7F;
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRHitachiAc::toString() {
+ String result = "";
+#else
+std::string IRHitachiAc::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kHitachiAcAuto:
+ result += " (AUTO)";
+ break;
+ case kHitachiAcCool:
+ result += " (COOL)";
+ break;
+ case kHitachiAcHeat:
+ result += " (HEAT)";
+ break;
+ case kHitachiAcDry:
+ result += " (DRY)";
+ break;
+ case kHitachiAcFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kHitachiAcFanAuto:
+ result += " (AUTO)";
+ break;
+ case kHitachiAcFanLow:
+ result += " (LOW)";
+ break;
+ case kHitachiAcFanHigh:
+ result += " (HIGH)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ break;
+ }
+ result += ", Swing (Vertical): ";
+ if (getSwingVertical())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Swing (Horizontal): ";
+ if (getSwingHorizontal())
+ result += "On";
+ else
+ result += "Off";
+ return result;
+}
+
+#if (DECODE_HITACHI_AC || DECODE_HITACHI_AC1 || DECODE_HITACHI_AC2)
+// Decode the supplied Hitachi A/C message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect.
+// Typically kHitachiAcBits, kHitachiAc1Bits, kHitachiAc2Bits
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: ALPHA / Untested.
+//
+// Supported devices:
+// Hitachi A/C Series VI (Circa 2007) / Remote: LT0541-HTA
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/417
+// https://github.com/markszabo/IRremoteESP8266/issues/453
+bool IRrecv::decodeHitachiAC(decode_results *results, uint16_t nbits,
+ bool strict) {
+ const uint8_t kTolerance = 30;
+ if (results->rawlen < 2 * nbits + kHeader + kFooter - 1)
+ return false; // Can't possibly be a valid HitachiAC message.
+ if (strict) {
+ switch (nbits) {
+ case kHitachiAcBits:
+ case kHitachiAc1Bits:
+ case kHitachiAc2Bits:
+ break; // Okay to continue.
+ default:
+ return false; // Not strictly a Hitachi message.
+ }
+ }
+ uint16_t offset = kStartOffset;
+ uint16_t dataBitsSoFar = 0;
+ match_result_t data_result;
+
+ // Header
+ if (nbits == kHitachiAc1Bits) {
+ if (!matchMark(results->rawbuf[offset++], kHitachiAc1HdrMark, kTolerance))
+ return false;
+ if (!matchSpace(results->rawbuf[offset++], kHitachiAc1HdrSpace, kTolerance))
+ return false;
+ } else { // Everything else.
+ if (!matchMark(results->rawbuf[offset++], kHitachiAcHdrMark, kTolerance))
+ return false;
+ if (!matchSpace(results->rawbuf[offset++], kHitachiAcHdrSpace, kTolerance))
+ return false;
+ }
+ // Data
+ // Keep reading bytes until we either run out of message or state to fill.
+ for (uint16_t i = 0; offset <= results->rawlen - 16 && i < nbits / 8;
+ i++, dataBitsSoFar += 8, offset += data_result.used) {
+ data_result = matchData(&(results->rawbuf[offset]), 8, kHitachiAcBitMark,
+ kHitachiAcOneSpace, kHitachiAcBitMark,
+ kHitachiAcZeroSpace, kTolerance);
+ if (data_result.success == false) break; // Fail
+ results->state[i] = (uint8_t)data_result.data;
+ }
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kHitachiAcBitMark, kTolerance))
+ return false;
+ if (offset <= results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kHitachiAcMinGap, kTolerance))
+ return false;
+
+ // Compliance
+ if (strict) {
+ // Re-check we got the correct size/length due to the way we read the data.
+ switch (dataBitsSoFar / 8) {
+ case kHitachiAcStateLength:
+ case kHitachiAc1StateLength:
+ case kHitachiAc2StateLength:
+ break; // Continue
+ default:
+ return false;
+ }
+ if (dataBitsSoFar / 8 == kHitachiAcStateLength &&
+ !IRHitachiAc::validChecksum(results->state, kHitachiAcStateLength))
+ return false;
+ }
+
+ // Success
+ switch (dataBitsSoFar) {
+ case kHitachiAc1Bits:
+ results->decode_type = HITACHI_AC1;
+ break;
+ case kHitachiAc2Bits:
+ results->decode_type = HITACHI_AC2;
+ break;
+ case kHitachiAcBits:
+ default:
+ results->decode_type = HITACHI_AC;
+ }
+ results->bits = dataBitsSoFar;
+ // No need to record the state as we stored it as we decoded it.
+ // As we use result->state, we don't record value, address, or command as it
+ // is a union data type.
+ return true;
+}
+#endif // (DECODE_HITACHI_AC || DECODE_HITACHI_AC1 || DECODE_HITACHI_AC2)
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Hitachi.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Hitachi.h
new file mode 100644
index 000000000000..eddab59e43c6
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Hitachi.h
@@ -0,0 +1,76 @@
+// Hitachi A/C
+//
+// Copyright 2018 David Conran
+
+#ifndef IR_HITACHI_H_
+#define IR_HITACHI_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifndef UNIT_TEST
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// Constants
+const uint8_t kHitachiAcAuto = 2;
+const uint8_t kHitachiAcHeat = 3;
+const uint8_t kHitachiAcCool = 4;
+const uint8_t kHitachiAcDry = 5;
+const uint8_t kHitachiAcFan = 0xC;
+const uint8_t kHitachiAcFanAuto = 1;
+const uint8_t kHitachiAcFanLow = 2;
+const uint8_t kHitachiAcFanHigh = 5;
+const uint8_t kHitachiAcMinTemp = 16; // 16C
+const uint8_t kHitachiAcMaxTemp = 32; // 32C
+const uint8_t kHitachiAcAutoTemp = 23; // 23C
+
+// Classes
+class IRHitachiAc {
+ public:
+ explicit IRHitachiAc(uint16_t pin);
+
+ void stateReset();
+#if SEND_HITACHI_AC
+ void send();
+#endif // SEND_HITACHI_AC
+ void begin();
+ void on();
+ void off();
+ void setPower(const bool on);
+ bool getPower();
+ void setTemp(const uint8_t temp);
+ uint8_t getTemp();
+ void setFan(const uint8_t speed);
+ uint8_t getFan();
+ void setMode(const uint8_t mode);
+ uint8_t getMode();
+ void setSwingVertical(const bool on);
+ bool getSwingVertical();
+ void setSwingHorizontal(const bool on);
+ bool getSwingHorizontal();
+ uint8_t* getRaw();
+ void setRaw(const uint8_t new_code[],
+ const uint16_t length = kHitachiAcStateLength);
+ static bool validChecksum(const uint8_t state[],
+ const uint16_t length = kHitachiAcStateLength);
+ static uint8_t calcChecksum(const uint8_t state[],
+ const uint16_t length = kHitachiAcStateLength);
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
+
+ private:
+ // The state of the IR remote in IR code form.
+ uint8_t remote_state[kHitachiAcStateLength];
+ void checksum(const uint16_t length = kHitachiAcStateLength);
+ IRsend _irsend;
+ uint8_t _previoustemp;
+};
+
+#endif // IR_HITACHI_H_
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_JVC.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_JVC.cpp
similarity index 57%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_JVC.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_JVC.cpp
index 194e3925010f..47df29dc45f0 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_JVC.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_JVC.cpp
@@ -19,31 +19,31 @@
// Constants
// Ref:
// http://www.sbprojects.com/knowledge/ir/jvc.php
-#define JVC_TICK 75U
-#define JVC_HDR_MARK_TICKS 112U
-#define JVC_HDR_MARK (JVC_HDR_MARK_TICKS * JVC_TICK)
-#define JVC_HDR_SPACE_TICKS 56U
-#define JVC_HDR_SPACE (JVC_HDR_SPACE_TICKS * JVC_TICK)
-#define JVC_BIT_MARK_TICKS 7U
-#define JVC_BIT_MARK (JVC_BIT_MARK_TICKS * JVC_TICK)
-#define JVC_ONE_SPACE_TICKS 23U
-#define JVC_ONE_SPACE (JVC_ONE_SPACE_TICKS * JVC_TICK)
-#define JVC_ZERO_SPACE_TICKS 7U
-#define JVC_ZERO_SPACE (JVC_ZERO_SPACE_TICKS * JVC_TICK)
-#define JVC_RPT_LENGTH_TICKS 800U
-#define JVC_RPT_LENGTH (JVC_RPT_LENGTH_TICKS * JVC_TICK)
-#define JVC_MIN_GAP_TICKS (JVC_RPT_LENGTH_TICKS - \
- (JVC_HDR_MARK_TICKS + JVC_HDR_SPACE_TICKS + \
- JVC_BITS * (JVC_BIT_MARK_TICKS + JVC_ONE_SPACE_TICKS) + \
- JVC_BIT_MARK_TICKS))
-#define JVC_MIN_GAP (JVC_MIN_GAP_TICKS * JVC_TICK)
+const uint16_t kJvcTick = 75;
+const uint16_t kJvcHdrMarkTicks = 112;
+const uint16_t kJvcHdrMark = kJvcHdrMarkTicks * kJvcTick;
+const uint16_t kJvcHdrSpaceTicks = 56;
+const uint16_t kJvcHdrSpace = kJvcHdrSpaceTicks * kJvcTick;
+const uint16_t kJvcBitMarkTicks = 7;
+const uint16_t kJvcBitMark = kJvcBitMarkTicks * kJvcTick;
+const uint16_t kJvcOneSpaceTicks = 23;
+const uint16_t kJvcOneSpace = kJvcOneSpaceTicks * kJvcTick;
+const uint16_t kJvcZeroSpaceTicks = 7;
+const uint16_t kJvcZeroSpace = kJvcZeroSpaceTicks * kJvcTick;
+const uint16_t kJvcRptLengthTicks = 800;
+const uint16_t kJvcRptLength = kJvcRptLengthTicks * kJvcTick;
+const uint16_t kJvcMinGapTicks =
+ kJvcRptLengthTicks -
+ (kJvcHdrMarkTicks + kJvcHdrSpaceTicks +
+ kJvcBits * (kJvcBitMarkTicks + kJvcOneSpaceTicks) + kJvcBitMarkTicks);
+const uint16_t kJvcMinGap = kJvcMinGapTicks * kJvcTick;
#if SEND_JVC
// Send a JVC message.
//
// Args:
// data: The contents of the command you want to send.
-// nbits: The bit size of the command being sent. (JVC_BITS)
+// nbits: The bit size of the command being sent. (kJvcBits)
// repeat: The number of times you want the command to be repeated.
//
// Status: STABLE.
@@ -57,18 +57,21 @@ void IRsend::sendJVC(uint64_t data, uint16_t nbits, uint16_t repeat) {
IRtimer usecs = IRtimer();
// Header
// Only sent for the first message.
- mark(JVC_HDR_MARK);
- space(JVC_HDR_SPACE);
+ mark(kJvcHdrMark);
+ space(kJvcHdrSpace);
// We always send the data & footer at least once, hence '<= repeat'.
for (uint16_t i = 0; i <= repeat; i++) {
- // Data
- sendData(JVC_BIT_MARK, JVC_ONE_SPACE, JVC_BIT_MARK, JVC_ZERO_SPACE,
- data, nbits, true);
- // Footer
- mark(JVC_BIT_MARK);
+ sendGeneric(0, 0, // No Header
+ kJvcBitMark, kJvcOneSpace, kJvcBitMark, kJvcZeroSpace,
+ kJvcBitMark, kJvcMinGap, data, nbits, 38, true,
+ 0, // Repeats are handles elsewhere.
+ 33);
// Wait till the end of the repeat time window before we send another code.
- space(std::max(JVC_MIN_GAP, JVC_RPT_LENGTH - usecs.elapsed()));
+ uint32_t elapsed = usecs.elapsed();
+ // Avoid potential unsigned integer underflow.
+ // e.g. when elapsed > kJvcRptLength.
+ if (elapsed < kJvcRptLength) space(kJvcRptLength - elapsed);
usecs.reset();
}
}
@@ -95,7 +98,7 @@ uint16_t IRsend::encodeJVC(uint8_t address, uint8_t command) {
//
// Args:
// results: Ptr to the data to decode and where to store the decode result.
-// nbits: Nr. of bits of data to expect. Typically JVC_BITS.
+// nbits: Nr. of bits of data to expect. Typically kJvcBits.
// strict: Flag indicating if we should perform strict matching.
// Returns:
// boolean: True if it can decode it, false if it can't.
@@ -106,50 +109,48 @@ uint16_t IRsend::encodeJVC(uint8_t address, uint8_t command) {
// JVC repeat codes don't have a header.
// Ref:
// http://www.sbprojects.com/knowledge/ir/jvc.php
-bool IRrecv::decodeJVC(decode_results *results, uint16_t nbits, bool strict) {
- if (strict && nbits != JVC_BITS)
+bool IRrecv::decodeJVC(decode_results *results, uint16_t nbits, bool strict) {
+ if (strict && nbits != kJvcBits)
return false; // Must be called with the correct nr. of bits.
- if (results->rawlen < 2 * nbits + FOOTER - 1)
+ if (results->rawlen < 2 * nbits + kFooter - 1)
return false; // Can't possibly be a valid JVC message.
uint64_t data = 0;
- uint16_t offset = OFFSET_START;
+ uint16_t offset = kStartOffset;
bool isRepeat = true;
uint32_t m_tick;
uint32_t s_tick;
// Header
// (Optional as repeat codes don't have the header)
- if (matchMark(results->rawbuf[offset], JVC_HDR_MARK)) {
+ if (matchMark(results->rawbuf[offset], kJvcHdrMark)) {
isRepeat = false;
- m_tick = results->rawbuf[offset++] * RAWTICK / JVC_HDR_MARK_TICKS;
+ m_tick = results->rawbuf[offset++] * kRawTick / kJvcHdrMarkTicks;
if (results->rawlen < 2 * nbits + 4)
return false; // Can't possibly be a valid JVC message with a header.
- if (!matchSpace(results->rawbuf[offset], JVC_HDR_SPACE))
- return false;
- s_tick = results->rawbuf[offset++] * RAWTICK / JVC_HDR_SPACE_TICKS;
+ if (!matchSpace(results->rawbuf[offset], kJvcHdrSpace)) return false;
+ s_tick = results->rawbuf[offset++] * kRawTick / kJvcHdrSpaceTicks;
} else {
// We can't easily auto-calibrate as there is no header, so assume
// the default tick time.
- m_tick = JVC_TICK;
- s_tick = JVC_TICK;
+ m_tick = kJvcTick;
+ s_tick = kJvcTick;
}
// Data
- match_result_t data_result = matchData(&(results->rawbuf[offset]), nbits,
- JVC_BIT_MARK_TICKS * m_tick,
- JVC_ONE_SPACE_TICKS * s_tick,
- JVC_BIT_MARK_TICKS * m_tick,
- JVC_ZERO_SPACE_TICKS * s_tick);
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), nbits, kJvcBitMarkTicks * m_tick,
+ kJvcOneSpaceTicks * s_tick, kJvcBitMarkTicks * m_tick,
+ kJvcZeroSpaceTicks * s_tick);
if (data_result.success == false) return false;
data = data_result.data;
offset += data_result.used;
// Footer
- if (!matchMark(results->rawbuf[offset++], JVC_BIT_MARK_TICKS * m_tick))
+ if (!matchMark(results->rawbuf[offset++], kJvcBitMarkTicks * m_tick))
return false;
if (offset < results->rawlen &&
- !matchAtLeast(results->rawbuf[offset], JVC_MIN_GAP_TICKS * s_tick))
+ !matchAtLeast(results->rawbuf[offset], kJvcMinGapTicks * s_tick))
return false;
// Success
@@ -157,7 +158,7 @@ bool IRrecv::decodeJVC(decode_results *results, uint16_t nbits, bool strict) {
results->bits = nbits;
results->value = data;
// command & address are transmitted LSB first, so we need to reverse them.
- results->address = reverseBits(data >> 8, 8); // The first 8 bits sent.
+ results->address = reverseBits(data >> 8, 8); // The first 8 bits sent.
results->command = reverseBits(data & 0xFF, 8); // The last 8 bits sent.
results->repeat = isRepeat;
return true;
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Kelvinator.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Kelvinator.cpp
new file mode 100644
index 000000000000..ddf61b097aba
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Kelvinator.cpp
@@ -0,0 +1,550 @@
+// Copyright 2016 David Conran
+//
+// Code to emulate IR Kelvinator YALIF remote control unit, which should control
+// at least the following Kelvinator A/C units:
+// KSV26CRC, KSV26HRC, KSV35CRC, KSV35HRC, KSV53HRC, KSV62HRC, KSV70CRC,
+// KSV70HRC, KSV80HRC.
+//
+// Note:
+// * Unsupported:
+// - All Sleep modes.
+// - All Timer modes.
+// - "I Feel" button & mode.
+// - Energy Saving mode.
+// - Low Heat mode.
+// - Fahrenheit.
+
+#include "ir_Kelvinator.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// KK KK EEEEEEE LL VV VV IIIII NN NN AAA TTTTTTT OOOOO RRRRRR
+// KK KK EE LL VV VV III NNN NN AAAAA TTT OO OO RR RR
+// KKKK EEEEE LL VV VV III NN N NN AA AA TTT OO OO RRRRRR
+// KK KK EE LL VV VV III NN NNN AAAAAAA TTT OO OO RR RR
+// KK KK EEEEEEE LLLLLLL VVV IIIII NN NN AA AA TTT OOOO0 RR RR
+
+// Constants
+
+const uint16_t kKelvinatorTick = 85;
+const uint16_t kKelvinatorHdrMarkTicks = 106;
+const uint16_t kKelvinatorHdrMark = kKelvinatorHdrMarkTicks * kKelvinatorTick;
+const uint16_t kKelvinatorHdrSpaceTicks = 53;
+const uint16_t kKelvinatorHdrSpace = kKelvinatorHdrSpaceTicks * kKelvinatorTick;
+const uint16_t kKelvinatorBitMarkTicks = 8;
+const uint16_t kKelvinatorBitMark = kKelvinatorBitMarkTicks * kKelvinatorTick;
+const uint16_t kKelvinatorOneSpaceTicks = 18;
+const uint16_t kKelvinatorOneSpace = kKelvinatorOneSpaceTicks * kKelvinatorTick;
+const uint16_t kKelvinatorZeroSpaceTicks = 6;
+const uint16_t kKelvinatorZeroSpace =
+ kKelvinatorZeroSpaceTicks * kKelvinatorTick;
+const uint16_t kKelvinatorGapSpaceTicks = 235;
+const uint16_t kKelvinatorGapSpace = kKelvinatorGapSpaceTicks * kKelvinatorTick;
+
+const uint8_t kKelvinatorCmdFooter = 2;
+const uint8_t kKelvinatorCmdFooterBits = 3;
+
+const uint8_t kKelvinatorPower = 8;
+const uint8_t kKelvinatorModeMask = 0xF8;
+const uint8_t kKelvinatorFanOffset = 4;
+const uint8_t kKelvinatorBasicFanMask = 0xFF ^ (3U << kKelvinatorFanOffset);
+const uint8_t kKelvinatorFanMask = 0xFF ^ (7U << kKelvinatorFanOffset);
+const uint8_t kKelvinatorChecksumStart = 10;
+const uint8_t kKelvinatorVentSwingOffset = 6;
+const uint8_t kKelvinatorVentSwing = 1 << kKelvinatorVentSwingOffset;
+const uint8_t kKelvinatorVentSwingV = 1;
+const uint8_t kKelvinatorVentSwingH = 1 << 4;
+const uint8_t kKelvinatorSleep1And3 = 1 << 7;
+const uint8_t kKelvinatorQuietOffset = 7;
+const uint8_t kKelvinatorQuiet = 1 << kKelvinatorQuietOffset;
+const uint8_t kKelvinatorIonFilterOffset = 6;
+const uint8_t kKelvinatorIonFilter = 1 << kKelvinatorIonFilterOffset;
+const uint8_t kKelvinatorLightOffset = 5;
+const uint8_t kKelvinatorLight = 1 << kKelvinatorLightOffset;
+const uint8_t kKelvinatorXfanOffset = 7;
+const uint8_t kKelvinatorXfan = 1 << kKelvinatorXfanOffset;
+const uint8_t kKelvinatorTurboOffset = 4;
+const uint8_t kKelvinatorTurbo = 1 << kKelvinatorTurboOffset;
+
+#if SEND_KELVINATOR
+// Send a Kelvinator A/C message.
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kKelvinatorStateLength)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: STABLE / Known working.
+//
+void IRsend::sendKelvinator(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kKelvinatorStateLength)
+ return; // Not enough bytes to send a proper message.
+
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // Command Block #1 (4 bytes)
+ sendGeneric(kKelvinatorHdrMark, kKelvinatorHdrSpace, kKelvinatorBitMark,
+ kKelvinatorOneSpace, kKelvinatorBitMark, kKelvinatorZeroSpace,
+ 0, 0, // No Footer yet.
+ data, 4, 38, false, 0, 50);
+ // Send Footer for the command block (3 bits (b010))
+ sendGeneric(0, 0, // No Header
+ kKelvinatorBitMark, kKelvinatorOneSpace, kKelvinatorBitMark,
+ kKelvinatorZeroSpace, kKelvinatorBitMark, kKelvinatorGapSpace,
+ kKelvinatorCmdFooter, kKelvinatorCmdFooterBits, 38, false, 0,
+ 50);
+ // Data Block #1 (4 bytes)
+ sendGeneric(0, 0, // No header
+ kKelvinatorBitMark, kKelvinatorOneSpace, kKelvinatorBitMark,
+ kKelvinatorZeroSpace, kKelvinatorBitMark,
+ kKelvinatorGapSpace * 2, data + 4, 4, 38, false, 0, 50);
+ // Command Block #2 (4 bytes)
+ sendGeneric(kKelvinatorHdrMark, kKelvinatorHdrSpace, kKelvinatorBitMark,
+ kKelvinatorOneSpace, kKelvinatorBitMark, kKelvinatorZeroSpace,
+ 0, 0, // No Footer yet.
+ data + 8, 4, 38, false, 0, 50);
+ // Send Footer for the command block (3 bits (B010))
+ sendGeneric(0, 0, // No Header
+ kKelvinatorBitMark, kKelvinatorOneSpace, kKelvinatorBitMark,
+ kKelvinatorZeroSpace, kKelvinatorBitMark, kKelvinatorGapSpace,
+ kKelvinatorCmdFooter, kKelvinatorCmdFooterBits, 38, false, 0,
+ 50);
+ // Data Block #2 (4 bytes)
+ sendGeneric(0, 0, // No header
+ kKelvinatorBitMark, kKelvinatorOneSpace, kKelvinatorBitMark,
+ kKelvinatorZeroSpace, kKelvinatorBitMark,
+ kKelvinatorGapSpace * 2, data + 12, 4, 38, false, 0, 50);
+ }
+}
+#endif // SEND_KELVINATOR
+
+IRKelvinatorAC::IRKelvinatorAC(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRKelvinatorAC::stateReset() {
+ for (uint8_t i = 0; i < kKelvinatorStateLength; i++) remote_state[i] = 0x0;
+ remote_state[3] = 0x50;
+ remote_state[11] = 0x70;
+}
+
+void IRKelvinatorAC::begin() { _irsend.begin(); }
+
+void IRKelvinatorAC::fixup() {
+ // X-Fan mode is only valid in COOL or DRY modes.
+ if (getMode() != kKelvinatorCool && getMode() != kKelvinatorDry)
+ setXFan(false);
+ checksum(); // Calculate the checksums
+}
+
+#if SEND_KELVINATOR
+void IRKelvinatorAC::send() {
+ fixup(); // Ensure correct settings before sending.
+ _irsend.sendKelvinator(remote_state);
+}
+#endif // SEND_KELVINATOR
+
+uint8_t *IRKelvinatorAC::getRaw() {
+ fixup(); // Ensure correct settings before sending.
+ return remote_state;
+}
+
+void IRKelvinatorAC::setRaw(uint8_t new_code[]) {
+ for (uint8_t i = 0; i < kKelvinatorStateLength; i++) {
+ remote_state[i] = new_code[i];
+ }
+}
+
+uint8_t IRKelvinatorAC::calcBlockChecksum(const uint8_t *block,
+ const uint16_t length) {
+ uint8_t sum = kKelvinatorChecksumStart;
+ // Sum the lower half of the first 4 bytes of this block.
+ for (uint8_t i = 0; i < 4 && i < length - 1; i++, block++)
+ sum += (*block & 0x0FU);
+ // then sum the upper half of the next 3 bytes.
+ for (uint8_t i = 4; i < length - 1; i++, block++) sum += (*block >> 4);
+ // Trim it down to fit into the 4 bits allowed. i.e. Mod 16.
+ return sum & 0x0FU;
+}
+
+// Many Bothans died to bring us this information.
+void IRKelvinatorAC::checksum(const uint16_t length) {
+ // For each command + options block.
+ for (uint16_t offset = 0; offset + 7 < length; offset += 8) {
+ uint8_t sum = calcBlockChecksum(remote_state + offset);
+ remote_state[7 + offset] = (sum << 4) | (remote_state[7 + offset] & 0xFU);
+ }
+}
+
+// Verify the checksum is valid for a given state.
+// Args:
+// state: The array to verify the checksum of.
+// length: The size of the state.
+// Returns:
+// A boolean.
+bool IRKelvinatorAC::validChecksum(const uint8_t state[],
+ const uint16_t length) {
+ for (uint16_t offset = 0; offset + 7 < length; offset += 8) {
+ // Top 4 bits of the last byte in the block is the block's checksum.
+ if (state[offset + 7] >> 4 != calcBlockChecksum(state + offset))
+ return false;
+ }
+ return true;
+}
+
+void IRKelvinatorAC::on() {
+ remote_state[0] |= kKelvinatorPower;
+ remote_state[8] = remote_state[0]; // Duplicate to the 2nd command chunk.
+}
+
+void IRKelvinatorAC::off() {
+ remote_state[0] &= ~kKelvinatorPower;
+ remote_state[8] = remote_state[0]; // Duplicate to the 2nd command chunk.
+}
+
+void IRKelvinatorAC::setPower(bool state) {
+ if (state)
+ on();
+ else
+ off();
+}
+
+bool IRKelvinatorAC::getPower() {
+ return ((remote_state[0] & kKelvinatorPower) != 0);
+}
+
+// Set the temp. in deg C
+void IRKelvinatorAC::setTemp(uint8_t temp) {
+ temp = std::max(kKelvinatorMinTemp, temp);
+ temp = std::min(kKelvinatorMaxTemp, temp);
+ remote_state[1] = (remote_state[1] & 0xF0U) | (temp - kKelvinatorMinTemp);
+ remote_state[9] = remote_state[1]; // Duplicate to the 2nd command chunk.
+}
+
+// Return the set temp. in deg C
+uint8_t IRKelvinatorAC::getTemp() {
+ return ((remote_state[1] & 0xFU) + kKelvinatorMinTemp);
+}
+
+// Set the speed of the fan, 0-5, 0 is auto, 1-5 is the speed
+void IRKelvinatorAC::setFan(uint8_t fan) {
+ fan = std::min(kKelvinatorFanMax, fan); // Bounds check
+
+ // Only change things if we need to.
+ if (fan != getFan()) {
+ // Set the basic fan values.
+ uint8_t fan_basic = std::min(kKelvinatorBasicFanMax, fan);
+ remote_state[0] = (remote_state[0] & kKelvinatorBasicFanMask) |
+ (fan_basic << kKelvinatorFanOffset);
+ remote_state[8] = remote_state[0]; // Duplicate to the 2nd command chunk.
+ // Set the advanced(?) fan value.
+ remote_state[14] =
+ (remote_state[14] & kKelvinatorFanMask) | (fan << kKelvinatorFanOffset);
+ setTurbo(false); // Turbo mode is turned off if we change the fan settings.
+ }
+}
+
+uint8_t IRKelvinatorAC::getFan() {
+ return ((remote_state[14] & ~kKelvinatorFanMask) >> kKelvinatorFanOffset);
+}
+
+uint8_t IRKelvinatorAC::getMode() {
+ return (remote_state[0] & ~kKelvinatorModeMask);
+}
+
+void IRKelvinatorAC::setMode(uint8_t mode) {
+ // If we get an unexpected mode, default to AUTO.
+ if (mode > kKelvinatorHeat) mode = kKelvinatorAuto;
+ remote_state[0] = (remote_state[0] & kKelvinatorModeMask) | mode;
+ remote_state[8] = remote_state[0]; // Duplicate to the 2nd command chunk.
+ if (mode == kKelvinatorAuto || kKelvinatorDry)
+ // When the remote is set to Auto or Dry, it defaults to 25C and doesn't
+ // show it.
+ setTemp(kKelvinatorAutoTemp);
+}
+
+void IRKelvinatorAC::setSwingVertical(bool state) {
+ if (state) {
+ remote_state[0] |= kKelvinatorVentSwing;
+ remote_state[4] |= kKelvinatorVentSwingV;
+ } else {
+ remote_state[4] &= ~kKelvinatorVentSwingV;
+ if (!getSwingHorizontal()) remote_state[0] &= ~kKelvinatorVentSwing;
+ }
+ remote_state[8] = remote_state[0]; // Duplicate to the 2nd command chunk.
+}
+
+bool IRKelvinatorAC::getSwingVertical() {
+ return ((remote_state[4] & kKelvinatorVentSwingV) != 0);
+}
+
+void IRKelvinatorAC::setSwingHorizontal(bool state) {
+ if (state) {
+ remote_state[0] |= kKelvinatorVentSwing;
+ remote_state[4] |= kKelvinatorVentSwingH;
+ } else {
+ remote_state[4] &= ~kKelvinatorVentSwingH;
+ if (!getSwingVertical()) remote_state[0] &= ~kKelvinatorVentSwing;
+ }
+ remote_state[8] = remote_state[0]; // Duplicate to the 2nd command chunk.
+}
+
+bool IRKelvinatorAC::getSwingHorizontal() {
+ return ((remote_state[4] & kKelvinatorVentSwingH) != 0);
+}
+
+void IRKelvinatorAC::setQuiet(bool state) {
+ remote_state[12] &= ~kKelvinatorQuiet;
+ remote_state[12] |= (state << kKelvinatorQuietOffset);
+}
+
+bool IRKelvinatorAC::getQuiet() {
+ return ((remote_state[12] & kKelvinatorQuiet) != 0);
+}
+
+void IRKelvinatorAC::setIonFilter(bool state) {
+ remote_state[2] &= ~kKelvinatorIonFilter;
+ remote_state[2] |= (state << kKelvinatorIonFilterOffset);
+ remote_state[10] = remote_state[2]; // Duplicate to the 2nd command chunk.
+}
+
+bool IRKelvinatorAC::getIonFilter() {
+ return ((remote_state[2] & kKelvinatorIonFilter) != 0);
+}
+
+void IRKelvinatorAC::setLight(bool state) {
+ remote_state[2] &= ~kKelvinatorLight;
+ remote_state[2] |= (state << kKelvinatorLightOffset);
+ remote_state[10] = remote_state[2]; // Duplicate to the 2nd command chunk.
+}
+
+bool IRKelvinatorAC::getLight() {
+ return ((remote_state[2] & kKelvinatorLight) != 0);
+}
+
+// Note: XFan mode is only valid in Cool or Dry mode.
+void IRKelvinatorAC::setXFan(bool state) {
+ remote_state[2] &= ~kKelvinatorXfan;
+ remote_state[2] |= (state << kKelvinatorXfanOffset);
+ remote_state[10] = remote_state[2]; // Duplicate to the 2nd command chunk.
+}
+
+bool IRKelvinatorAC::getXFan() {
+ return ((remote_state[2] & kKelvinatorXfan) != 0);
+}
+
+// Note: Turbo mode is turned off if the fan speed is changed.
+void IRKelvinatorAC::setTurbo(bool state) {
+ remote_state[2] &= ~kKelvinatorTurbo;
+ remote_state[2] |= (state << kKelvinatorTurboOffset);
+ remote_state[10] = remote_state[2]; // Duplicate to the 2nd command chunk.
+}
+
+bool IRKelvinatorAC::getTurbo() {
+ return ((remote_state[2] & kKelvinatorTurbo) != 0);
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRKelvinatorAC::toString() {
+ String result = "";
+#else
+std::string IRKelvinatorAC::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kKelvinatorAuto:
+ result += " (AUTO)";
+ break;
+ case kKelvinatorCool:
+ result += " (COOL)";
+ break;
+ case kKelvinatorHeat:
+ result += " (HEAT)";
+ break;
+ case kKelvinatorDry:
+ result += " (DRY)";
+ break;
+ case kKelvinatorFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kKelvinatorFanAuto:
+ result += " (AUTO)";
+ break;
+ case kKelvinatorFanMax:
+ result += " (MAX)";
+ break;
+ }
+ result += ", Turbo: ";
+ if (getTurbo())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Quiet: ";
+ if (getQuiet())
+ result += "On";
+ else
+ result += "Off";
+ result += ", XFan: ";
+ if (getXFan())
+ result += "On";
+ else
+ result += "Off";
+ result += ", IonFilter: ";
+ if (getIonFilter())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Light: ";
+ if (getLight())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Swing (Horizontal): ";
+ if (getSwingHorizontal())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Swing (Vertical): ";
+ if (getSwingVertical())
+ result += "On";
+ else
+ result += "Off";
+ return result;
+}
+
+#if DECODE_KELVINATOR
+// Decode the supplied Kelvinator message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kKelvinatorBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: ALPHA / Untested.
+bool IRrecv::decodeKelvinator(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen <
+ 2 * (nbits + kKelvinatorCmdFooterBits) + (kHeader + kFooter + 1) * 2 - 1)
+ return false; // Can't possibly be a valid Kelvinator message.
+ if (strict && nbits != kKelvinatorBits)
+ return false; // Not strictly a Kelvinator message.
+
+ uint32_t data;
+ uint16_t offset = kStartOffset;
+
+ // There are two messages back-to-back in a full Kelvinator IR message
+ // sequence.
+ int8_t state_pos = 0;
+ for (uint8_t s = 0; s < 2; s++) {
+ match_result_t data_result;
+
+ // Header
+ if (!matchMark(results->rawbuf[offset], kKelvinatorHdrMark)) return false;
+ // Calculate how long the lowest tick time is based on the header mark.
+ uint32_t mark_tick =
+ results->rawbuf[offset++] * kRawTick / kKelvinatorHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kKelvinatorHdrSpace)) return false;
+ // Calculate how long the common tick time is based on the header space.
+ uint32_t space_tick =
+ results->rawbuf[offset++] * kRawTick / kKelvinatorHdrSpaceTicks;
+
+ // Data (Command) (32 bits)
+ data_result = matchData(
+ &(results->rawbuf[offset]), 32, kKelvinatorBitMarkTicks * mark_tick,
+ kKelvinatorOneSpaceTicks * space_tick,
+ kKelvinatorBitMarkTicks * mark_tick,
+ kKelvinatorZeroSpaceTicks * space_tick, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+
+ // Record command data in the state.
+ for (uint16_t i = 0; i < 4; i++, data >>= 8)
+ results->state[state_pos + i] = data & 0xFF;
+ state_pos += 4;
+
+ // Command data footer (3 bits, B010)
+ data_result = matchData(
+ &(results->rawbuf[offset]), kKelvinatorCmdFooterBits,
+ kKelvinatorBitMarkTicks * mark_tick,
+ kKelvinatorOneSpaceTicks * space_tick,
+ kKelvinatorBitMarkTicks * mark_tick,
+ kKelvinatorZeroSpaceTicks * space_tick, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) return false;
+ if (data_result.data != kKelvinatorCmdFooter) return false;
+ offset += data_result.used;
+
+ // Interdata gap.
+ if (!matchMark(results->rawbuf[offset++],
+ kKelvinatorBitMarkTicks * mark_tick))
+ return false;
+ if (!matchSpace(results->rawbuf[offset++],
+ kKelvinatorGapSpaceTicks * space_tick))
+ return false;
+
+ // Data (Options) (32 bits)
+ data_result = matchData(
+ &(results->rawbuf[offset]), 32, kKelvinatorBitMarkTicks * mark_tick,
+ kKelvinatorOneSpaceTicks * space_tick,
+ kKelvinatorBitMarkTicks * mark_tick,
+ kKelvinatorZeroSpaceTicks * space_tick, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+
+ // Record option data in the state.
+ for (uint16_t i = 0; i < 4; i++, data >>= 8)
+ results->state[state_pos + i] = data & 0xFF;
+ state_pos += 4;
+
+ // Inter-sequence gap. (Double length gap)
+ if (!matchMark(results->rawbuf[offset++],
+ kKelvinatorBitMarkTicks * mark_tick))
+ return false;
+ if (s == 0) {
+ if (!matchSpace(results->rawbuf[offset++],
+ kKelvinatorGapSpaceTicks * space_tick * 2))
+ return false;
+ } else {
+ if (offset <= results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset],
+ kKelvinatorGapSpaceTicks * 2 * space_tick))
+ return false;
+ }
+ }
+
+ // Compliance
+ if (strict) {
+ // Correct size/length)
+ if (state_pos != kKelvinatorStateLength) return false;
+ // Verify the message's checksum is correct.
+ if (!IRKelvinatorAC::validChecksum(results->state)) return false;
+ }
+
+ // Success
+ results->decode_type = KELVINATOR;
+ results->bits = state_pos * 8;
+ // No need to record the state as we stored it as we decoded it.
+ // As we use result->state, we don't record value, address, or command as it
+ // is a union data type.
+ return true;
+}
+#endif // DECODE_KELVINATOR
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Kelvinator.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Kelvinator.h
similarity index 71%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Kelvinator.h
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Kelvinator.h
index c15d85c6e45e..1508d6cdc8f2 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Kelvinator.h
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Kelvinator.h
@@ -7,6 +7,11 @@
#define __STDC_LIMIT_MACROS
#include
+#ifndef UNIT_TEST
+#include
+#else
+#include
+#endif
#include "IRremoteESP8266.h"
#include "IRsend.h"
@@ -17,19 +22,33 @@
// KK KK EEEEEEE LLLLLLL VVV IIIII NN NN AA AA TTT OOOO0 RR RR
// Constants
-#define KELVINATOR_AUTO 0U
-#define KELVINATOR_COOL 1U
-#define KELVINATOR_DRY 2U
-#define KELVINATOR_FAN 3U
-#define KELVINATOR_HEAT 4U
-#define KELVINATOR_BASIC_FAN_MAX 3U
-#define KELVINATOR_FAN_MAX 5U
-#define KELVINATOR_MIN_TEMP 16U // 16C
-#define KELVINATOR_MAX_TEMP 30U // 30C
-#define KELVINATOR_AUTO_TEMP 25U // 25C
+const uint8_t kKelvinatorAuto = 0;
+const uint8_t kKelvinatorCool = 1;
+const uint8_t kKelvinatorDry = 2;
+const uint8_t kKelvinatorFan = 3;
+const uint8_t kKelvinatorHeat = 4;
+const uint8_t kKelvinatorBasicFanMax = 3;
+const uint8_t kKelvinatorFanAuto = 0;
+const uint8_t kKelvinatorFanMax = 5;
+const uint8_t kKelvinatorMinTemp = 16; // 16C
+const uint8_t kKelvinatorMaxTemp = 30; // 30C
+const uint8_t kKelvinatorAutoTemp = 25; // 25C
+
+// Legacy defines (Deprecated)
+#define KELVINATOR_MIN_TEMP kKelvinatorMinTemp
+#define KELVINATOR_MAX_TEMP kKelvinatorMaxTemp
+#define KELVINATOR_HEAT kKelvinatorHeat
+#define KELVINATOR_FAN_MAX kKelvinatorFanMax
+#define KELVINATOR_FAN_AUTO kKelvinatorFanAuto
+#define KELVINATOR_FAN kKelvinatorFan
+#define KELVINATOR_DRY kKelvinatorDry
+#define KELVINATOR_COOL kKelvinatorCool
+#define KELVINATOR_BASIC_FAN_MAX kKelvinatorBasicFanMax
+#define KELVINATOR_AUTO_TEMP kKelvinatorAutoTemp
+#define KELVINATOR_AUTO kKelvinatorAuto
/*
- Kelvinator AC map
+ Kelvinator AC map
(header mark and space)
byte 0 = Basic Modes
@@ -104,15 +123,15 @@
b7-4 = checksum of the previous bytes (8-14)
*/
-#if SEND_KELVINATOR
-
// Classes
class IRKelvinatorAC {
public:
explicit IRKelvinatorAC(uint16_t pin);
void stateReset();
+#if SEND_KELVINATOR
void send();
+#endif // SEND_KELVINATOR
void begin();
void on();
void off();
@@ -139,14 +158,23 @@ class IRKelvinatorAC {
void setTurbo(bool state);
bool getTurbo();
uint8_t* getRaw();
+ void setRaw(uint8_t new_code[]);
+ static uint8_t calcBlockChecksum(
+ const uint8_t* block, const uint16_t length = kKelvinatorStateLength / 2);
+ static bool validChecksum(const uint8_t state[],
+ const uint16_t length = kKelvinatorStateLength);
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
private:
// The state of the IR remote in IR code form.
- uint8_t remote_state[KELVINATOR_STATE_LENGTH];
- void checksum();
+ uint8_t remote_state[kKelvinatorStateLength];
+ void checksum(const uint16_t length = kKelvinatorStateLength);
void fixup();
IRsend _irsend;
};
-#endif
#endif // IR_KELVINATOR_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_LG.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_LG.cpp
new file mode 100644
index 000000000000..f9d922fc740e
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_LG.cpp
@@ -0,0 +1,290 @@
+// Copyright 2015 Darryl Smith
+// Copyright 2015 cheaplin
+// Copyright 2017, 2018 David Conran
+
+#include "ir_LG.h"
+#include
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// L GGGG
+// L G
+// L G GG
+// L G G
+// LLLLL GGG
+
+// LG decode originally added by Darryl Smith (based on the JVC protocol)
+// LG send originally added by https://github.com/chaeplin
+//
+// Known supported devices:
+// IR Remotes:
+// 6711A20083V
+// AKB74395308
+
+// Constants
+const uint16_t kLgTick = 50;
+const uint16_t kLgHdrMarkTicks = 170;
+const uint16_t kLgHdrMark = kLgHdrMarkTicks * kLgTick; // 8500
+const uint16_t kLgHdrSpaceTicks = 85;
+const uint16_t kLgHdrSpace = kLgHdrSpaceTicks * kLgTick; // 4250
+const uint16_t kLgBitMarkTicks = 11;
+const uint16_t kLgBitMark = kLgBitMarkTicks * kLgTick; // 550
+const uint16_t kLgOneSpaceTicks = 32;
+const uint16_t kLgOneSpace = kLgOneSpaceTicks * kLgTick; // 1600
+const uint16_t kLgZeroSpaceTicks = 11;
+const uint16_t kLgZeroSpace = kLgZeroSpaceTicks * kLgTick; // 550
+const uint16_t kLgRptSpaceTicks = 45;
+const uint16_t kLgRptSpace = kLgRptSpaceTicks * kLgTick; // 2250
+const uint16_t kLgMinGapTicks = 795;
+const uint16_t kLgMinGap = kLgMinGapTicks * kLgTick; // 39750
+const uint16_t kLgMinMessageLengthTicks = 2161;
+const uint32_t kLgMinMessageLength = kLgMinMessageLengthTicks * kLgTick;
+
+const uint16_t kLg32HdrMarkTicks = 90;
+const uint16_t kLg32HdrMark = kLg32HdrMarkTicks * kLgTick; // 4500
+const uint16_t kLg32HdrSpaceTicks = 89;
+const uint16_t kLg32HdrSpace = kLg32HdrSpaceTicks * kLgTick; // 4450
+const uint16_t kLg32RptHdrMarkTicks = 179;
+const uint16_t kLg32RptHdrMark = kLg32RptHdrMarkTicks * kLgTick; // 8950
+
+const uint16_t kLg2HdrMarkTicks = 64;
+const uint16_t kLg2HdrMark = kLg2HdrMarkTicks * kLgTick; // 3200
+const uint16_t kLg2HdrSpaceTicks = 197;
+const uint16_t kLg2HdrSpace = kLg2HdrSpaceTicks * kLgTick; // 9850
+const uint16_t kLg2BitMarkTicks = 10;
+const uint16_t kLg2BitMark = kLg2BitMarkTicks * kLgTick; // 500
+
+#if (SEND_LG || DECODE_LG)
+// Calculate the rolling 4-bit wide checksum over all of the data.
+// Args:
+// data: The value to be checksum'ed.
+// Returns:
+// A 4-bit checksum.
+uint8_t calcLGChecksum(uint16_t data) {
+ return (((data >> 12) + ((data >> 8) & 0xF) + ((data >> 4) & 0xF) +
+ (data & 0xF)) &
+ 0xF);
+}
+#endif
+
+#if SEND_LG
+// Send an LG formatted message.
+//
+// Args:
+// data: The contents of the message you want to send.
+// nbits: The bit size of the message being sent.
+// Typically kLgBits or kLg32Bits.
+// repeat: The number of times you want the message to be repeated.
+//
+// Status: Beta / Should be working.
+//
+// Notes:
+// LG has a separate message to indicate a repeat, like NEC does.
+// Supports:
+// IR Remote models: 6711A20083V
+void IRsend::sendLG(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ uint16_t repeatHeaderMark = 0;
+
+ if (nbits >= kLg32Bits) {
+ // LG 32bit protocol is near identical to Samsung except for repeats.
+ sendSAMSUNG(data, nbits, 0); // Send it as a single Samsung message.
+ repeatHeaderMark = kLg32RptHdrMark;
+ repeat++;
+ } else {
+ // LG (28-bit) protocol.
+ repeatHeaderMark = kLgHdrMark;
+ sendGeneric(kLgHdrMark, kLgHdrSpace, kLgBitMark, kLgOneSpace, kLgBitMark,
+ kLgZeroSpace, kLgBitMark, kLgMinGap, kLgMinMessageLength, data,
+ nbits, 38, true, 0, // Repeats are handled later.
+ 50);
+ }
+
+ // Repeat
+ // Protocol has a mandatory repeat-specific code sent after every command.
+ if (repeat)
+ sendGeneric(repeatHeaderMark, kLgRptSpace, 0, 0, 0, 0, // No data is sent.
+ kLgBitMark, kLgMinGap, kLgMinMessageLength, 0, 0, // No data.
+ 38, true, repeat - 1, 50);
+}
+
+// Send an LG Variant-2 formatted message.
+//
+// Args:
+// data: The contents of the message you want to send.
+// nbits: The bit size of the message being sent.
+// Typically kLgBits or kLg32Bits.
+// repeat: The number of times you want the message to be repeated.
+//
+// Status: Beta / Should be working.
+//
+// Notes:
+// LG has a separate message to indicate a repeat, like NEC does.
+// Supports:
+// IR Remote models: AKB74395308
+void IRsend::sendLG2(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ if (nbits >= kLg32Bits) {
+ // Let the original routine handle it.
+ sendLG(data, nbits, repeat); // Send it as a single Samsung message.
+ return;
+ }
+
+ // LGv2 (28-bit) protocol.
+ sendGeneric(kLg2HdrMark, kLg2HdrSpace, kLgBitMark, kLgOneSpace, kLgBitMark,
+ kLgZeroSpace, kLgBitMark, kLgMinGap, kLgMinMessageLength, data,
+ nbits, 38, true, 0, // Repeats are handled later.
+ 50);
+
+ // TODO(crackn): Verify the details of what repeat messages look like.
+ // Repeat
+ // Protocol has a mandatory repeat-specific code sent after every command.
+ if (repeat)
+ sendGeneric(kLg2HdrMark, kLgRptSpace, 0, 0, 0, 0, // No data is sent.
+ kLgBitMark, kLgMinGap, kLgMinMessageLength, 0, 0, // No data.
+ 38, true, repeat - 1, 50);
+}
+
+// Construct a raw 28-bit LG message code from the supplied address & command.
+//
+// Args:
+// address: The address code.
+// command: The command code.
+// Returns:
+// A raw 28-bit LG message code suitable for sendLG() etc.
+//
+// Status: BETA / Should work.
+//
+// Notes:
+// e.g. Sequence of bits = address + command + checksum.
+uint32_t IRsend::encodeLG(uint16_t address, uint16_t command) {
+ return ((address << 20) | (command << 4) | calcLGChecksum(command));
+}
+#endif
+
+#if DECODE_LG
+// Decode the supplied LG message.
+// LG protocol has a repeat code which is 4 items long.
+// Even though the protocol has 28/32 bits of data, only 24/28 bits are
+// distinct.
+// In transmission order, the 28/32 bits are constructed as follows:
+// 8/12 bits of address + 16 bits of command + 4 bits of checksum.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of bits to expect in the data portion.
+// Typically kLgBits or kLg32Bits.
+// strict: Flag to indicate if we strictly adhere to the specification.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Should work.
+//
+// Note:
+// LG 32bit protocol appears near identical to the Samsung protocol.
+// They possibly differ on how they repeat and initial HDR mark.
+//
+// Supports:
+// IR Remote models: 6711A20083V, AKB74395308
+
+// Ref:
+// https://funembedded.wordpress.com/2014/11/08/ir-remote-control-for-lg-conditioner-using-stm32f302-mcu-on-mbed-platform/
+bool IRrecv::decodeLG(decode_results *results, uint16_t nbits, bool strict) {
+ if (nbits >= kLg32Bits) {
+ if (results->rawlen < 2 * nbits + 2 * (kHeader + kFooter) - 1)
+ return false; // Can't possibly be a valid LG32 message.
+ } else {
+ if (results->rawlen < 2 * nbits + kHeader + kFooter - 1)
+ return false; // Can't possibly be a valid LG message.
+ }
+ if (strict && nbits != kLgBits && nbits != kLg32Bits)
+ return false; // Doesn't comply with expected LG protocol.
+
+ uint64_t data = 0;
+ uint16_t offset = kStartOffset;
+ bool isLg2 = false;
+
+ // Header
+ uint32_t m_tick;
+ if (matchMark(results->rawbuf[offset], kLgHdrMark)) {
+ m_tick = results->rawbuf[offset++] * kRawTick / kLgHdrMarkTicks;
+ } else if (matchMark(results->rawbuf[offset], kLg2HdrMark)) {
+ m_tick = results->rawbuf[offset++] * kRawTick / kLg2HdrMarkTicks;
+ isLg2 = true;
+ } else if (matchMark(results->rawbuf[offset], kLg32HdrMark)) {
+ m_tick = results->rawbuf[offset++] * kRawTick / kLg32HdrMarkTicks;
+ } else {
+ return false;
+ }
+ uint32_t s_tick;
+ if (isLg2) {
+ if (matchSpace(results->rawbuf[offset], kLg2HdrSpace))
+ s_tick = results->rawbuf[offset++] * kRawTick / kLg2HdrSpaceTicks;
+ else
+ return false;
+ } else {
+ if (matchSpace(results->rawbuf[offset], kLgHdrSpace))
+ s_tick = results->rawbuf[offset++] * kRawTick / kLgHdrSpaceTicks;
+ else if (matchSpace(results->rawbuf[offset], kLg2HdrSpace))
+ s_tick = results->rawbuf[offset++] * kRawTick / kLg32HdrSpaceTicks;
+ else
+ return false;
+ }
+
+ // Set up the expected tick sizes based on variant.
+ uint16_t bitmarkticks;
+ if (isLg2) {
+ bitmarkticks = kLg2BitMarkTicks;
+ } else {
+ bitmarkticks = kLgBitMarkTicks;
+ }
+
+ // Data
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), nbits, bitmarkticks * m_tick,
+ kLgOneSpaceTicks * s_tick, bitmarkticks * m_tick,
+ kLgZeroSpaceTicks * s_tick, kTolerance, 0);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], bitmarkticks * m_tick))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kLgMinGapTicks * s_tick))
+ return false;
+
+ // Repeat
+ if (nbits >= kLg32Bits) {
+ // If we are expecting the LG 32-bit protocol, there is always
+ // a repeat message. So, check for it.
+ offset++;
+ if (!matchMark(results->rawbuf[offset++], kLg32RptHdrMarkTicks * m_tick))
+ return false;
+ if (!matchSpace(results->rawbuf[offset++], kLgRptSpaceTicks * s_tick))
+ return false;
+ if (!matchMark(results->rawbuf[offset++], bitmarkticks * m_tick))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kLgMinGapTicks * s_tick))
+ return false;
+ }
+
+ // Compliance
+ uint16_t command = (data >> 4) & 0xFFFF; // The 16 bits before the checksum.
+
+ if (strict && (data & 0xF) != calcLGChecksum(command))
+ return false; // The last 4 bits sent are the expected checksum.
+
+ // Success
+ if (isLg2)
+ results->decode_type = LG2;
+ else
+ results->decode_type = LG;
+ results->bits = nbits;
+ results->value = data;
+ results->command = command;
+ results->address = data >> 20; // The bits before the command.
+ return true;
+}
+#endif
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_LG.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_LG.h
similarity index 100%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_LG.h
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_LG.h
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Lasertag.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Lasertag.cpp
new file mode 100644
index 000000000000..7f0b89ae9110
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Lasertag.cpp
@@ -0,0 +1,122 @@
+// Copyright 2017 David Conran
+
+#include
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// LL AAA SSSSS EEEEEEE RRRRRR TTTTTTT AAA GGGG
+// LL AAAAA SS EE RR RR TTT AAAAA GG GG
+// LL AA AA SSSSS EEEEE RRRRRR TTT AA AA GG
+// LL AAAAAAA SS EE RR RR TTT AAAAAAA GG GG
+// LLLLLLL AA AA SSSSS EEEEEEE RR RR TTT AA AA GGGGGG
+
+// Constants
+const uint16_t kLasertagMinSamples = 13;
+const uint16_t kLasertagTick = 333;
+const uint32_t kLasertagMinGap = 100000; // Completely made up amount.
+const uint8_t kLasertagTolerance = 0; // Percentage error margin.
+const uint16_t kLasertagExcess = 0; // See kMarkExcess.
+const uint16_t kLasertagDelta = 150; // Use instead of Excess and Tolerance.
+const int16_t kSpace = 1;
+const int16_t kMark = 0;
+
+#if SEND_LASERTAG
+// Send a Lasertag packet.
+// This protocol is pretty much just raw Manchester encoding.
+//
+// Args:
+// data: The message you wish to send.
+// nbits: Bit size of the protocol you want to send.
+// repeat: Nr. of extra times the data will be sent.
+//
+// Status: STABLE / Working.
+//
+void IRsend::sendLasertag(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ if (nbits > sizeof(data) * 8) return; // We can't send something that big.
+
+ // Set 36kHz IR carrier frequency & a 1/4 (25%) duty cycle.
+ // NOTE: duty cycle is not confirmed. Just guessing based on RC5/6 protocols.
+ enableIROut(36, 25);
+
+ for (uint16_t i = 0; i <= repeat; i++) {
+ // Data
+ for (uint64_t mask = 1ULL << (nbits - 1); mask; mask >>= 1)
+ if (data & mask) { // 1
+ space(kLasertagTick); // 1 is space, then mark.
+ mark(kLasertagTick);
+ } else { // 0
+ mark(kLasertagTick); // 0 is mark, then space.
+ space(kLasertagTick);
+ }
+ // Footer
+ space(kLasertagMinGap);
+ }
+}
+#endif // SEND_LASERTAG
+
+#if DECODE_LASERTAG
+// Decode the supplied Lasertag message.
+// This protocol is pretty much just raw Manchester encoding.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Appears to be working 90% of the time.
+//
+// Ref:
+// http://www.sbprojects.com/knowledge/ir/rc5.php
+// https://en.wikipedia.org/wiki/RC-5
+// https://en.wikipedia.org/wiki/Manchester_code
+bool IRrecv::decodeLasertag(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < kLasertagMinSamples) return false;
+
+ // Compliance
+ if (strict && nbits != kLasertagBits) return false;
+
+ uint16_t offset = kStartOffset;
+ uint16_t used = 0;
+ uint64_t data = 0;
+ uint16_t actual_bits = 0;
+
+ // No Header
+
+ // Data
+ for (; offset <= results->rawlen; actual_bits++) {
+ int16_t levelA =
+ getRClevel(results, &offset, &used, kLasertagTick, kLasertagTolerance,
+ kLasertagExcess, kLasertagDelta);
+ int16_t levelB =
+ getRClevel(results, &offset, &used, kLasertagTick, kLasertagTolerance,
+ kLasertagExcess, kLasertagDelta);
+ if (levelA == kSpace && levelB == kMark) {
+ data = (data << 1) | 1; // 1
+ } else {
+ if (levelA == kMark && levelB == kSpace) {
+ data <<= 1; // 0
+ } else {
+ break;
+ }
+ }
+ }
+ // Footer (None)
+
+ // Compliance
+ if (actual_bits < nbits) return false; // Less data than we expected.
+ if (strict && actual_bits != kLasertagBits) return false;
+
+ // Success
+ results->decode_type = LASERTAG;
+ results->value = data;
+ results->address = data & 0xF; // Unit
+ results->command = data >> 4; // Team
+ results->repeat = false;
+ results->bits = actual_bits;
+ return true;
+}
+#endif // DECODE_LASERTAG
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Lutron.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Lutron.cpp
new file mode 100644
index 000000000000..00eb9383b85b
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Lutron.cpp
@@ -0,0 +1,156 @@
+// Copyright 2018 David Conran
+
+#define __STDC_LIMIT_MACROS
+#include
+#include
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// LL UU UU TTTTTTT RRRRRR OOOOO NN NN
+// LL UU UU TTT RR RR OO OO NNN NN
+// LL UU UU TTT RRRRRR OO OO NN N NN
+// LL UU UU TTT RR RR OO OO NN NNN
+// LLLLLLL UUUUU TTT RR RR OOOO0 NN NN
+
+// Notes:
+// The Lutron protocol uses a sort of Run Length encoding to encode
+// its data. There is no header or footer per-se.
+// As a mark is the first data we will notice, we always assume the First
+// bit of the technically 36-bit protocol is '1'. So it is assumed, and thus
+// we only care about the 35 bits of data.
+
+// Constants
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/515
+const uint16_t kLutronTick = 2288;
+const uint32_t kLutronGap = 150000; // Completely made up value.
+const uint16_t kLutronDelta = 400; // +/- 300 usecs.
+
+#if SEND_LUTRON
+// Send a Lutron formatted message.
+//
+// Args:
+// data: The message to be sent.
+// nbits: The number of bits of the message to be sent. Typically kLutronBits
+// repeat: The number of times the command is to be repeated.
+//
+// Status: Stable / Appears to be working for real devices.
+
+// Notes:
+// Protocol is really 36 bits long, but the first bit is always a 1.
+// So, assume the 1 and only have a normal payload of 35 bits.
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/515
+void IRsend::sendLutron(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ enableIROut(40000, 40); // 40Khz & 40% dutycycle.
+ for (uint16_t r = 0; r <= repeat; r++) {
+ mark(kLutronTick); // 1st bit is always '1'.
+ // Send the supplied data in MSB First order.
+ for (uint64_t mask = 1ULL << (nbits - 1); mask; mask >>= 1)
+ if (data & mask)
+ mark(kLutronTick); // Send a 1
+ else
+ space(kLutronTick); // Send a 0
+ space(kLutronGap); // Inter-message gap.
+ }
+}
+#endif // SEND_LUTRON
+
+#if DECODE_LUTRON
+// Decode the supplied Lutron message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kLutronBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: ALPHA / Untested.
+//
+// Notes:
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/515
+bool IRrecv::decodeLutron(decode_results *results, uint16_t nbits,
+ bool strict) {
+ // Technically the smallest number of entries for the smallest message is '1'.
+ // i.e. All the bits set to 1, would produce a single huge mark signal.
+ // So no minimum length check is required.
+ if (strict && nbits != kLutronBits)
+ return false; // Not strictly an Lutron message.
+
+ uint64_t data = 0;
+ int16_t bitsSoFar = -1;
+
+ if (nbits > sizeof(data) * 8) return false; // To large to store the data.
+ for (uint16_t offset = kStartOffset;
+ bitsSoFar < nbits && offset < results->rawlen; offset++) {
+ uint16_t entry = results->rawbuf[offset];
+ // It has to be large enough to qualify as a bit.
+ if (!matchAtLeast(entry, kLutronTick, 0, kLutronDelta)) {
+ DPRINTLN("Entry too small. Aborting.");
+ return false;
+ }
+ // Keep reading bits of the same value until we run out.
+ while (entry != 0 && matchAtLeast(entry, kLutronTick, 0, kLutronDelta)) {
+ bitsSoFar++;
+ DPRINT("Bit: ");
+ DPRINT(bitsSoFar);
+ if (offset % 2) { // Is Odd?
+ data = (data << 1) + 1; // Append a '1'.
+ DPRINTLN(" is a 1.");
+ } else { // Is it Even?
+ data <<= 1; // Append a '0'.
+ DPRINTLN(" is a 0.");
+ if (bitsSoFar == nbits && matchAtLeast(entry, kLutronGap))
+ break; // We've likely reached the end of a message.
+ }
+ // Remove a bit length from the current entry.
+ entry = std::max(entry, (uint16_t)(kLutronTick / kRawTick)) -
+ kLutronTick / kRawTick;
+ }
+ if (offset % 2 && !match(entry, kLutronDelta, 0, kLutronDelta)) {
+ DPRINT("offset = ");
+ DPRINTLN(offset);
+ DPRINT("rawlen = ");
+ DPRINTLN(results->rawlen);
+ DPRINT("entry = ");
+ DPRINTLN(entry);
+ DPRINTLN("Odd Entry has too much left over. Aborting.");
+ return false; // Too much left over to be a good value. Reject it.
+ }
+ if (offset % 2 == 0 && offset <= results->rawlen - 1 &&
+ !matchAtLeast(entry, kLutronDelta, 0, kLutronDelta)) {
+ DPRINT("offset = ");
+ DPRINTLN(offset);
+ DPRINT("rawlen = ");
+ DPRINTLN(results->rawlen);
+ DPRINT("entry = ");
+ DPRINTLN(entry);
+ DPRINTLN("Entry has too much left over. Aborting.");
+ return false; // Too much left over to be a good value. Reject it.
+ }
+ }
+
+ // We got too many bits.
+ if (bitsSoFar > nbits || bitsSoFar < 0) {
+ DPRINTLN("Wrong number of bits found. Aborting.");
+ return false;
+ }
+ // If we got less bits than we were expecting, we need to pad with zeros
+ // until we get the correct number of bits.
+ if (bitsSoFar < nbits) data <<= (nbits - bitsSoFar);
+
+ // Success
+ DPRINTLN("Lutron Success!");
+ results->decode_type = LUTRON;
+ results->bits = bitsSoFar;
+ results->value = data ^ (1ULL << nbits); // Mask off the initial '1'.
+ results->address = 0;
+ results->command = 0;
+ return true;
+}
+#endif // DECODE_LUTRON
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_MWM.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_MWM.cpp
new file mode 100644
index 000000000000..a75e99e3a51d
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_MWM.cpp
@@ -0,0 +1,202 @@
+// Copyright 2018 Brett T. Warden
+// derived from ir_Lasertag.cpp, Copyright 2017 David Conran
+
+#include
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// MM MM WW WW MM MM
+// MMM MMM WW WW MMM MMM
+// MM M MM WW W WW MM M MM
+// MM MM WWW WWW MM MM
+// MM MM WW WW MM MM
+
+// Constants
+const uint16_t kMWMMinSamples = 6; // Msgs are >=3 bytes, bytes have >=2
+ // samples
+const uint16_t kMWMTick = 417;
+const uint32_t kMWMMinGap = 30000; // Typical observed delay b/w commands
+const uint8_t kMWMTolerance = 0; // Percentage error margin.
+const uint16_t kMWMExcess = 0; // See kMarkExcess.
+const uint16_t kMWMDelta = 150; // Use instead of Excess and Tolerance.
+const uint8_t kMWMMaxWidth = 9; // Maximum number of successive bits at a
+ // single level - worst case
+const int16_t kSpace = 1;
+const int16_t kMark = 0;
+
+#if SEND_MWM
+// Send a MWM packet.
+// This protocol is 2400 bps serial, 1 start bit (mark), 1 stop bit (space), no
+// parity
+//
+// Args:
+// data: The message you wish to send.
+// nbits: Bit size of the protocol you want to send.
+// repeat: Nr. of extra times the data will be sent.
+//
+// Status: Implemented.
+//
+void IRsend::sendMWM(uint8_t data[], uint16_t nbytes, uint16_t repeat) {
+ if (nbytes < 3) return; // Shortest possible message is 3 bytes
+
+ // Set 38kHz IR carrier frequency & a 1/4 (25%) duty cycle.
+ // NOTE: duty cycle is not confirmed. Just guessing based on RC5/6 protocols.
+ enableIROut(38, 25);
+
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // Data
+ for (uint16_t i = 0; i < nbytes; i++) {
+ uint8_t byte = data[i];
+
+ // Start bit
+ mark(kMWMTick);
+
+ // LSB first, space=1
+ for (uint8_t mask = 0x1; mask; mask <<= 1) {
+ if (byte & mask) { // 1
+ space(kMWMTick);
+ } else { // 0
+ mark(kMWMTick);
+ }
+ }
+ // Stop bit
+ space(kMWMTick);
+ }
+ // Footer
+ space(kMWMMinGap);
+ }
+}
+#endif // SEND_MWM
+
+#if DECODE_MWM
+// Decode the supplied MWM message.
+// This protocol is 2400 bps serial, 1 start bit (mark), 1 stop bit (space), no
+// parity
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: Implemented.
+//
+bool IRrecv::decodeMWM(decode_results *results, uint16_t nbits, bool strict) {
+ DPRINTLN("DEBUG: decodeMWM");
+
+ // Compliance
+ if (results->rawlen < kMWMMinSamples) {
+ DPRINTLN("DEBUG: decodeMWM: too few samples");
+ return false;
+ }
+
+ uint16_t offset = kStartOffset;
+ uint16_t used = 0;
+ uint64_t data = 0;
+ uint16_t frame_bits = 0;
+ uint16_t data_bits = 0;
+
+ // No Header
+
+ // Data
+ uint8_t bits_per_frame = 10;
+ for (; offset < results->rawlen && results->bits < 8 * kStateSizeMax;
+ frame_bits++) {
+ DPRINT("DEBUG: decodeMWM: offset = ");
+ DPRINTLN(uint64ToString(offset));
+ int16_t level = getRClevel(results, &offset, &used, kMWMTick, kMWMTolerance,
+ kMWMExcess, kMWMDelta, kMWMMaxWidth);
+ if (level < 0) {
+ DPRINTLN("DEBUG: decodeMWM: getRClevel returned error");
+ break;
+ }
+ switch (frame_bits % bits_per_frame) {
+ case 0:
+ // Start bit
+ if (level != kMark) {
+ DPRINTLN("DEBUG: decodeMWM: framing error - invalid start bit");
+ goto done;
+ }
+ break;
+ case 9:
+ // Stop bit
+ if (level != kSpace) {
+ DPRINTLN("DEBUG: decodeMWM: framing error - invalid stop bit");
+ return false;
+ } else {
+ DPRINT("DEBUG: decodeMWM: data_bits = ");
+ DPRINTLN(data_bits);
+ DPRINT("DEBUG: decodeMWM: Finished byte: ");
+ DPRINTLN(data);
+ results->state[data_bits / 8 - 1] = data & 0xFF;
+ results->bits = data_bits;
+ data = 0;
+ }
+ break;
+ default:
+ // Data bits
+ DPRINT("DEBUG: decodeMWM: Storing bit: ");
+ DPRINTLN((level == kSpace));
+ // Transmission is LSB-first, space=1
+ data |= ((level == kSpace)) << 8;
+ data >>= 1;
+ data_bits++;
+ break;
+ }
+ }
+
+done:
+ // Footer (None)
+
+ // Compliance
+ DPRINT("DEBUG: decodeMWM: frame_bits = ");
+ DPRINTLN(frame_bits);
+ DPRINT("DEBUG: decodeMWM: data_bits = ");
+ DPRINTLN(data_bits);
+ if (data_bits < nbits) {
+ DPRINT("DEBUG: decodeMWM: too few bits; expected ");
+ DPRINTLN(nbits);
+ return false; // Less data than we expected.
+ }
+
+ uint16_t payload_length = 0;
+ switch (results->state[0] & 0xf0) {
+ case 0x90:
+ case 0xf0:
+ // Normal commands
+ payload_length = results->state[0] & 0x0f;
+ DPRINT("DEBUG: decodeMWM: payload_length = ");
+ DPRINTLN(payload_length);
+ break;
+ default:
+ if (strict) {
+ // Show commands
+ if (results->state[0] != 0x55 && results->state[1] != 0xAA) {
+ return false;
+ }
+ }
+ break;
+ }
+ if (data_bits < (payload_length + 3) * 8) {
+ DPRINT("DEBUG: decodeMWM: too few bytes; expected ");
+ DPRINTLN((payload_length + 3));
+ return false;
+ }
+ if (strict) {
+ if (payload_length && (data_bits > (payload_length + 3) * 8)) {
+ DPRINT("DEBUG: decodeMWM: too many bytes; expected ");
+ DPRINTLN((payload_length + 3));
+ return false;
+ }
+ }
+
+ // Success
+ results->decode_type = MWM;
+ results->repeat = false;
+ return true;
+}
+#endif // DECODE_MWM
+
+// vim: et:ts=2:sw=2
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Magiquest.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Magiquest.cpp
new file mode 100644
index 000000000000..863aa0ec3aa5
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Magiquest.cpp
@@ -0,0 +1,166 @@
+// Copyright 2013 mpflaga
+// Copyright 2015 kitlaan
+// Copyright 2017 Jason kendall, David Conran
+
+#include "ir_Magiquest.h"
+#include
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+#define IS_ZERO(m, s) (((m)*100 / ((m) + (s))) <= kMagiQuestZeroRatio)
+#define IS_ONE(m, s) (((m)*100 / ((m) + (s))) >= kMagiQuestOneRatio)
+
+// Strips taken from:
+// https://github.com/kitlaan/Arduino-IRremote/blob/master/ir_Magiquest.cpp
+// and
+// https://github.com/mpflaga/Arduino-IRremote
+
+// Source: https://github.com/mpflaga/Arduino-IRremote
+
+#if SEND_MAGIQUEST
+// Send a MagiQuest formatted message.
+//
+// Args:
+// data: The contents of the message you want to send.
+// nbits: The bit size of the message being sent.
+// Typically kMagiquestBits.
+// repeat: The number of times you want the message to be repeated.
+//
+// Status: Alpha / Should be working.
+//
+void IRsend::sendMagiQuest(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ sendGeneric(0, 0, // No Headers - Technically it's included in the data.
+ // i.e. 8 zeros.
+ kMagiQuestMarkOne, kMagiQuestSpaceOne, kMagiQuestMarkZero,
+ kMagiQuestSpaceZero,
+ 0, // No footer mark.
+ kMagiQuestGap, data, nbits, 36, true, repeat, 50);
+}
+
+// Encode a MagiQuest wand_id, and a magnitude into a single 64bit value.
+// (Only 48 bits of real data + 8 leading zero bits)
+// This is suitable for calling sendMagiQuest() with.
+// e.g. sendMagiQuest(encodeMagiQuest(wand_id, magnitude));
+uint64_t IRsend::encodeMagiQuest(uint32_t wand_id, uint16_t magnitude) {
+ uint64_t result = 0;
+ result = wand_id;
+ result <<= 16;
+ result |= magnitude;
+ // Shouldn't be needed, but ensure top 8/16 bit are zero.
+ result &= 0xFFFFFFFFFFFFULL;
+ return result;
+}
+#endif
+
+// Source:
+// https://github.com/kitlaan/Arduino-IRremote/blob/master/ir_Magiquest.cpp
+
+#if DECODE_MAGIQUEST
+// Decode the supplied MagiQuest message.
+// MagiQuest protocol appears to be a header of 8 'zero' bits, followed
+// by 32 bits of "wand ID" and finally 16 bits of "magnitude".
+// Even though we describe this protocol as 56 bits, it really only has
+// 48 bits of data that matter.
+//
+// In transmission order, 8 zeros + 32 wand_id + 16 magnitude.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of bits to expect in the data portion, inc. the 8 bit header.
+// Typically kMagiquestBits.
+// strict: Flag to indicate if we strictly adhere to the specification.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: Alpha / Should work.
+//
+// Ref:
+// https://github.com/kitlaan/Arduino-IRremote/blob/master/ir_Magiquest.cpp
+bool IRrecv::decodeMagiQuest(decode_results *results, uint16_t nbits,
+ bool strict) {
+ uint16_t bits = 0;
+ uint64_t data = 0;
+ uint16_t offset = kStartOffset;
+
+ if (results->rawlen < (2 * kMagiquestBits)) {
+ DPRINT("Not enough bits to be Magiquest - Rawlen: ");
+ DPRINT(results->rawlen);
+ DPRINT(" Expected: ");
+ DPRINTLN((2 * kMagiquestBits));
+ return false;
+ }
+
+ // Compliance
+ if (strict && nbits != kMagiquestBits) return false;
+
+ // Of six wands as datapoints, so far they all start with 8 ZEROs.
+ // For example, here is the data from two wands
+ // 00000000 00100011 01001100 00100110 00000010 00000010 00010111
+ // 00000000 00100000 10001000 00110001 00000010 00000010 10110100
+
+ // Decode the (MARK + SPACE) bits
+ while (offset + 1 < results->rawlen && bits < nbits - 1) {
+ uint16_t mark = results->rawbuf[offset];
+ uint16_t space = results->rawbuf[offset + 1];
+ if (!matchMark(mark + space, kMagiQuestTotalUsec)) {
+ DPRINT("Not enough time to be Magiquest - Mark: ");
+ DPRINT(mark);
+ DPRINT(" Space: ");
+ DPRINT(space);
+ DPRINT(" Total: ");
+ DPRINT(mark + space);
+ DPRINT("Expected: ");
+ DPRINTLN(kMagiQuestTotalUsec);
+ return false;
+ }
+
+ if (IS_ZERO(mark, space))
+ data = (data << 1) | 0;
+ else if (IS_ONE(mark, space))
+ data = (data << 1) | 1;
+ else
+ return false;
+
+ bits++;
+ offset += 2;
+
+ // Compliance
+ // The first 8 bits of this protocol are supposed to all be 0.
+ // Exit out early as it is never going to match.
+ if (strict && bits == 8 && data != 0) return false;
+ }
+
+ // Last bit is special as the protocol ends with a SPACE, not a MARK.
+ // Grab the last MARK bit, assuming a good SPACE after it
+ if (offset < results->rawlen) {
+ uint16_t mark = results->rawbuf[offset];
+ uint16_t space = (kMagiQuestTotalUsec / kRawTick) - mark;
+
+ if (IS_ZERO(mark, space))
+ data = (data << 1) | 0;
+ else if (IS_ONE(mark, space))
+ data = (data << 1) | 1;
+ else
+ return false;
+
+ bits++;
+ }
+
+ if (bits != nbits) return false;
+
+ if (strict) {
+ // The top 8 bits of the 56 bits needs to be 0x00 to be valid.
+ // i.e. bits 56 to 49 are all zero.
+ if ((data >> (nbits - 8)) != 0) return false;
+ }
+
+ // Success
+ results->decode_type = MAGIQUEST;
+ results->bits = bits;
+ results->value = data;
+ results->address = data >> 16; // Wand ID
+ results->command = data & 0xFFFF; // Magnitude
+ return true;
+}
+#endif
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Magiquest.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Magiquest.h
new file mode 100644
index 000000000000..d2d82d152767
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Magiquest.h
@@ -0,0 +1,35 @@
+// Copyright 2013 mpflaga
+// Copyright 2015 kitlaan
+// Copyright 2017 Jason kendall, David Conran
+
+#ifndef IR_MAGIQUEST_H_
+#define IR_MAGIQUEST_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// MagiQuest packet is both Wand ID and magnitude of swish and flick
+union magiquest {
+ uint64_t llword;
+ uint8_t byte[8];
+ // uint16_t word[4];
+ uint32_t lword[2];
+ struct {
+ uint16_t magnitude;
+ uint32_t wand_id;
+ uint8_t padding;
+ uint8_t scrap;
+ } cmd;
+};
+
+const uint16_t kMagiQuestTotalUsec = 1150;
+const uint8_t kMagiQuestZeroRatio = 30; // usually <= ~25%
+const uint8_t kMagiQuestOneRatio = 38; // usually >= ~50%
+const uint16_t kMagiQuestMarkZero = 280;
+const uint16_t kMagiQuestSpaceZero = 850;
+const uint16_t kMagiQuestMarkOne = 580;
+const uint16_t kMagiQuestSpaceOne = 600;
+const uint32_t kMagiQuestGap = 100000; // A guess of the gap between messages
+#endif // IR_MAGIQUEST_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Midea.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Midea.cpp
new file mode 100644
index 000000000000..8e55c7d227be
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Midea.cpp
@@ -0,0 +1,403 @@
+// Copyright 2017 bwze, crankyoldgit
+
+#include "ir_Midea.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// MM MM IIIII DDDDD EEEEEEE AAA
+// MMM MMM III DD DD EE AAAAA
+// MM MM MM III DD DD EEEEE AA AA
+// MM MM III DD DD EE AAAAAAA
+// MM MM IIIII DDDDDD EEEEEEE AA AA
+
+// Midea A/C added by (send) bwze/crankyoldgit & (decode) crankyoldgit
+//
+// Equipment it seems compatible with:
+// * Pioneer System Model RYBO12GMFILCAD (12K BTU)
+// * Pioneer System Model RUBO18GMFILCAD (18K BTU)
+// *
+
+// Ref:
+// https://docs.google.com/spreadsheets/d/1TZh4jWrx4h9zzpYUI9aYXMl1fYOiqu-xVuOOMqagxrs/edit?usp=sharing
+
+// Constants
+const uint16_t kMideaTick = 80;
+const uint16_t kMideaBitMarkTicks = 7;
+const uint16_t kMideaBitMark = kMideaBitMarkTicks * kMideaTick;
+const uint16_t kMideaOneSpaceTicks = 21;
+const uint16_t kMideaOneSpace = kMideaOneSpaceTicks * kMideaTick;
+const uint16_t kMideaZeroSpaceTicks = 7;
+const uint16_t kMideaZeroSpace = kMideaZeroSpaceTicks * kMideaTick;
+const uint16_t kMideaHdrMarkTicks = 56;
+const uint16_t kMideaHdrMark = kMideaHdrMarkTicks * kMideaTick;
+const uint16_t kMideaHdrSpaceTicks = 56;
+const uint16_t kMideaHdrSpace = kMideaHdrSpaceTicks * kMideaTick;
+const uint16_t kMideaMinGapTicks =
+ kMideaHdrMarkTicks + kMideaZeroSpaceTicks + kMideaBitMarkTicks;
+const uint16_t kMideaMinGap = kMideaMinGapTicks * kMideaTick;
+const uint8_t kMideaTolerance = 30; // Percent
+
+#if SEND_MIDEA
+// Send a Midea message
+//
+// Args:
+// data: Contents of the message to be sent.
+// nbits: Nr. of bits of data to be sent. Typically kMideaBits.
+// repeat: Nr. of additional times the message is to be sent.
+//
+// Status: Alpha / Needs testing against a real device.
+//
+void IRsend::sendMidea(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ if (nbits % 8 != 0) return; // nbits is required to be a multiple of 8.
+
+ // Set IR carrier frequency
+ enableIROut(38);
+
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // The protcol sends the message, then follows up with an entirely
+ // inverted payload.
+ for (size_t inner_loop = 0; inner_loop < 2; inner_loop++) {
+ // Header
+ mark(kMideaHdrMark);
+ space(kMideaHdrSpace);
+ // Data
+ // Break data into byte segments, starting at the Most Significant
+ // Byte. Each byte then being sent normal, then followed inverted.
+ for (uint16_t i = 8; i <= nbits; i += 8) {
+ // Grab a bytes worth of data.
+ uint8_t segment = (data >> (nbits - i)) & 0xFF;
+ sendData(kMideaBitMark, kMideaOneSpace, kMideaBitMark, kMideaZeroSpace,
+ segment, 8, true);
+ }
+ // Footer
+ mark(kMideaBitMark);
+ space(kMideaMinGap); // Pause before repeating
+
+ // Invert the data for the 2nd phase of the message.
+ // As we get called twice in the inner loop, we will always revert
+ // to the original 'data' state.
+ data = ~data;
+ }
+ }
+}
+#endif
+
+// Code to emulate Midea A/C IR remote control unit.
+// Warning: Consider this very alpha code.
+
+// Initialise the object.
+IRMideaAC::IRMideaAC(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+// Reset the state of the remote to a known good state/sequence.
+void IRMideaAC::stateReset() {
+ // Power On, Mode Auto, Fan Auto, Temp = 25C/77F
+ remote_state = 0xA1826FFFFF62;
+}
+
+// Configure the pin for output.
+void IRMideaAC::begin() { _irsend.begin(); }
+
+#if SEND_MIDEA
+// Send the current desired state to the IR LED.
+void IRMideaAC::send() {
+ checksum(); // Ensure correct checksum before sending.
+ _irsend.sendMidea(remote_state);
+}
+#endif // SEND_MIDEA
+
+// Return a pointer to the internal state date of the remote.
+uint64_t IRMideaAC::getRaw() {
+ checksum();
+ return remote_state & kMideaACStateMask;
+}
+
+// Override the internal state with the new state.
+void IRMideaAC::setRaw(uint64_t newState) {
+ remote_state = newState & kMideaACStateMask;
+}
+
+// Set the requested power state of the A/C to off.
+void IRMideaAC::on() { remote_state |= kMideaACPower; }
+
+// Set the requested power state of the A/C to off.
+void IRMideaAC::off() { remote_state &= (kMideaACStateMask ^ kMideaACPower); }
+
+// Set the requested power state of the A/C.
+void IRMideaAC::setPower(const bool state) {
+ if (state)
+ on();
+ else
+ off();
+}
+
+// Return the requested power state of the A/C.
+bool IRMideaAC::getPower() { return (remote_state & kMideaACPower); }
+
+// Set the temperature.
+// Args:
+// temp: Temp. in degrees.
+// useCelsius: Degree type to use. Celsius (true) or Fahrenheit (false)
+void IRMideaAC::setTemp(const uint8_t temp, const bool useCelsius) {
+ uint8_t new_temp = temp;
+ if (useCelsius) {
+ new_temp = std::max(kMideaACMinTempC, new_temp);
+ new_temp = std::min(kMideaACMaxTempC, new_temp);
+ new_temp = (uint8_t)((new_temp * 1.8) + 32.5); // 0.5 so we rounding.
+ }
+ new_temp = std::max(kMideaACMinTempF, new_temp);
+ new_temp = std::min(kMideaACMaxTempF, new_temp);
+ new_temp -= kMideaACMinTempF;
+ remote_state &= kMideaACTempMask;
+ remote_state |= ((uint64_t)new_temp << 24);
+}
+
+// Return the set temp.
+// Args:
+// useCelsius: Flag indicating if the results are in Celsius or Fahrenheit.
+// Returns:
+// A uint8_t containing the temperature.
+uint8_t IRMideaAC::getTemp(const bool useCelsius) {
+ uint8_t temp = ((remote_state >> 24) & 0x1F) + kMideaACMinTempF;
+ if (useCelsius) {
+ temp = (uint8_t)((temp - 32) / 1.8);
+ }
+ return temp;
+}
+
+// Set the speed of the fan,
+// 1-3 set the speed, 0 or anything else set it to auto.
+void IRMideaAC::setFan(const uint8_t fan) {
+ uint64_t new_fan;
+ switch (fan) {
+ case kMideaACFanLow:
+ case kMideaACFanMed:
+ case kMideaACFanHigh:
+ new_fan = fan;
+ break;
+ default:
+ new_fan = kMideaACFanAuto;
+ }
+ remote_state &= kMideaACFanMask;
+ remote_state |= (new_fan << 35);
+}
+
+// Return the requested state of the unit's fan.
+uint8_t IRMideaAC::getFan() { return (remote_state >> 35) & 0b111; }
+
+// Get the requested climate operation mode of the a/c unit.
+// Returns:
+// A uint8_t containing the A/C mode.
+uint8_t IRMideaAC::getMode() { return ((remote_state >> 32) & 0b111); }
+
+// Set the requested climate operation mode of the a/c unit.
+void IRMideaAC::setMode(const uint8_t mode) {
+ // If we get an unexpected mode, default to AUTO.
+ uint64_t new_mode;
+ switch (mode) {
+ case kMideaACAuto:
+ case kMideaACCool:
+ case kMideaACHeat:
+ case kMideaACDry:
+ case kMideaACFan:
+ new_mode = mode;
+ break;
+ default:
+ new_mode = kMideaACAuto;
+ }
+ remote_state &= kMideaACModeMask;
+ remote_state |= (new_mode << 32);
+}
+
+// Set the Sleep state of the A/C.
+void IRMideaAC::setSleep(const bool state) {
+ if (state)
+ remote_state |= kMideaACSleep;
+ else
+ remote_state &= (kMideaACStateMask ^ kMideaACSleep);
+}
+
+// Return the Sleep state of the A/C.
+bool IRMideaAC::getSleep() { return (remote_state & kMideaACSleep); }
+
+// Calculate the checksum for a given array.
+// Args:
+// state: The state to calculate the checksum over.
+// Returns:
+// The 8 bit checksum value.
+uint8_t IRMideaAC::calcChecksum(const uint64_t state) {
+ uint8_t sum = 0;
+ uint64_t temp_state = state;
+
+ for (uint8_t i = 0; i < 5; i++) {
+ temp_state >>= 8;
+ sum += reverseBits((temp_state & 0xFF), 8);
+ }
+ sum = 256 - sum;
+ return reverseBits(sum, 8);
+}
+
+// Verify the checksum is valid for a given state.
+// Args:
+// state: The state to verify the checksum of.
+// Returns:
+// A boolean.
+bool IRMideaAC::validChecksum(const uint64_t state) {
+ return ((state & 0xFF) == calcChecksum(state));
+}
+
+// Calculate & set the checksum for the current internal state of the remote.
+void IRMideaAC::checksum() {
+ // Stored the checksum value in the last byte.
+ remote_state &= kMideaACChecksumMask;
+ remote_state |= calcChecksum(remote_state);
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRMideaAC::toString() {
+ String result = "";
+#else
+std::string IRMideaAC::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kMideaACAuto:
+ result += " (AUTO)";
+ break;
+ case kMideaACCool:
+ result += " (COOL)";
+ break;
+ case kMideaACHeat:
+ result += " (HEAT)";
+ break;
+ case kMideaACDry:
+ result += " (DRY)";
+ break;
+ case kMideaACFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp(true)) + "C/" +
+ uint64ToString(getTemp(false)) + "F";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kMideaACFanAuto:
+ result += " (AUTO)";
+ break;
+ case kMideaACFanLow:
+ result += " (LOW)";
+ break;
+ case kMideaACFanMed:
+ result += " (MED)";
+ break;
+ case kMideaACFanHigh:
+ result += " (HI)";
+ break;
+ }
+ result += ", Sleep: ";
+ if (getSleep())
+ result += "On";
+ else
+ result += "Off";
+ return result;
+}
+
+#if DECODE_MIDEA
+// Decode the supplied Midea message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kMideaBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: Alpha / Needs testing against a real device.
+//
+bool IRrecv::decodeMidea(decode_results *results, uint16_t nbits, bool strict) {
+ if (nbits % 8 != 0) // nbits has to be a multiple of nr. of bits in a byte.
+ return false;
+
+ uint8_t min_nr_of_messages = 1;
+ if (strict) {
+ if (nbits != kMideaBits) return false; // Not strictly a MIDEA message.
+ min_nr_of_messages = 2;
+ }
+
+ // The protocol sends the data normal + inverted, alternating on
+ // each byte. Hence twice the number of expected data bits.
+ if (results->rawlen <
+ min_nr_of_messages * (2 * nbits + kHeader + kFooter) - 1)
+ return false; // Can't possibly be a valid MIDEA message.
+
+ uint64_t data = 0;
+ uint64_t inverted = 0;
+ uint16_t offset = kStartOffset;
+
+ if (nbits > sizeof(data) * 8)
+ return false; // We can't possibly capture a Midea packet that big.
+
+ for (uint8_t i = 0; i < min_nr_of_messages; i++) {
+ // Header
+ if (!matchMark(results->rawbuf[offset], kMideaHdrMark)) return false;
+ // Calculate how long the common tick time is based on the header mark.
+ uint32_t m_tick = results->rawbuf[offset++] * kRawTick / kMideaHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kMideaHdrSpace)) return false;
+ // Calculate how long the common tick time is based on the header space.
+ uint32_t s_tick =
+ results->rawbuf[offset++] * kRawTick / kMideaHdrSpaceTicks;
+
+ // Data (Normal)
+ match_result_t data_result = matchData(
+ &(results->rawbuf[offset]), nbits, kMideaBitMarkTicks * m_tick,
+ kMideaOneSpaceTicks * s_tick, kMideaBitMarkTicks * m_tick,
+ kMideaZeroSpaceTicks * s_tick, kMideaTolerance);
+ if (data_result.success == false) return false;
+ offset += data_result.used;
+ if (i % 2 == 0)
+ data = data_result.data;
+ else
+ inverted = data_result.data;
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kMideaBitMarkTicks * m_tick,
+ kMideaTolerance))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kMideaMinGapTicks * s_tick,
+ kMideaTolerance))
+ return false;
+ }
+
+ // Compliance
+ if (strict) {
+ // Protocol requires a second message with all the data bits inverted.
+ // We should have checked we got a second message in the previous loop.
+ // Just need to check it's value is an inverted copy of the first message.
+ uint64_t mask = (1ULL << kMideaBits) - 1;
+ if ((data & mask) != ((inverted ^ mask) & mask)) return false;
+ if (!IRMideaAC::validChecksum(data)) return false;
+ }
+
+ // Success
+ results->decode_type = MIDEA;
+ results->bits = nbits;
+ results->value = data;
+ results->address = 0;
+ results->command = 0;
+ return true;
+}
+#endif // DECODE_MIDEA
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Midea.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Midea.h
new file mode 100644
index 000000000000..aa9f94a928a2
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Midea.h
@@ -0,0 +1,103 @@
+// Copyright 2017 David Conran
+#ifndef IR_MIDEA_H_
+#define IR_MIDEA_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifdef ARDUINO
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// MM MM IIIII DDDDD EEEEEEE AAA
+// MMM MMM III DD DD EE AAAAA
+// MM MM MM III DD DD EEEEE AA AA
+// MM MM III DD DD EE AAAAAAA
+// MM MM IIIII DDDDDD EEEEEEE AA AA
+
+// Midea added by crankyoldgit & bwze
+// Ref:
+// https://docs.google.com/spreadsheets/d/1TZh4jWrx4h9zzpYUI9aYXMl1fYOiqu-xVuOOMqagxrs/edit?usp=sharing
+
+// Constants
+const uint8_t kMideaACCool = 0; // 0b000
+const uint8_t kMideaACDry = 1; // 0b001
+const uint8_t kMideaACAuto = 2; // 0b010
+const uint8_t kMideaACHeat = 3; // 0b011
+const uint8_t kMideaACFan = 4; // 0b100
+const uint8_t kMideaACFanAuto = 0; // 0b000
+const uint8_t kMideaACFanLow = 1; // 0b001
+const uint8_t kMideaACFanMed = 2; // 0b010
+const uint8_t kMideaACFanHigh = 3; // 0b011
+const uint64_t kMideaACPower = 1ULL << 39;
+const uint64_t kMideaACSleep = 1ULL << 38;
+const uint8_t kMideaACMinTempF = 62; // Fahrenheit
+const uint8_t kMideaACMaxTempF = 86; // Fahrenheit
+const uint8_t kMideaACMinTempC = 16; // Celsius
+const uint8_t kMideaACMaxTempC = 30; // Celsius
+const uint64_t kMideaACStateMask = 0x0000FFFFFFFFFFFF;
+const uint64_t kMideaACTempMask = 0x0000FFFFE0FFFFFF;
+const uint64_t kMideaACFanMask = 0x0000FFC7FFFFFFFF;
+const uint64_t kMideaACModeMask = 0x0000FFF8FFFFFFFF;
+const uint64_t kMideaACChecksumMask = 0x0000FFFFFFFFFF00;
+
+// Legacy defines. (Deprecated)
+#define MIDEA_AC_COOL kMideaACCool
+#define MIDEA_AC_DRY kMideaACDry
+#define MIDEA_AC_AUTO kMideaACAuto
+#define MIDEA_AC_HEAT kMideaACHeat
+#define MIDEA_AC_FAN kMideaACFan
+#define MIDEA_AC_FAN_AUTO kMideaACFanAuto
+#define MIDEA_AC_FAN_LOW kMideaACFanLow
+#define MIDEA_AC_FAN_MED kMideaACFanMed
+#define MIDEA_AC_FAN_HI kMideaACFanHigh
+#define MIDEA_AC_POWER kMideaACPower
+#define MIDEA_AC_SLEEP kMideaACSleep
+#define MIDEA_AC_MIN_TEMP_F kMideaACMinTempF
+#define MIDEA_AC_MAX_TEMP_F kMideaACMaxTempF
+#define MIDEA_AC_MIN_TEMP_C kMideaACMinTempC
+#define MIDEA_AC_MAX_TEMP_C kMideaACMaxTempC
+
+class IRMideaAC {
+ public:
+ explicit IRMideaAC(uint16_t pin);
+
+ void stateReset();
+#if SEND_MIDEA
+ void send();
+#endif // SEND_MIDEA
+ void begin();
+ void on();
+ void off();
+ void setPower(const bool state);
+ bool getPower();
+ void setTemp(const uint8_t temp, const bool useCelsius = false);
+ uint8_t getTemp(const bool useCelsius = false);
+ void setFan(const uint8_t fan);
+ uint8_t getFan();
+ void setMode(const uint8_t mode);
+ uint8_t getMode();
+ void setRaw(uint64_t newState);
+ uint64_t getRaw();
+ static bool validChecksum(const uint64_t state);
+ void setSleep(const bool state);
+ bool getSleep();
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
+#ifndef UNIT_TEST
+
+ private:
+#endif
+ uint64_t remote_state;
+ void checksum();
+ static uint8_t calcChecksum(const uint64_t state);
+ IRsend _irsend;
+};
+
+#endif // IR_MIDEA_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Mitsubishi.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Mitsubishi.cpp
new file mode 100644
index 000000000000..b092c27b9573
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Mitsubishi.cpp
@@ -0,0 +1,714 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2017-2018 David Conran
+// Copyright 2018 Denes Varga
+
+#include "ir_Mitsubishi.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// MMMMM IIIII TTTTT SSSS U U BBBB IIIII SSSS H H IIIII
+// M M M I T S U U B B I S H H I
+// M M M I T SSS U U BBBB I SSS HHHHH I
+// M M I T S U U B B I S H H I
+// M M IIIII T SSSS UUU BBBBB IIIII SSSS H H IIIII
+
+// Mitsubishi (TV) decoding added from https://github.com/z3t0/Arduino-IRremote
+// Mitsubishi (TV) sending & Mitsubishi A/C support added by David Conran
+
+// Constants
+// Mitsubishi TV
+// period time is 1/33000Hz = 30.303 uSeconds (T)
+// Ref:
+// GlobalCache's Control Tower's Mitsubishi TV data.
+// https://github.com/marcosamarinho/IRremoteESP8266/blob/master/ir_Mitsubishi.cpp
+const uint16_t kMitsubishiTick = 30;
+const uint16_t kMitsubishiBitMarkTicks = 10;
+const uint16_t kMitsubishiBitMark = kMitsubishiBitMarkTicks * kMitsubishiTick;
+const uint16_t kMitsubishiOneSpaceTicks = 70;
+const uint16_t kMitsubishiOneSpace = kMitsubishiOneSpaceTicks * kMitsubishiTick;
+const uint16_t kMitsubishiZeroSpaceTicks = 30;
+const uint16_t kMitsubishiZeroSpace =
+ kMitsubishiZeroSpaceTicks * kMitsubishiTick;
+const uint16_t kMitsubishiMinCommandLengthTicks = 1786;
+const uint16_t kMitsubishiMinCommandLength =
+ kMitsubishiMinCommandLengthTicks * kMitsubishiTick;
+const uint16_t kMitsubishiMinGapTicks = 936;
+const uint16_t kMitsubishiMinGap = kMitsubishiMinGapTicks * kMitsubishiTick;
+
+// Mitsubishi Projector (HC3000)
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/441
+
+const uint16_t kMitsubishi2HdrMark = 8400;
+const uint16_t kMitsubishi2HdrSpace = kMitsubishi2HdrMark / 2;
+const uint16_t kMitsubishi2BitMark = 560;
+const uint16_t kMitsubishi2ZeroSpace = 520;
+const uint16_t kMitsubishi2OneSpace = kMitsubishi2ZeroSpace * 3;
+const uint16_t kMitsubishi2MinGap = 28500;
+
+// Mitsubishi A/C
+// Ref:
+// https://github.com/r45635/HVAC-IR-Control/blob/master/HVAC_ESP8266/HVAC_ESP8266.ino#L84
+
+const uint16_t kMitsubishiAcHdrMark = 3400;
+const uint16_t kMitsubishiAcHdrSpace = 1750;
+const uint16_t kMitsubishiAcBitMark = 450;
+const uint16_t kMitsubishiAcOneSpace = 1300;
+const uint16_t kMitsubishiAcZeroSpace = 420;
+const uint16_t kMitsubishiAcRptMark = 440;
+const uint16_t kMitsubishiAcRptSpace = 17100;
+
+#if SEND_MITSUBISHI
+// Send a Mitsubishi message
+//
+// Args:
+// data: Contents of the message to be sent.
+// nbits: Nr. of bits of data to be sent. Typically kMitsubishiBits.
+// repeat: Nr. of additional times the message is to be sent.
+//
+// Status: ALPHA / untested.
+//
+// Notes:
+// This protocol appears to have no header.
+// Ref:
+// https://github.com/marcosamarinho/IRremoteESP8266/blob/master/ir_Mitsubishi.cpp
+// GlobalCache's Control Tower's Mitsubishi TV data.
+void IRsend::sendMitsubishi(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ sendGeneric(0, 0, // No Header
+ kMitsubishiBitMark, kMitsubishiOneSpace, kMitsubishiBitMark,
+ kMitsubishiZeroSpace, kMitsubishiBitMark, kMitsubishiMinGap,
+ kMitsubishiMinCommandLength, data, nbits, 33, true, repeat, 50);
+}
+#endif // SEND_MITSUBISHI
+
+#if DECODE_MITSUBISHI
+// Decode the supplied Mitsubishi message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of data bits to expect.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / previously working.
+//
+// Notes:
+// This protocol appears to have no header.
+//
+// Ref:
+// GlobalCache's Control Tower's Mitsubishi TV data.
+bool IRrecv::decodeMitsubishi(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < 2 * nbits + kFooter - 1)
+ return false; // Shorter than shortest possibly expected.
+ if (strict && nbits != kMitsubishiBits)
+ return false; // Request is out of spec.
+
+ uint16_t offset = kStartOffset;
+ uint64_t data = 0;
+
+ // No Header
+ // But try to auto-calibrate off the initial mark signal.
+ if (!matchMark(results->rawbuf[offset], kMitsubishiBitMark, 30)) return false;
+ // Calculate how long the common tick time is based on the initial mark.
+ uint32_t tick = results->rawbuf[offset] * kRawTick / kMitsubishiBitMarkTicks;
+
+ // Data
+ match_result_t data_result = matchData(
+ &(results->rawbuf[offset]), nbits, kMitsubishiBitMarkTicks * tick,
+ kMitsubishiOneSpaceTicks * tick, kMitsubishiBitMarkTicks * tick,
+ kMitsubishiZeroSpaceTicks * tick);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+ uint16_t actualBits = data_result.used / 2;
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kMitsubishiBitMarkTicks * tick, 30))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kMitsubishiMinGapTicks * tick))
+ return false;
+
+ // Compliance
+ if (actualBits < nbits) return false;
+ if (strict && actualBits != nbits) return false; // Not as we expected.
+
+ // Success
+ results->decode_type = MITSUBISHI;
+ results->bits = actualBits;
+ results->value = data;
+ results->address = 0;
+ results->command = 0;
+ return true;
+}
+#endif // DECODE_MITSUBISHI
+
+#if SEND_MITSUBISHI2
+// Send a Mitsubishi2 message
+//
+// Args:
+// data: Contents of the message to be sent.
+// nbits: Nr. of bits of data to be sent. Typically kMitsubishiBits.
+// repeat: Nr. of additional times the message is to be sent.
+//
+// Status: ALPHA / untested.
+//
+// Notes:
+// Based on a Mitsubishi HC3000 projector's remote.
+// This protocol appears to have a manditory in-protocol repeat.
+// That is in *addition* to the entire message needing to be sent twice
+// for the device to accept the command. That is separate from the repeat.
+// i.e. Allegedly, the real remote requires the "OFF" button pressed twice.
+// You will need to add a suitable gap yourself.
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/441
+void IRsend::sendMitsubishi2(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ for (uint16_t i = 0; i <= repeat; i++) {
+ // First half of the data.
+ sendGeneric(kMitsubishi2HdrMark, kMitsubishi2HdrSpace, kMitsubishi2BitMark,
+ kMitsubishi2OneSpace, kMitsubishi2BitMark,
+ kMitsubishi2ZeroSpace, kMitsubishi2BitMark,
+ kMitsubishi2HdrSpace, data >> (nbits / 2), nbits / 2, 33, true,
+ 0, 50);
+ // Second half of the data.
+ sendGeneric(0, 0, // No header for the second data block
+ kMitsubishi2BitMark, kMitsubishi2OneSpace, kMitsubishi2BitMark,
+ kMitsubishi2ZeroSpace, kMitsubishi2BitMark, kMitsubishi2MinGap,
+ data & ((1 << (nbits / 2)) - 1), nbits / 2, 33, true, 0, 50);
+ }
+}
+#endif // SEND_MITSUBISHI2
+
+#if DECODE_MITSUBISHI2
+// Decode the supplied Mitsubishi2 message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of data bits to expect.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Works with simulated data.
+//
+// Notes:
+// Hardware supported:
+// * Mitsubishi HC3000 projector's remote.
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/441
+bool IRrecv::decodeMitsubishi2(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < 2 * nbits + kHeader + (kFooter * 2) - 1)
+ return false; // Shorter than shortest possibly expected.
+ if (strict && nbits != kMitsubishiBits)
+ return false; // Request is out of spec.
+
+ uint16_t offset = kStartOffset;
+ uint64_t data = 0;
+ uint16_t actualBits = 0;
+
+ // Header
+ if (!matchMark(results->rawbuf[offset++], kMitsubishi2HdrMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kMitsubishi2HdrSpace))
+ return false;
+ for (uint8_t i = 1; i <= 2; i++) {
+ // Data
+ match_result_t data_result = matchData(
+ &(results->rawbuf[offset]), nbits / 2, kMitsubishi2BitMark,
+ kMitsubishi2OneSpace, kMitsubishi2BitMark, kMitsubishi2ZeroSpace);
+ if (data_result.success == false) return false;
+ data <<= nbits / 2;
+ data += data_result.data;
+ offset += data_result.used;
+ actualBits += data_result.used / 2;
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kMitsubishi2BitMark))
+ return false;
+ if (i % 2) { // Every odd data block, we expect a HDR space.
+ if (!matchSpace(results->rawbuf[offset++], kMitsubishi2HdrSpace))
+ return false;
+ } else { // Every even data block, we expect Min Gap or end of the message.
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kMitsubishi2MinGap))
+ return false;
+ }
+ }
+
+ // Compliance
+ if (actualBits < nbits) return false;
+ if (strict && actualBits != nbits) return false; // Not as we expected.
+
+ // Success
+ results->decode_type = MITSUBISHI2;
+ results->bits = actualBits;
+ results->value = data;
+ results->address = data >> actualBits / 2;
+ results->command = data & ((1 << (actualBits / 2)) - 1);
+ return true;
+}
+#endif // DECODE_MITSUBISHI2
+
+#if SEND_MITSUBISHI_AC
+// Send a Mitsubishi A/C message.
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kMitsubishiACStateLength)
+// repeat: Nr. of times the message is to be repeated.
+// (Default = kMitsubishiACMinRepeat).
+//
+// Status: BETA / Appears to be working.
+//
+void IRsend::sendMitsubishiAC(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kMitsubishiACStateLength)
+ return; // Not enough bytes to send a proper message.
+
+ sendGeneric(kMitsubishiAcHdrMark, kMitsubishiAcHdrSpace, kMitsubishiAcBitMark,
+ kMitsubishiAcOneSpace, kMitsubishiAcBitMark,
+ kMitsubishiAcZeroSpace, kMitsubishiAcRptMark,
+ kMitsubishiAcRptSpace, data, nbytes, 38, false, repeat, 50);
+}
+#endif // SEND_MITSUBISHI_AC
+
+#if DECODE_MITSUBISHI_AC
+// Decode the supplied Mitsubishi message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of data bits to expect.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: ALPHA / Under development
+//
+// Ref:
+// https://www.analysir.com/blog/2015/01/06/reverse-engineering-mitsubishi-ac-infrared-protocol/
+bool IRrecv::decodeMitsubishiAC(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < ((kMitsubishiACBits * 2) + 2)) {
+ DPRINTLN("Shorter than shortest possibly expected.");
+ return false; // Shorter than shortest possibly expected.
+ }
+ if (strict && nbits != kMitsubishiACBits) {
+ DPRINTLN("Request is out of spec.");
+ return false; // Request is out of spec.
+ }
+ uint16_t offset = kStartOffset;
+ for (uint8_t i = 0; i < kMitsubishiACStateLength; i++) {
+ results->state[i] = 0;
+ }
+ bool failure = false;
+ uint8_t rep = 0;
+ do {
+ failure = false;
+ // Header:
+ // Somtime happens that junk signals arrives before the real message
+ bool headerFound = false;
+ while (!headerFound &&
+ offset < (results->rawlen - (kMitsubishiACBits * 2 + 2))) {
+ headerFound =
+ matchMark(results->rawbuf[offset++], kMitsubishiAcHdrMark) &&
+ matchSpace(results->rawbuf[offset++], kMitsubishiAcHdrSpace);
+ }
+ if (!headerFound) {
+ DPRINTLN("Header mark not found.");
+ failure = true;
+ }
+ // Decode byte-by-byte:
+ match_result_t data_result;
+ for (uint8_t i = 0; i < kMitsubishiACStateLength && !failure; i++) {
+ results->state[i] = 0;
+ data_result =
+ matchData(&(results->rawbuf[offset]), 8, kMitsubishiAcBitMark,
+ kMitsubishiAcOneSpace, kMitsubishiAcBitMark,
+ kMitsubishiAcZeroSpace, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) {
+ failure = true;
+ DPRINT("Byte decode failed at #");
+ DPRINTLN((uint16_t)i);
+ } else {
+ results->state[i] = data_result.data;
+ offset += data_result.used;
+ DPRINT((uint16_t)results->state[i]);
+ DPRINT(",");
+ }
+ DPRINTLN("");
+ }
+ // HEADER validation:
+ if (failure || results->state[0] != 0x23 || results->state[1] != 0xCB ||
+ results->state[2] != 0x26 || results->state[3] != 0x01 ||
+ results->state[4] != 0x00) {
+ DPRINTLN("Header mismatch.");
+ failure = true;
+ } else {
+ // DATA part:
+
+ // FOOTER checksum:
+ if (IRMitsubishiAC::calculateChecksum(results->state) !=
+ results->state[kMitsubishiACStateLength - 1]) {
+ DPRINTLN("Checksum error.");
+ failure = true;
+ }
+ }
+ if (rep != kMitsubishiACMinRepeat && failure) {
+ bool repeatMarkFound = false;
+ while (!repeatMarkFound &&
+ offset < (results->rawlen - (kMitsubishiACBits * 2 + 4))) {
+ repeatMarkFound =
+ matchMark(results->rawbuf[offset++], kMitsubishiAcRptMark) &&
+ matchSpace(results->rawbuf[offset++], kMitsubishiAcRptSpace);
+ }
+ if (!repeatMarkFound) {
+ DPRINTLN("First attempt failure and repeat mark not found.");
+ return false;
+ }
+ }
+ rep++;
+ // Check if the repeat is correct if we need strict decode:
+ if (strict && !failure) {
+ DPRINTLN("Strict repeat check enabled.");
+ // Repeat mark and space:
+ if (!matchMark(results->rawbuf[offset++], kMitsubishiAcRptMark) ||
+ !matchSpace(results->rawbuf[offset++], kMitsubishiAcRptSpace)) {
+ DPRINTLN("Repeat mark error.");
+ return false;
+ }
+ // Header mark and space:
+ if (!matchMark(results->rawbuf[offset++], kMitsubishiAcHdrMark) ||
+ !matchSpace(results->rawbuf[offset++], kMitsubishiAcHdrSpace)) {
+ DPRINTLN("Repeat header error.");
+ return false;
+ }
+ // Payload:
+ for (uint8_t i = 0; i < kMitsubishiACStateLength; i++) {
+ data_result =
+ matchData(&(results->rawbuf[offset]), 8, kMitsubishiAcBitMark,
+ kMitsubishiAcOneSpace, kMitsubishiAcBitMark,
+ kMitsubishiAcZeroSpace, kTolerance, kMarkExcess, false);
+ if (data_result.success == false ||
+ data_result.data != results->state[i]) {
+ DPRINTLN("Repeat payload error.");
+ return false;
+ }
+ offset += data_result.used;
+ }
+ } // strict repeat check
+ } while (failure && rep <= kMitsubishiACMinRepeat);
+ results->decode_type = MITSUBISHI_AC;
+ results->bits = kMitsubishiACStateLength * 8;
+ return true;
+}
+#endif // DECODE_MITSUBISHI_AC
+
+// Code to emulate Mitsubishi A/C IR remote control unit.
+// Inspired and derived from the work done at:
+// https://github.com/r45635/HVAC-IR-Control
+//
+// Warning: Consider this very alpha code. Seems to work, but not validated.
+//
+// Equipment it seems compatible with:
+// *
+// Initialise the object.
+IRMitsubishiAC::IRMitsubishiAC(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+// Reset the state of the remote to a known good state/sequence.
+void IRMitsubishiAC::stateReset() {
+ // The state of the IR remote in IR code form.
+ // Known good state obtained from:
+ // https://github.com/r45635/HVAC-IR-Control/blob/master/HVAC_ESP8266/HVAC_ESP8266.ino#L108
+ // Note: Can't use the following because it requires -std=c++11
+ // uint8_t known_good_state[kMitsubishiACStateLength] = {
+ // 0x23, 0xCB, 0x26, 0x01, 0x00, 0x20, 0x08, 0x06, 0x30, 0x45, 0x67, 0x00,
+ // 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F};
+ remote_state[0] = 0x23;
+ remote_state[1] = 0xCB;
+ remote_state[2] = 0x26;
+ remote_state[3] = 0x01;
+ remote_state[4] = 0x00;
+ remote_state[5] = 0x20;
+ remote_state[6] = 0x08;
+ remote_state[7] = 0x06;
+ remote_state[8] = 0x30;
+ remote_state[9] = 0x45;
+ remote_state[10] = 0x67;
+ for (uint8_t i = 11; i < kMitsubishiACStateLength - 1; i++)
+ remote_state[i] = 0;
+ remote_state[kMitsubishiACStateLength - 1] = 0x1F;
+ checksum(); // Calculate the checksum
+}
+
+// Configure the pin for output.
+void IRMitsubishiAC::begin() { _irsend.begin(); }
+
+#if SEND_MITSUBISHI_AC
+// Send the current desired state to the IR LED.
+void IRMitsubishiAC::send() {
+ checksum(); // Ensure correct checksum before sending.
+ _irsend.sendMitsubishiAC(remote_state);
+}
+#endif // SEND_MITSUBISHI_AC
+
+// Return a pointer to the internal state date of the remote.
+uint8_t *IRMitsubishiAC::getRaw() {
+ checksum();
+ return remote_state;
+}
+
+void IRMitsubishiAC::setRaw(uint8_t *data) {
+ for (uint8_t i = 0; i < (kMitsubishiACStateLength - 1); i++) {
+ remote_state[i] = data[i];
+ }
+ checksum();
+}
+
+// Calculate the checksum for the current internal state of the remote.
+void IRMitsubishiAC::checksum() {
+ remote_state[17] = calculateChecksum(remote_state);
+}
+
+uint8_t IRMitsubishiAC::calculateChecksum(uint8_t *data) {
+ uint8_t sum = 0;
+ // Checksum is simple addition of all previous bytes stored
+ // as an 8 bit value.
+ for (uint8_t i = 0; i < 17; i++) sum += data[i];
+ return sum & 0xFFU;
+}
+
+// Set the requested power state of the A/C to off.
+void IRMitsubishiAC::on() {
+ // state = ON;
+ remote_state[5] |= kMitsubishiAcPower;
+}
+
+// Set the requested power state of the A/C to off.
+void IRMitsubishiAC::off() {
+ // state = OFF;
+ remote_state[5] &= ~kMitsubishiAcPower;
+}
+
+// Set the requested power state of the A/C.
+void IRMitsubishiAC::setPower(bool state) {
+ if (state)
+ on();
+ else
+ off();
+}
+
+// Return the requested power state of the A/C.
+bool IRMitsubishiAC::getPower() {
+ return ((remote_state[5] & kMitsubishiAcPower) != 0);
+}
+
+// Set the temp. in deg C
+void IRMitsubishiAC::setTemp(uint8_t temp) {
+ temp = std::max((uint8_t)kMitsubishiAcMinTemp, temp);
+ temp = std::min((uint8_t)kMitsubishiAcMaxTemp, temp);
+ remote_state[7] = temp - kMitsubishiAcMinTemp;
+}
+
+// Return the set temp. in deg C
+uint8_t IRMitsubishiAC::getTemp() {
+ return (remote_state[7] + kMitsubishiAcMinTemp);
+}
+
+// Set the speed of the fan, 0-6.
+// 0 is auto, 1-5 is the speed, 6 is silent.
+void IRMitsubishiAC::setFan(uint8_t fan) {
+ // Bounds check
+ if (fan > kMitsubishiAcFanSilent)
+ fan = kMitsubishiAcFanMax; // Set the fan to maximum if out of range.
+ if (fan == kMitsubishiAcFanAuto) { // Automatic is a special case.
+ remote_state[9] = 0b10000000 | (remote_state[9] & 0b01111000);
+ return;
+ } else if (fan >= kMitsubishiAcFanMax) {
+ fan--; // There is no spoon^H^H^Heed 5 (max), pretend it doesn't exist.
+ }
+ remote_state[9] &= 0b01111000; // Clear the previous state
+ remote_state[9] |= fan;
+}
+
+// Return the requested state of the unit's fan.
+uint8_t IRMitsubishiAC::getFan() {
+ uint8_t fan = remote_state[9] & 0b111;
+ if (fan == kMitsubishiAcFanMax) return kMitsubishiAcFanSilent;
+ return fan;
+}
+
+// Return the requested climate operation mode of the a/c unit.
+uint8_t IRMitsubishiAC::getMode() { return (remote_state[6]); }
+
+// Set the requested climate operation mode of the a/c unit.
+void IRMitsubishiAC::setMode(uint8_t mode) {
+ // If we get an unexpected mode, default to AUTO.
+ switch (mode) {
+ case kMitsubishiAcAuto:
+ remote_state[8] = 0b00110000;
+ break;
+ case kMitsubishiAcCool:
+ remote_state[8] = 0b00110110;
+ break;
+ case kMitsubishiAcDry:
+ remote_state[8] = 0b00110010;
+ break;
+ case kMitsubishiAcHeat:
+ remote_state[8] = 0b00110000;
+ break;
+ default:
+ mode = kMitsubishiAcAuto;
+ remote_state[8] = 0b00110000;
+ }
+ remote_state[6] = mode;
+}
+
+// Set the requested vane operation mode of the a/c unit.
+void IRMitsubishiAC::setVane(uint8_t mode) {
+ mode = std::min(mode, (uint8_t)0b111); // bounds check
+ mode |= 0b1000;
+ mode <<= 3;
+ remote_state[9] &= 0b11000111; // Clear the previous setting.
+ remote_state[9] |= mode;
+}
+
+// Return the requested vane operation mode of the a/c unit.
+uint8_t IRMitsubishiAC::getVane() {
+ return ((remote_state[9] & 0b00111000) >> 3);
+}
+
+// Return the clock setting of the message. 1=1/6 hour. e.g. 4pm = 48
+uint8_t IRMitsubishiAC::getClock() { return remote_state[10]; }
+
+// Set the current time. 1 = 1/6 hour. e.g. 6am = 36.
+void IRMitsubishiAC::setClock(uint8_t clock) { remote_state[10] = clock; }
+
+// Return the desired start time. 1 = 1/6 hour. e.g. 1am = 6
+uint8_t IRMitsubishiAC::getStartClock() { return remote_state[12]; }
+
+// Set the desired start tiem of the AC. 1 = 1/6 hour. e.g. 8pm = 120
+void IRMitsubishiAC::setStartClock(uint8_t clock) { remote_state[12] = clock; }
+
+// Return the desired stop time of the AC. 1 = 1/6 hour. e.g 10pm = 132
+uint8_t IRMitsubishiAC::getStopClock() { return remote_state[11]; }
+
+// Set the desired stop time of the AC. 1 = 1/6 hour. e.g 10pm = 132
+void IRMitsubishiAC::setStopClock(uint8_t clock) { remote_state[11] = clock; }
+
+// Return the timer setting. Possible values: kMitsubishiAcNoTimer,
+// kMitsubishiAcStartTimer, kMitsubishiAcStopTimer,
+// kMitsubishiAcStartStopTimer
+uint8_t IRMitsubishiAC::getTimer() { return remote_state[13] & 0b111; }
+
+// Set the timer setting. Possible values: kMitsubishiAcNoTimer,
+// kMitsubishiAcStartTimer, kMitsubishiAcStopTimer,
+// kMitsubishiAcStartStopTimer
+void IRMitsubishiAC::setTimer(uint8_t timer) {
+ remote_state[13] = timer & 0b111;
+}
+
+#ifdef ARDUINO
+String IRMitsubishiAC::timeToString(uint64_t time) {
+ String result = "";
+#else
+std::string IRMitsubishiAC::timeToString(uint64_t time) {
+ std::string result = "";
+#endif // ARDUINO
+ if (time / 6 < 10) result += "0";
+ result += uint64ToString(time / 6);
+ result += ":";
+ if (time * 10 % 60 < 10) result += "0";
+ result += uint64ToString(time * 10 % 60);
+ return result;
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRMitsubishiAC::toString() {
+ String result = "";
+#else
+std::string IRMitsubishiAC::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ switch (getMode()) {
+ case MITSUBISHI_AC_AUTO:
+ result += " (AUTO)";
+ break;
+ case MITSUBISHI_AC_COOL:
+ result += " (COOL)";
+ break;
+ case MITSUBISHI_AC_DRY:
+ result += " (DRY)";
+ break;
+ case MITSUBISHI_AC_HEAT:
+ result += " (HEAT)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", FAN: ";
+ switch (getFan()) {
+ case MITSUBISHI_AC_FAN_AUTO:
+ result += "AUTO";
+ break;
+ case MITSUBISHI_AC_FAN_MAX:
+ result += "MAX";
+ break;
+ case MITSUBISHI_AC_FAN_SILENT:
+ result += "SILENT";
+ break;
+ default:
+ result += uint64ToString(getFan());
+ }
+ result += ", VANE: ";
+ switch (getVane()) {
+ case MITSUBISHI_AC_VANE_AUTO:
+ result += "AUTO";
+ break;
+ case MITSUBISHI_AC_VANE_AUTO_MOVE:
+ result += "AUTO MOVE";
+ break;
+ default:
+ result += uint64ToString(getVane());
+ }
+ result += ", Time: ";
+ result += timeToString(getClock());
+ result += ", On timer: ";
+ result += timeToString(getStartClock());
+ result += ", Off timer: ";
+ result += timeToString(getStopClock());
+ result += ", Timer: ";
+ switch (getTimer()) {
+ case kMitsubishiAcNoTimer:
+ result += "-";
+ break;
+ case kMitsubishiAcStartTimer:
+ result += "Start";
+ break;
+ case kMitsubishiAcStopTimer:
+ result += "Stop";
+ break;
+ case kMitsubishiAcStartStopTimer:
+ result += "Start+Stop";
+ break;
+ default:
+ result += "? (";
+ result += getTimer();
+ result += ")\n";
+ }
+ return result;
+}
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Mitsubishi.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Mitsubishi.h
new file mode 100644
index 000000000000..7b03efce6463
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Mitsubishi.h
@@ -0,0 +1,109 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2017 David Conran
+#ifndef IR_MITSUBISHI_H_
+#define IR_MITSUBISHI_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifndef UNIT_TEST
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// MMMMM IIIII TTTTT SSSS U U BBBB IIIII SSSS H H IIIII
+// M M M I T S U U B B I S H H I
+// M M M I T SSS U U BBBB I SSS HHHHH I
+// M M I T S U U B B I S H H I
+// M M IIIII T SSSS UUU BBBBB IIIII SSSS H H IIIII
+
+// Mitsubishi (TV) decoding added from https://github.com/z3t0/Arduino-IRremote
+// Mitsubishi (TV) sending & Mitsubishi A/C support added by David Conran
+
+// Constants
+const uint8_t kMitsubishiAcAuto = 0x20;
+const uint8_t kMitsubishiAcCool = 0x18;
+const uint8_t kMitsubishiAcDry = 0x10;
+const uint8_t kMitsubishiAcHeat = 0x08;
+const uint8_t kMitsubishiAcPower = 0x20;
+const uint8_t kMitsubishiAcFanAuto = 0;
+const uint8_t kMitsubishiAcFanMax = 5;
+const uint8_t kMitsubishiAcFanRealMax = 4;
+const uint8_t kMitsubishiAcFanSilent = 6;
+const uint8_t kMitsubishiAcMinTemp = 16; // 16C
+const uint8_t kMitsubishiAcMaxTemp = 31; // 31C
+const uint8_t kMitsubishiAcVaneAuto = 0;
+const uint8_t kMitsubishiAcVaneAutoMove = 7;
+const uint8_t kMitsubishiAcNoTimer = 0;
+const uint8_t kMitsubishiAcStartTimer = 5;
+const uint8_t kMitsubishiAcStopTimer = 3;
+const uint8_t kMitsubishiAcStartStopTimer = 7;
+
+// Legacy defines (Deprecated)
+#define MITSUBISHI_AC_VANE_AUTO_MOVE kMitsubishiAcVaneAutoMove
+#define MITSUBISHI_AC_VANE_AUTO kMitsubishiAcVaneAuto
+#define MITSUBISHI_AC_POWER kMitsubishiAcPower
+#define MITSUBISHI_AC_MIN_TEMP kMitsubishiAcMinTemp
+#define MITSUBISHI_AC_MAX_TEMP kMitsubishiAcMaxTemp
+#define MITSUBISHI_AC_HEAT kMitsubishiAcHeat
+#define MITSUBISHI_AC_FAN_SILENT kMitsubishiAcFanSilent
+#define MITSUBISHI_AC_FAN_REAL_MAX kMitsubishiAcFanRealMax
+#define MITSUBISHI_AC_FAN_MAX kMitsubishiAcFanMax
+#define MITSUBISHI_AC_FAN_AUTO kMitsubishiAcFanAuto
+#define MITSUBISHI_AC_DRY kMitsubishiAcDry
+#define MITSUBISHI_AC_COOL kMitsubishiAcCool
+#define MITSUBISHI_AC_AUTO kMitsubishiAcAuto
+
+class IRMitsubishiAC {
+ public:
+ explicit IRMitsubishiAC(uint16_t pin);
+
+ static uint8_t calculateChecksum(uint8_t* data);
+
+ void stateReset();
+#if SEND_MITSUBISHI_AC
+ void send();
+#endif // SEND_MITSUBISHI_AC
+ void begin();
+ void on();
+ void off();
+ void setPower(bool state);
+ bool getPower();
+ void setTemp(uint8_t temp);
+ uint8_t getTemp();
+ void setFan(uint8_t fan);
+ uint8_t getFan();
+ void setMode(uint8_t mode);
+ uint8_t getMode();
+ void setVane(uint8_t mode);
+ uint8_t getVane();
+ uint8_t* getRaw();
+ void setRaw(uint8_t* data);
+ uint8_t getClock();
+ void setClock(uint8_t clock);
+ uint8_t getStartClock();
+ void setStartClock(uint8_t clock);
+ uint8_t getStopClock();
+ void setStopClock(uint8_t clock);
+ uint8_t getTimer();
+ void setTimer(uint8_t timer);
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
+
+ private:
+#ifdef ARDUINO
+ String timeToString(uint64_t time);
+#else
+ std::string timeToString(uint64_t time);
+#endif
+ uint8_t remote_state[kMitsubishiACStateLength];
+ void checksum();
+ IRsend _irsend;
+};
+
+#endif // IR_MITSUBISHI_H_
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_NEC.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_NEC.cpp
similarity index 53%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_NEC.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_NEC.cpp
index a5febe1b8656..660b5110957a 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_NEC.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_NEC.cpp
@@ -2,11 +2,11 @@
// Copyright 2017 David Conran
#define __STDC_LIMIT_MACROS
+#include "ir_NEC.h"
#include
#include
#include "IRrecv.h"
#include "IRsend.h"
-#include "IRtimer.h"
#include "IRutils.h"
// N N EEEEE CCCC
@@ -17,39 +17,13 @@
// NEC originally added from https://github.com/shirriff/Arduino-IRremote/
-// Constants
-// Ref:
-// http://www.sbprojects.com/knowledge/ir/nec.php
-#define NEC_TICK 560U
-#define NEC_HDR_MARK_TICKS 16U
-#define NEC_HDR_MARK (NEC_HDR_MARK_TICKS * NEC_TICK)
-#define NEC_HDR_SPACE_TICKS 8U
-#define NEC_HDR_SPACE (NEC_HDR_SPACE_TICKS * NEC_TICK)
-#define NEC_BIT_MARK_TICKS 1U
-#define NEC_BIT_MARK (NEC_BIT_MARK_TICKS * NEC_TICK)
-#define NEC_ONE_SPACE_TICKS 3U
-#define NEC_ONE_SPACE (NEC_TICK * NEC_ONE_SPACE_TICKS)
-#define NEC_ZERO_SPACE_TICKS 1U
-#define NEC_ZERO_SPACE (NEC_TICK * NEC_ZERO_SPACE_TICKS)
-#define NEC_RPT_SPACE_TICKS 4U
-#define NEC_RPT_SPACE (NEC_RPT_SPACE_TICKS * NEC_TICK)
-#define NEC_RPT_LENGTH 4U
-#define NEC_MIN_COMMAND_LENGTH_TICKS 193U
-#define NEC_MIN_COMMAND_LENGTH (NEC_MIN_COMMAND_LENGTH_TICKS * NEC_TICK)
-#define NEC_MIN_GAP (NEC_MIN_COMMAND_LENGTH - \
- (NEC_HDR_MARK + NEC_HDR_SPACE + NEC_BITS * (NEC_BIT_MARK + NEC_ONE_SPACE) \
- + NEC_BIT_MARK))
-#define NEC_MIN_GAP_TICKS (NEC_MIN_COMMAND_LENGTH_TICKS - \
- (NEC_HDR_MARK_TICKS + NEC_HDR_SPACE_TICKS + \
- NEC_BITS * (NEC_BIT_MARK_TICKS + NEC_ONE_SPACE_TICKS) + \
- NEC_BIT_MARK_TICKS))
-
-#if (SEND_NEC || SEND_SHERWOOD || SEND_AIWA_RC_T501 || SEND_SANYO)
+#if (SEND_NEC || SEND_SHERWOOD || SEND_AIWA_RC_T501 || SEND_SANYO || \
+ SEND_PIONEER)
// Send a raw NEC(Renesas) formatted message.
//
// Args:
// data: The message to be sent.
-// nbits: The number of bits of the message to be sent. Typically NEC_BITS.
+// nbits: The number of bits of the message to be sent. Typically kNECBits.
// repeat: The number of times the command is to be repeated.
//
// Status: STABLE / Known working.
@@ -57,29 +31,17 @@
// Ref:
// http://www.sbprojects.com/knowledge/ir/nec.php
void IRsend::sendNEC(uint64_t data, uint16_t nbits, uint16_t repeat) {
- // Set 38kHz IR carrier frequency & a 1/3 (33%) duty cycle.
- enableIROut(38, 33);
- IRtimer usecs = IRtimer();
- // Header
- mark(NEC_HDR_MARK);
- space(NEC_HDR_SPACE);
- // Data
- sendData(NEC_BIT_MARK, NEC_ONE_SPACE, NEC_BIT_MARK, NEC_ZERO_SPACE,
- data, nbits, true);
- // Footer
- mark(NEC_BIT_MARK);
- // Gap to next command.
- space(std::max(NEC_MIN_GAP, NEC_MIN_COMMAND_LENGTH - usecs.elapsed()));
-
+ sendGeneric(kNecHdrMark, kNecHdrSpace, kNecBitMark, kNecOneSpace, kNecBitMark,
+ kNecZeroSpace, kNecBitMark, kNecMinGap, kNecMinCommandLength,
+ data, nbits, 38, true, 0, // Repeats are handled later.
+ 33);
// Optional command repeat sequence.
- for (uint16_t i = 0; i < repeat; i++) {
- usecs.reset();
- mark(NEC_HDR_MARK);
- space(NEC_RPT_SPACE);
- mark(NEC_BIT_MARK);
- // Gap till next command.
- space(std::max(NEC_MIN_GAP, NEC_MIN_COMMAND_LENGTH - usecs.elapsed()));
- }
+ if (repeat)
+ sendGeneric(kNecHdrMark, kNecRptSpace, 0, 0, 0, 0, // No actual data sent.
+ kNecBitMark, kNecMinGap, kNecMinCommandLength, 0,
+ 0, // No data to be sent.
+ 38, true, repeat - 1, // We've already sent a one message.
+ 33);
}
// Calculate the raw NEC data based on address and command.
@@ -97,8 +59,8 @@ uint32_t IRsend::encodeNEC(uint16_t address, uint16_t command) {
command &= 0xFF; // We only want the least significant byte of command.
// sendNEC() sends MSB first, but protocol says this is LSB first.
command = reverseBits(command, 8);
- command = (command << 8) + (command ^ 0xFF); // Calculate the new command.
- if (address > 0xFF) { // Is it Extended NEC?
+ command = (command << 8) + (command ^ 0xFF); // Calculate the new command.
+ if (address > 0xFF) { // Is it Extended NEC?
address = reverseBits(address, 16);
return ((address << 16) + command); // Extended.
} else {
@@ -113,7 +75,7 @@ uint32_t IRsend::encodeNEC(uint16_t address, uint16_t command) {
//
// Args:
// results: Ptr to the data to decode and where to store the decode result.
-// nbits: The number of data bits to expect. Typically NEC_BITS.
+// nbits: The number of data bits to expect. Typically kNECBits.
// strict: Flag indicating if we should perform strict matching.
// Returns:
// boolean: True if it can decode it, false if it can't.
@@ -122,34 +84,33 @@ uint32_t IRsend::encodeNEC(uint16_t address, uint16_t command) {
//
// Notes:
// NEC protocol has three varients/forms.
-// Normal: a 8 bit address & a 8 bit command in 32 bit data form.
+// Normal: an 8 bit address & an 8 bit command in 32 bit data form.
// i.e. address + inverted(address) + command + inverted(command)
-// Extended: a 16 bit address & a 8 bit command in 32 bit data form.
+// Extended: a 16 bit address & an 8 bit command in 32 bit data form.
// i.e. address + command + inverted(command)
// Repeat: a 0-bit code. i.e. No data bits. Just the header + footer.
//
// Ref:
// http://www.sbprojects.com/knowledge/ir/nec.php
bool IRrecv::decodeNEC(decode_results *results, uint16_t nbits, bool strict) {
- if (results->rawlen < 2 * nbits + HEADER + FOOTER - 1 &&
- results->rawlen != NEC_RPT_LENGTH)
+ if (results->rawlen < 2 * nbits + kHeader + kFooter - 1 &&
+ results->rawlen != kNecRptLength)
return false; // Can't possibly be a valid NEC message.
- if (strict && nbits != NEC_BITS)
+ if (strict && nbits != kNECBits)
return false; // Not strictly an NEC message.
uint64_t data = 0;
- uint16_t offset = OFFSET_START;
+ uint16_t offset = kStartOffset;
// Header
- if (!matchMark(results->rawbuf[offset], NEC_HDR_MARK)) return false;
+ if (!matchMark(results->rawbuf[offset], kNecHdrMark)) return false;
// Calculate how long the lowest tick time is based on the header mark.
- uint32_t mark_tick = results->rawbuf[offset++] * RAWTICK /
- NEC_HDR_MARK_TICKS;
+ uint32_t mark_tick = results->rawbuf[offset++] * kRawTick / kNecHdrMarkTicks;
// Check if it is a repeat code.
- if (results->rawlen == NEC_RPT_LENGTH &&
- matchSpace(results->rawbuf[offset], NEC_RPT_SPACE) &&
- matchMark(results->rawbuf[offset + 1], NEC_BIT_MARK_TICKS * mark_tick)) {
- results->value = REPEAT;
+ if (results->rawlen == kNecRptLength &&
+ matchSpace(results->rawbuf[offset], kNecRptSpace) &&
+ matchMark(results->rawbuf[offset + 1], kNecBitMarkTicks * mark_tick)) {
+ results->value = kRepeat;
results->decode_type = NEC;
results->bits = 0;
results->address = 0;
@@ -159,34 +120,32 @@ bool IRrecv::decodeNEC(decode_results *results, uint16_t nbits, bool strict) {
}
// Header (cont.)
- if (!matchSpace(results->rawbuf[offset], NEC_HDR_SPACE)) return false;
+ if (!matchSpace(results->rawbuf[offset], kNecHdrSpace)) return false;
// Calculate how long the common tick time is based on the header space.
- uint32_t space_tick = results->rawbuf[offset++] * RAWTICK /
- NEC_HDR_SPACE_TICKS;
+ uint32_t space_tick =
+ results->rawbuf[offset++] * kRawTick / kNecHdrSpaceTicks;
// Data
- match_result_t data_result = matchData(&(results->rawbuf[offset]), nbits,
- NEC_BIT_MARK_TICKS * mark_tick,
- NEC_ONE_SPACE_TICKS * space_tick,
- NEC_BIT_MARK_TICKS * mark_tick,
- NEC_ZERO_SPACE_TICKS * space_tick);
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), nbits, kNecBitMarkTicks * mark_tick,
+ kNecOneSpaceTicks * space_tick, kNecBitMarkTicks * mark_tick,
+ kNecZeroSpaceTicks * space_tick);
if (data_result.success == false) return false;
data = data_result.data;
offset += data_result.used;
// Footer
- if (!matchMark(results->rawbuf[offset++], NEC_BIT_MARK_TICKS * mark_tick))
- return false;
- if (offset <= results->rawlen &&
- !matchAtLeast(results->rawbuf[offset], NEC_MIN_GAP_TICKS * space_tick))
+ if (!matchMark(results->rawbuf[offset++], kNecBitMarkTicks * mark_tick))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kNecMinGapTicks * space_tick))
return false;
// Compliance
// Calculate command and optionally enforce integrity checking.
- uint8_t command = (data & 0xFF00) >> 8;
+ uint8_t command = (data & 0xFF00) >> 8;
// Command is sent twice, once as plain and then inverted.
if ((command ^ 0xFF) != (data & 0xFF)) {
- if (strict)
- return false; // Command integrity failed.
+ if (strict) return false; // Command integrity failed.
command = 0; // The command value isn't valid, so default to zero.
}
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_NEC.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_NEC.h
new file mode 100644
index 000000000000..c274c104ef65
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_NEC.h
@@ -0,0 +1,46 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2017, 2018 David Conran
+
+#ifndef IR_NEC_H_
+#define IR_NEC_H_
+
+#include
+#include "IRremoteESP8266.h"
+
+// N N EEEEE CCCC
+// NN N E C
+// N N N EEE C
+// N NN E C
+// N N EEEEE CCCC
+
+// NEC originally added from https://github.com/shirriff/Arduino-IRremote/
+
+// Constants
+// Ref:
+// http://www.sbprojects.com/knowledge/ir/nec.php
+const uint16_t kNecTick = 560;
+const uint16_t kNecHdrMarkTicks = 16;
+const uint16_t kNecHdrMark = kNecHdrMarkTicks * kNecTick;
+const uint16_t kNecHdrSpaceTicks = 8;
+const uint16_t kNecHdrSpace = kNecHdrSpaceTicks * kNecTick;
+const uint16_t kNecBitMarkTicks = 1;
+const uint16_t kNecBitMark = kNecBitMarkTicks * kNecTick;
+const uint16_t kNecOneSpaceTicks = 3;
+const uint16_t kNecOneSpace = kNecOneSpaceTicks * kNecTick;
+const uint16_t kNecZeroSpaceTicks = 1;
+const uint16_t kNecZeroSpace = kNecZeroSpaceTicks * kNecTick;
+const uint16_t kNecRptSpaceTicks = 4;
+const uint16_t kNecRptSpace = kNecRptSpaceTicks * kNecTick;
+const uint16_t kNecRptLength = 4;
+const uint16_t kNecMinCommandLengthTicks = 193;
+const uint32_t kNecMinCommandLength = kNecMinCommandLengthTicks * kNecTick;
+const uint32_t kNecMinGap =
+ kNecMinCommandLength -
+ (kNecHdrMark + kNecHdrSpace + kNECBits * (kNecBitMark + kNecOneSpace) +
+ kNecBitMark);
+const uint16_t kNecMinGapTicks =
+ kNecMinCommandLengthTicks -
+ (kNecHdrMarkTicks + kNecHdrSpaceTicks +
+ kNECBits * (kNecBitMarkTicks + kNecOneSpaceTicks) + kNecBitMarkTicks);
+
+#endif // IR_NEC_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Nikai.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Nikai.cpp
new file mode 100644
index 000000000000..9ac22a849912
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Nikai.cpp
@@ -0,0 +1,104 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2017 David Conran
+
+#include
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// NN NN IIIII KK KK AAA IIIII
+// NNN NN III KK KK AAAAA III
+// NN N NN III KKKK AA AA III
+// NN NNN III KK KK AAAAAAA III
+// NN NN IIIII KK KK AA AA IIIII
+
+// Constants
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/309
+const uint16_t kNikaiTick = 500;
+const uint16_t kNikaiHdrMarkTicks = 8;
+const uint16_t kNikaiHdrMark = kNikaiHdrMarkTicks * kNikaiTick;
+const uint16_t kNikaiHdrSpaceTicks = 8;
+const uint16_t kNikaiHdrSpace = kNikaiHdrSpaceTicks * kNikaiTick;
+const uint16_t kNikaiBitMarkTicks = 1;
+const uint16_t kNikaiBitMark = kNikaiBitMarkTicks * kNikaiTick;
+const uint16_t kNikaiOneSpaceTicks = 2;
+const uint16_t kNikaiOneSpace = kNikaiOneSpaceTicks * kNikaiTick;
+const uint16_t kNikaiZeroSpaceTicks = 4;
+const uint16_t kNikaiZeroSpace = kNikaiZeroSpaceTicks * kNikaiTick;
+const uint16_t kNikaiMinGapTicks = 17;
+const uint16_t kNikaiMinGap = kNikaiMinGapTicks * kNikaiTick;
+
+#if SEND_NIKAI
+// Send a Nikai TV formatted message.
+//
+// Args:
+// data: The message to be sent.
+// nbits: The bit size of the message being sent. typically kNikaiBits.
+// repeat: The number of times the message is to be repeated.
+//
+// Status: STABLE / Working.
+//
+// Ref: https://github.com/markszabo/IRremoteESP8266/issues/309
+void IRsend::sendNikai(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ sendGeneric(kNikaiHdrMark, kNikaiHdrSpace, kNikaiBitMark, kNikaiOneSpace,
+ kNikaiBitMark, kNikaiZeroSpace, kNikaiBitMark, kNikaiMinGap, data,
+ nbits, 38, true, repeat, 33);
+}
+#endif
+
+#if DECODE_NIKAI
+// Decode the supplied Nikai message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of bits to expect in the data portion.
+// Typically kNikaiBits.
+// strict: Flag to indicate if we strictly adhere to the specification.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: STABLE / Working.
+//
+bool IRrecv::decodeNikai(decode_results *results, uint16_t nbits, bool strict) {
+ if (results->rawlen < 2 * nbits + kHeader + kFooter - 1)
+ return false; // Can't possibly be a valid Nikai message.
+ if (strict && nbits != kNikaiBits)
+ return false; // We expect Nikai to be a certain sized message.
+
+ uint64_t data = 0;
+ uint16_t offset = kStartOffset;
+
+ // Header
+ if (!matchMark(results->rawbuf[offset], kNikaiHdrMark)) return false;
+ // Calculate how long the common tick time is based on the header mark.
+ uint32_t m_tick = results->rawbuf[offset++] * kRawTick / kNikaiHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kNikaiHdrSpace)) return false;
+ // Calculate how long the common tick time is based on the header space.
+ uint32_t s_tick = results->rawbuf[offset++] * kRawTick / kNikaiHdrSpaceTicks;
+ // Data
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), nbits, kNikaiBitMarkTicks * m_tick,
+ kNikaiOneSpaceTicks * s_tick, kNikaiBitMarkTicks * m_tick,
+ kNikaiZeroSpaceTicks * s_tick);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kNikaiBitMarkTicks * m_tick))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kNikaiMinGapTicks * s_tick))
+ return false;
+
+ // Compliance
+
+ // Success
+ results->bits = nbits;
+ results->value = data;
+ results->decode_type = NIKAI;
+ results->command = 0;
+ results->address = 0;
+ return true;
+}
+#endif
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Panasonic.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Panasonic.cpp
new file mode 100644
index 000000000000..e79b136a5430
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Panasonic.cpp
@@ -0,0 +1,863 @@
+// Copyright 2015 Kristian Lauszus
+// Copyright 2017, 2018 David Conran
+
+#include "ir_Panasonic.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// PPPP AAA N N AAA SSSS OOO N N IIIII CCCC
+// P P A A NN N A A S O O NN N I C
+// PPPP AAAAA N N N AAAAA SSS O O N N N I C
+// P A A N NN A A S O O N NN I C
+// P A A N N A A SSSS OOO N N IIIII CCCC
+
+// Panasonic protocol originally added by Kristian Lauszus from:
+// https://github.com/z3t0/Arduino-IRremote
+// (Thanks to zenwheel and other people at the original blog post)
+//
+// Panasonic A/C support add by crankyoldgit but heavily influenced by:
+// https://github.com/ToniA/ESPEasy/blob/HeatpumpIR/lib/HeatpumpIR/PanasonicHeatpumpIR.cpp
+// Panasonic A/C Clock & Timer support:
+// Reverse Engineering by MikkelTb
+// Code by crankyoldgit
+// Panasonic A/C models supported:
+// A/C Series/models:
+// JKE, LKE, DKE, CKP, & NKE series. (In theory)
+// CS-YW9MKD (confirmed)
+// CS-ME14CKPG / CS-ME12CKPG / CS-ME10CKPG
+// A/C Remotes:
+// A75C3747 (confirmed)
+// A75C3704
+// A75C2311 (CKP)
+
+// Constants
+// Ref:
+// http://www.remotecentral.com/cgi-bin/mboard/rc-pronto/thread.cgi?26152
+
+const uint16_t kPanasonicTick = 432;
+const uint16_t kPanasonicHdrMarkTicks = 8;
+const uint16_t kPanasonicHdrMark = kPanasonicHdrMarkTicks * kPanasonicTick;
+const uint16_t kPanasonicHdrSpaceTicks = 4;
+const uint16_t kPanasonicHdrSpace = kPanasonicHdrSpaceTicks * kPanasonicTick;
+const uint16_t kPanasonicBitMarkTicks = 1;
+const uint16_t kPanasonicBitMark = kPanasonicBitMarkTicks * kPanasonicTick;
+const uint16_t kPanasonicOneSpaceTicks = 3;
+const uint16_t kPanasonicOneSpace = kPanasonicOneSpaceTicks * kPanasonicTick;
+const uint16_t kPanasonicZeroSpaceTicks = 1;
+const uint16_t kPanasonicZeroSpace = kPanasonicZeroSpaceTicks * kPanasonicTick;
+const uint16_t kPanasonicMinCommandLengthTicks = 378;
+const uint32_t kPanasonicMinCommandLength =
+ kPanasonicMinCommandLengthTicks * kPanasonicTick;
+const uint16_t kPanasonicEndGap = 5000; // See issue #245
+const uint16_t kPanasonicMinGapTicks =
+ kPanasonicMinCommandLengthTicks -
+ (kPanasonicHdrMarkTicks + kPanasonicHdrSpaceTicks +
+ kPanasonicBits * (kPanasonicBitMarkTicks + kPanasonicOneSpaceTicks) +
+ kPanasonicBitMarkTicks);
+const uint32_t kPanasonicMinGap = kPanasonicMinGapTicks * kPanasonicTick;
+
+const uint16_t kPanasonicAcSectionGap = 10000;
+const uint16_t kPanasonicAcSection1Length = 8;
+const uint32_t kPanasonicAcMessageGap = 100000; // A complete guess.
+
+#if (SEND_PANASONIC || SEND_DENON)
+// Send a Panasonic formatted message.
+//
+// Args:
+// data: The message to be sent.
+// nbits: The number of bits of the message to be sent. (kPanasonicBits).
+// repeat: The number of times the command is to be repeated.
+//
+// Status: BETA / Should be working.
+//
+// Note:
+// This protocol is a modified version of Kaseikyo.
+void IRsend::sendPanasonic64(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ sendGeneric(kPanasonicHdrMark, kPanasonicHdrSpace, kPanasonicBitMark,
+ kPanasonicOneSpace, kPanasonicBitMark, kPanasonicZeroSpace,
+ kPanasonicBitMark, kPanasonicMinGap, kPanasonicMinCommandLength,
+ data, nbits, kPanasonicFreq, true, repeat, 50);
+}
+
+// Send a Panasonic formatted message.
+//
+// Args:
+// address: The manufacturer code.
+// data: The data portion to be sent.
+// nbits: The number of bits of the message to be sent. (kPanasonicBits).
+// repeat: The number of times the command is to be repeated.
+//
+// Status: STABLE.
+//
+// Note:
+// This protocol is a modified version of Kaseikyo.
+void IRsend::sendPanasonic(uint16_t address, uint32_t data, uint16_t nbits,
+ uint16_t repeat) {
+ sendPanasonic64(((uint64_t)address << 32) | (uint64_t)data, nbits, repeat);
+}
+
+// Calculate the raw Panasonic data based on device, subdevice, & function.
+//
+// Args:
+// manufacturer: A 16-bit manufacturer code. e.g. 0x4004 is Panasonic.
+// device: An 8-bit code.
+// subdevice: An 8-bit code.
+// function: An 8-bit code.
+// Returns:
+// A raw uint64_t Panasonic message.
+//
+// Status: BETA / Should be working..
+//
+// Note:
+// Panasonic 48-bit protocol is a modified version of Kaseikyo.
+// Ref:
+// http://www.remotecentral.com/cgi-bin/mboard/rc-pronto/thread.cgi?2615
+uint64_t IRsend::encodePanasonic(uint16_t manufacturer, uint8_t device,
+ uint8_t subdevice, uint8_t function) {
+ uint8_t checksum = device ^ subdevice ^ function;
+ return (((uint64_t)manufacturer << 32) | ((uint64_t)device << 24) |
+ ((uint64_t)subdevice << 16) | ((uint64_t)function << 8) | checksum);
+}
+#endif // (SEND_PANASONIC || SEND_DENON)
+
+#if (DECODE_PANASONIC || DECODE_DENON)
+// Decode the supplied Panasonic message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of data bits to expect.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Should be working.
+// Note:
+// Panasonic 48-bit protocol is a modified version of Kaseikyo.
+// Ref:
+// http://www.remotecentral.com/cgi-bin/mboard/rc-pronto/thread.cgi?26152
+// http://www.hifi-remote.com/wiki/index.php?title=Panasonic
+bool IRrecv::decodePanasonic(decode_results *results, uint16_t nbits,
+ bool strict, uint32_t manufacturer) {
+ if (results->rawlen < 2 * nbits + kHeader + kFooter - 1)
+ return false; // Not enough entries to be a Panasonic message.
+ if (strict && nbits != kPanasonicBits)
+ return false; // Request is out of spec.
+
+ uint64_t data = 0;
+ uint16_t offset = kStartOffset;
+
+ // Header
+ if (!matchMark(results->rawbuf[offset], kPanasonicHdrMark)) return false;
+ // Calculate how long the common tick time is based on the header mark.
+ uint32_t m_tick =
+ results->rawbuf[offset++] * kRawTick / kPanasonicHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kPanasonicHdrSpace)) return false;
+ // Calculate how long the common tick time is based on the header space.
+ uint32_t s_tick =
+ results->rawbuf[offset++] * kRawTick / kPanasonicHdrSpaceTicks;
+
+ // Data
+ match_result_t data_result = matchData(
+ &(results->rawbuf[offset]), nbits, kPanasonicBitMarkTicks * m_tick,
+ kPanasonicOneSpaceTicks * s_tick, kPanasonicBitMarkTicks * m_tick,
+ kPanasonicZeroSpaceTicks * s_tick);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+
+ // Footer
+ if (!match(results->rawbuf[offset++], kPanasonicBitMarkTicks * m_tick))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kPanasonicEndGap))
+ return false;
+
+ // Compliance
+ uint32_t address = data >> 32;
+ uint32_t command = data & 0xFFFFFFFF;
+ if (strict) {
+ if (address != manufacturer) // Verify the Manufacturer code.
+ return false;
+ // Verify the checksum.
+ uint8_t checksumOrig = data & 0xFF;
+ uint8_t checksumCalc = ((data >> 24) ^ (data >> 16) ^ (data >> 8)) & 0xFF;
+ if (checksumOrig != checksumCalc) return false;
+ }
+
+ // Success
+ results->value = data;
+ results->address = address;
+ results->command = command;
+ results->decode_type = PANASONIC;
+ results->bits = nbits;
+ return true;
+}
+#endif // (DECODE_PANASONIC || DECODE_DENON)
+
+#if SEND_PANASONIC_AC
+// Send a Panasonic A/C message.
+//
+// Args:
+// data: Contents of the message to be sent. (Guessing MSBF order)
+// nbits: Nr. of bits of data to be sent. Typically kPanasonicAcBits.
+// repeat: Nr. of additional times the message is to be sent.
+//
+// Status: Beta / Appears to work with real device(s).
+//:
+// Panasonic A/C models supported:
+// A/C Series/models:
+// JKE, LKE, DKE, & NKE series.
+// CS-YW9MKD
+// A/C Remotes:
+// A75C3747
+// A75C3704
+//
+void IRsend::sendPanasonicAC(uint8_t data[], uint16_t nbytes, uint16_t repeat) {
+ if (nbytes < kPanasonicAcSection1Length) return;
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // First section. (8 bytes)
+ sendGeneric(kPanasonicHdrMark, kPanasonicHdrSpace, kPanasonicBitMark,
+ kPanasonicOneSpace, kPanasonicBitMark, kPanasonicZeroSpace,
+ kPanasonicBitMark, kPanasonicAcSectionGap, data,
+ kPanasonicAcSection1Length, kPanasonicFreq, false, 0, 50);
+ // First section. (The rest of the data bytes)
+ sendGeneric(kPanasonicHdrMark, kPanasonicHdrSpace, kPanasonicBitMark,
+ kPanasonicOneSpace, kPanasonicBitMark, kPanasonicZeroSpace,
+ kPanasonicBitMark, kPanasonicAcMessageGap,
+ data + kPanasonicAcSection1Length,
+ nbytes - kPanasonicAcSection1Length, kPanasonicFreq, false, 0,
+ 50);
+ }
+}
+#endif // SEND_PANASONIC_AC
+
+IRPanasonicAc::IRPanasonicAc(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRPanasonicAc::stateReset() {
+ for (uint8_t i = 0; i < kPanasonicAcStateLength; i++)
+ remote_state[i] = kPanasonicKnownGoodState[i];
+ _temp = 25; // An initial saved desired temp. Completely made up.
+ _swingh = kPanasonicAcSwingHMiddle; // A similar made up value for H Swing.
+}
+
+void IRPanasonicAc::begin() { _irsend.begin(); }
+
+// Verify the checksum is valid for a given state.
+// Args:
+// state: The array to verify the checksum of.
+// length: The size of the state.
+// Returns:
+// A boolean.
+bool IRPanasonicAc::validChecksum(uint8_t state[], const uint16_t length) {
+ if (length < 2) return false; // 1 byte of data can't have a checksum.
+ return (state[length - 1] ==
+ sumBytes(state, length - 1, kPanasonicAcChecksumInit));
+}
+
+uint8_t IRPanasonicAc::calcChecksum(uint8_t state[], const uint16_t length) {
+ return sumBytes(state, length - 1, kPanasonicAcChecksumInit);
+}
+
+void IRPanasonicAc::fixChecksum(const uint16_t length) {
+ remote_state[length - 1] = calcChecksum(remote_state, length);
+}
+
+#if SEND_PANASONIC_AC
+void IRPanasonicAc::send() {
+ fixChecksum();
+ _irsend.sendPanasonicAC(remote_state);
+}
+#endif // SEND_PANASONIC_AC
+
+void IRPanasonicAc::setModel(const panasonic_ac_remote_model_t model) {
+ switch (model) {
+ case kPanasonicDke:
+ case kPanasonicJke:
+ case kPanasonicLke:
+ case kPanasonicNke:
+ case kPanasonicCkp:
+ break;
+ default: // Only proceed if we know what to do.
+ return;
+ }
+ // clear & set the various bits and bytes.
+ remote_state[13] &= 0xF0;
+ remote_state[17] = 0x00;
+ remote_state[21] &= 0b11101111;
+ remote_state[23] = 0x81;
+ remote_state[25] = 0x00;
+
+ switch (model) {
+ case kPanasonicLke:
+ remote_state[13] |= 0x02;
+ remote_state[17] = 0x06;
+ break;
+ case kPanasonicDke:
+ remote_state[23] = 0x01;
+ remote_state[25] = 0x06;
+ // Has to be done last as setSwingHorizontal has model check built-in
+ setSwingHorizontal(_swingh);
+ break;
+ case kPanasonicNke:
+ remote_state[17] = 0x06;
+ break;
+ case kPanasonicJke:
+ break;
+ case kPanasonicCkp:
+ remote_state[21] |= 0x10;
+ remote_state[23] = 0x01;
+ default:
+ break;
+ }
+}
+
+panasonic_ac_remote_model_t IRPanasonicAc::getModel() {
+ if (remote_state[17] == 0x00) {
+ if ((remote_state[21] & 0x10) && (remote_state[23] & 0x01))
+ return kPanasonicCkp;
+ if (remote_state[23] & 0x80) return kPanasonicJke;
+ }
+ if (remote_state[17] == 0x06 && (remote_state[13] & 0x0F) == 0x02)
+ return kPanasonicLke;
+ if (remote_state[23] == 0x01) return kPanasonicDke;
+ if (remote_state[17] == 0x06) return kPanasonicNke;
+ return kPanasonicUnknown;
+}
+
+uint8_t *IRPanasonicAc::getRaw() {
+ fixChecksum();
+ return remote_state;
+}
+
+void IRPanasonicAc::setRaw(const uint8_t state[]) {
+ for (uint8_t i = 0; i < kPanasonicAcStateLength; i++) {
+ remote_state[i] = state[i];
+ }
+}
+
+// Control the power state of the A/C unit.
+//
+// For CKP models, the remote has no memory of the power state the A/C unit
+// should be in. For those models setting this on/true will toggle the power
+// state of the Panasonic A/C unit with the next meessage.
+// e.g. If the A/C unit is already on, setPower(true) will turn it off.
+// If the A/C unit is already off, setPower(true) will turn it on.
+// setPower(false) will leave the A/C power state as it was.
+//
+// For all other models, setPower(true) should set the internal state to
+// turn it on, and setPower(false) should turn it off.
+void IRPanasonicAc::setPower(const bool state) {
+ if (state)
+ on();
+ else
+ off();
+}
+
+// Return the A/C power state of the remote.
+// Except for CKP models, where it returns if the power state will be toggled
+// on the A/C unit when the next message is sent.
+bool IRPanasonicAc::getPower() {
+ return (remote_state[13] & kPanasonicAcPower) == kPanasonicAcPower;
+}
+
+void IRPanasonicAc::on() { remote_state[13] |= kPanasonicAcPower; }
+
+void IRPanasonicAc::off() { remote_state[13] &= ~kPanasonicAcPower; }
+
+uint8_t IRPanasonicAc::getMode() { return remote_state[13] >> 4; }
+
+void IRPanasonicAc::setMode(const uint8_t desired) {
+ uint8_t mode = kPanasonicAcAuto; // Default to Auto mode.
+ switch (desired) {
+ case kPanasonicAcFan:
+ // Allegedly Fan mode has a temperature of 27.
+ setTemp(kPanasonicAcFanModeTemp, false);
+ mode = desired;
+ break;
+ case kPanasonicAcAuto:
+ case kPanasonicAcCool:
+ case kPanasonicAcHeat:
+ case kPanasonicAcDry:
+ mode = desired;
+ // Set the temp to the saved temp, just incase our previous mode was Fan.
+ setTemp(_temp);
+ break;
+ }
+ remote_state[13] &= 0x0F; // Clear the previous mode bits.
+ remote_state[13] |= mode << 4;
+}
+
+uint8_t IRPanasonicAc::getTemp() { return remote_state[14] >> 1; }
+
+// Set the desitred temperature in Celcius.
+// Args:
+// celsius: The temperature to set the A/C unit to.
+// remember: A boolean flag for the class to remember the temperature.
+//
+// Automatically safely limits the temp to the operating range supported.
+void IRPanasonicAc::setTemp(const uint8_t celsius, const bool remember) {
+ uint8_t temperature;
+ temperature = std::max(celsius, kPanasonicAcMinTemp);
+ temperature = std::min(temperature, kPanasonicAcMaxTemp);
+ remote_state[14] = temperature << 1;
+ if (remember) _temp = temperature;
+}
+
+uint8_t IRPanasonicAc::getSwingVertical() { return remote_state[16] & 0x0F; }
+
+void IRPanasonicAc::setSwingVertical(const uint8_t desired_elevation) {
+ uint8_t elevation = desired_elevation;
+ if (elevation != kPanasonicAcSwingVAuto) {
+ elevation = std::max(elevation, kPanasonicAcSwingVUp);
+ elevation = std::min(elevation, kPanasonicAcSwingVDown);
+ }
+ remote_state[16] &= 0xF0;
+ remote_state[16] |= elevation;
+}
+
+uint8_t IRPanasonicAc::getSwingHorizontal() { return remote_state[17]; }
+
+void IRPanasonicAc::setSwingHorizontal(const uint8_t desired_direction) {
+ switch (desired_direction) {
+ case kPanasonicAcSwingHAuto:
+ case kPanasonicAcSwingHMiddle:
+ case kPanasonicAcSwingHFullLeft:
+ case kPanasonicAcSwingHLeft:
+ case kPanasonicAcSwingHRight:
+ case kPanasonicAcSwingHFullRight:
+ break;
+ default: // Ignore anything that isn't valid.
+ return;
+ }
+ _swingh = desired_direction; // Store the direction for later.
+ uint8_t direction = desired_direction;
+ switch (getModel()) {
+ case kPanasonicDke:
+ break;
+ case kPanasonicNke:
+ case kPanasonicLke:
+ direction = kPanasonicAcSwingHMiddle;
+ break;
+ default: // Ignore everything else.
+ return;
+ }
+ remote_state[17] = direction;
+}
+
+void IRPanasonicAc::setFan(const uint8_t speed) {
+ if (speed <= kPanasonicAcFanMax || speed == kPanasonicAcFanAuto)
+ remote_state[16] =
+ (remote_state[16] & 0x0F) | ((speed + kPanasonicAcFanOffset) << 4);
+}
+
+uint8_t IRPanasonicAc::getFan() {
+ return (remote_state[16] >> 4) - kPanasonicAcFanOffset;
+}
+
+bool IRPanasonicAc::getQuiet() {
+ if (getModel() == kPanasonicCkp)
+ return remote_state[21] & kPanasonicAcQuietCkp;
+ else
+ return remote_state[21] & kPanasonicAcQuiet;
+}
+
+void IRPanasonicAc::setQuiet(const bool state) {
+ uint8_t quiet;
+ if (getModel() == kPanasonicCkp)
+ quiet = kPanasonicAcQuietCkp;
+ else
+ quiet = kPanasonicAcQuiet;
+
+ if (state) {
+ setPowerful(false); // Powerful is mutually exclusive.
+ remote_state[21] |= quiet;
+ } else {
+ remote_state[21] &= ~quiet;
+ }
+}
+
+bool IRPanasonicAc::getPowerful() {
+ if (getModel() == kPanasonicCkp)
+ return remote_state[21] & kPanasonicAcPowerfulCkp;
+ else
+ return remote_state[21] & kPanasonicAcPowerful;
+}
+
+void IRPanasonicAc::setPowerful(const bool state) {
+ uint8_t powerful;
+ if (getModel() == kPanasonicCkp)
+ powerful = kPanasonicAcPowerfulCkp;
+ else
+ powerful = kPanasonicAcPowerful;
+
+ if (state) {
+ setQuiet(false); // Quiet is mutually exclusive.
+ remote_state[21] |= powerful;
+ } else {
+ remote_state[21] &= ~powerful;
+ }
+}
+
+uint16_t IRPanasonicAc::encodeTime(const uint8_t hours, const uint8_t mins) {
+ return std::min(hours, (uint8_t)23) * 60 + std::min(mins, (uint8_t)59);
+}
+
+uint16_t IRPanasonicAc::getClock() {
+ uint16_t result = ((remote_state[25] & 0b00000111) << 8) + remote_state[24];
+ if (result == kPanasonicAcTimeSpecial) return 0;
+ return result;
+}
+
+void IRPanasonicAc::setClock(const uint16_t mins_since_midnight) {
+ uint16_t corrected = std::min(mins_since_midnight, kPanasonicAcTimeMax);
+ if (mins_since_midnight == kPanasonicAcTimeSpecial)
+ corrected = kPanasonicAcTimeSpecial;
+ remote_state[24] = corrected & 0xFF;
+ remote_state[25] &= 0b11111000;
+ remote_state[25] |= (corrected >> 8);
+}
+
+uint16_t IRPanasonicAc::getOnTimer() {
+ uint16_t result = ((remote_state[19] & 0b00000111) << 8) + remote_state[18];
+ if (result == kPanasonicAcTimeSpecial) return 0;
+ return result;
+}
+
+void IRPanasonicAc::setOnTimer(const uint16_t mins_since_midnight,
+ const bool enable) {
+ // Ensure it's on a 10 minute boundary and no overflow.
+ uint16_t corrected = std::min(mins_since_midnight, kPanasonicAcTimeMax);
+ corrected -= corrected % 10;
+ if (mins_since_midnight == kPanasonicAcTimeSpecial)
+ corrected = kPanasonicAcTimeSpecial;
+
+ if (enable)
+ remote_state[13] |= kPanasonicAcOnTimer; // Set the Ontimer flag.
+ else
+ remote_state[13] &= ~kPanasonicAcOnTimer; // Clear the Ontimer flag.
+ // Store the time.
+ remote_state[18] = corrected & 0xFF;
+ remote_state[19] &= 0b11111000;
+ remote_state[19] |= (corrected >> 8);
+}
+
+void IRPanasonicAc::cancelOnTimer() { setOnTimer(0, false); }
+
+bool IRPanasonicAc::isOnTimerEnabled() {
+ return remote_state[13] & kPanasonicAcOnTimer;
+}
+
+uint16_t IRPanasonicAc::getOffTimer() {
+ uint16_t result =
+ ((remote_state[20] & 0b01111111) << 4) + (remote_state[19] >> 4);
+ if (result == kPanasonicAcTimeSpecial) return 0;
+ return result;
+}
+
+void IRPanasonicAc::setOffTimer(const uint16_t mins_since_midnight,
+ const bool enable) {
+ // Ensure its on a 10 minute boundary and no overflow.
+ uint16_t corrected = std::min(mins_since_midnight, kPanasonicAcTimeMax);
+ corrected -= corrected % 10;
+ if (mins_since_midnight == kPanasonicAcTimeSpecial)
+ corrected = kPanasonicAcTimeSpecial;
+
+ if (enable)
+ remote_state[13] |= kPanasonicAcOffTimer; // Set the OffTimer flag.
+ else
+ remote_state[13] &= ~kPanasonicAcOffTimer; // Clear the OffTimer flag.
+ // Store the time.
+ remote_state[19] &= 0b00001111;
+ remote_state[19] |= (corrected & 0b00001111) << 4;
+ remote_state[20] &= 0b10000000;
+ remote_state[20] |= corrected >> 4;
+}
+
+void IRPanasonicAc::cancelOffTimer() { setOffTimer(0, false); }
+
+bool IRPanasonicAc::isOffTimerEnabled() {
+ return remote_state[13] & kPanasonicAcOffTimer;
+}
+
+#ifdef ARDUINO
+String IRPanasonicAc::timeToString(const uint16_t mins_since_midnight) {
+ String result = "";
+#else
+std::string IRPanasonicAc::timeToString(const uint16_t mins_since_midnight) {
+ std::string result = "";
+#endif // ARDUINO
+ result += uint64ToString(mins_since_midnight / 60) + ":";
+ uint8_t mins = mins_since_midnight % 60;
+ if (mins < 10) result += "0"; // Zero pad the minutes.
+ return result + uint64ToString(mins);
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRPanasonicAc::toString() {
+ String result = "";
+#else
+std::string IRPanasonicAc::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Model: " + uint64ToString(getModel());
+ switch (getModel()) {
+ case kPanasonicDke:
+ result += " (DKE)";
+ break;
+ case kPanasonicJke:
+ result += " (JKE)";
+ break;
+ case kPanasonicNke:
+ result += " (NKE)";
+ break;
+ case kPanasonicLke:
+ result += " (LKE)";
+ break;
+ case kPanasonicCkp:
+ result += " (CKP)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kPanasonicAcAuto:
+ result += " (AUTO)";
+ break;
+ case kPanasonicAcCool:
+ result += " (COOL)";
+ break;
+ case kPanasonicAcHeat:
+ result += " (HEAT)";
+ break;
+ case kPanasonicAcDry:
+ result += " (DRY)";
+ break;
+ case kPanasonicAcFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kPanasonicAcFanAuto:
+ result += " (AUTO)";
+ break;
+ case kPanasonicAcFanMax:
+ result += " (MAX)";
+ break;
+ case kPanasonicAcFanMin:
+ result += " (MIN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ break;
+ }
+ result += ", Swing (Vertical): " + uint64ToString(getSwingVertical());
+ switch (getSwingVertical()) {
+ case kPanasonicAcSwingVAuto:
+ result += " (AUTO)";
+ break;
+ case kPanasonicAcSwingVUp:
+ result += " (Full Up)";
+ break;
+ case kPanasonicAcSwingVDown:
+ result += " (Full Down)";
+ break;
+ case 2:
+ case 3:
+ case 4:
+ break;
+ default:
+ result += " (UNKNOWN)";
+ break;
+ }
+ switch (getModel()) {
+ case kPanasonicJke:
+ case kPanasonicCkp:
+ break; // No Horizontal Swing support.
+ default:
+ result += ", Swing (Horizontal): " + uint64ToString(getSwingHorizontal());
+ switch (getSwingHorizontal()) {
+ case kPanasonicAcSwingHAuto:
+ result += " (AUTO)";
+ break;
+ case kPanasonicAcSwingHFullLeft:
+ result += " (Full Left)";
+ break;
+ case kPanasonicAcSwingHLeft:
+ result += " (Left)";
+ break;
+ case kPanasonicAcSwingHMiddle:
+ result += " (Middle)";
+ break;
+ case kPanasonicAcSwingHFullRight:
+ result += " (Full Right)";
+ break;
+ case kPanasonicAcSwingHRight:
+ result += " (Right)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ break;
+ }
+ }
+ result += ", Quiet: ";
+ if (getQuiet())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Powerful: ";
+ if (getPowerful())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Clock: " + timeToString(getClock());
+ result += ", On Timer: ";
+ if (isOnTimerEnabled())
+ result += timeToString(getOnTimer());
+ else
+ result += "Off";
+ result += ", Off Timer: ";
+ if (isOffTimerEnabled())
+ result += timeToString(getOffTimer());
+ else
+ result += "Off";
+ return result;
+}
+
+#if DECODE_PANASONIC_AC
+// Decode the supplied Panasonic AC message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kPanasonicAcBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: Beta / Appears to work with real device(s).
+//
+// Panasonic A/C models supported:
+// A/C Series/models:
+// JKE, LKE, DKE, & NKE series.
+// CS-YW9MKD
+// A/C Remotes:
+// A75C3747 (Confirmed)
+// A75C3704
+bool IRrecv::decodePanasonicAC(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (nbits % 8 != 0) // nbits has to be a multiple of nr. of bits in a byte.
+ return false;
+
+ uint8_t min_nr_of_messages = 1;
+ if (strict) {
+ if (nbits != kPanasonicAcBits && nbits != kPanasonicAcShortBits)
+ return false; // Not strictly a PANASONIC_AC message.
+ }
+
+ if (results->rawlen <
+ min_nr_of_messages * (2 * nbits + kHeader + kFooter) - 1)
+ return false; // Can't possibly be a valid PANASONIC_AC message.
+
+ uint16_t dataBitsSoFar = 0;
+ uint16_t offset = kStartOffset;
+ match_result_t data_result;
+
+ // Header
+ if (!matchMark(results->rawbuf[offset], kPanasonicHdrMark,
+ kPanasonicAcTolerance, kPanasonicAcExcess))
+ return false;
+ // Calculate how long the common tick time is based on the header mark.
+ uint32_t m_tick =
+ results->rawbuf[offset++] * kRawTick / kPanasonicHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kPanasonicHdrSpace,
+ kPanasonicAcTolerance, kPanasonicAcExcess))
+ return false;
+ // Calculate how long the common tick time is based on the header space.
+ uint32_t s_tick =
+ results->rawbuf[offset++] * kRawTick / kPanasonicHdrSpaceTicks;
+
+ uint16_t i = 0;
+ // Data (Section #1)
+ // Keep reading bytes until we either run out of section or state to fill.
+ for (; offset <= results->rawlen - 16 && i < kPanasonicAcSection1Length;
+ i++, dataBitsSoFar += 8, offset += data_result.used) {
+ data_result = matchData(
+ &(results->rawbuf[offset]), 8, kPanasonicBitMarkTicks * m_tick,
+ kPanasonicOneSpaceTicks * s_tick, kPanasonicBitMarkTicks * m_tick,
+ kPanasonicZeroSpaceTicks * s_tick, kPanasonicAcTolerance,
+ kPanasonicAcExcess, false);
+ if (data_result.success == false) {
+ DPRINT("DEBUG: offset = ");
+ DPRINTLN(offset + data_result.used);
+ return false; // Fail
+ }
+ results->state[i] = data_result.data;
+ }
+ // Section footer.
+ if (!matchMark(results->rawbuf[offset++], kPanasonicBitMarkTicks * m_tick,
+ kPanasonicAcTolerance, kPanasonicAcExcess))
+ return false;
+ if (!matchSpace(results->rawbuf[offset++], kPanasonicAcSectionGap,
+ kPanasonicAcTolerance, kPanasonicAcExcess))
+ return false;
+ // Header.
+ if (!matchMark(results->rawbuf[offset++], kPanasonicHdrMarkTicks * m_tick,
+ kPanasonicAcTolerance, kPanasonicAcExcess))
+ return false;
+ if (!matchSpace(results->rawbuf[offset++], kPanasonicHdrSpaceTicks * s_tick,
+ kPanasonicAcTolerance, kPanasonicAcExcess))
+ return false;
+ // Data (Section #2)
+ // Keep reading bytes until we either run out of data.
+ for (; offset <= results->rawlen - 16 && i < nbits / 8;
+ i++, dataBitsSoFar += 8, offset += data_result.used) {
+ data_result = matchData(
+ &(results->rawbuf[offset]), 8, kPanasonicBitMarkTicks * m_tick,
+ kPanasonicOneSpaceTicks * s_tick, kPanasonicBitMarkTicks * m_tick,
+ kPanasonicZeroSpaceTicks * s_tick, kPanasonicAcTolerance,
+ kPanasonicAcExcess, false);
+ if (data_result.success == false) {
+ DPRINT("DEBUG: offset = ");
+ DPRINTLN(offset + data_result.used);
+ return false; // Fail
+ }
+ results->state[i] = data_result.data;
+ }
+ // Message Footer.
+ if (!matchMark(results->rawbuf[offset++], kPanasonicBitMarkTicks * m_tick,
+ kPanasonicAcTolerance, kPanasonicAcExcess))
+ return false;
+ if (offset <= results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kPanasonicAcMessageGap))
+ return false;
+
+ // Compliance
+ if (strict) {
+ // Check the signatures of the section blocks. They start with 0x02& 0x20.
+ if (results->state[0] != 0x02 || results->state[1] != 0x20 ||
+ results->state[8] != 0x02 || results->state[9] != 0x20)
+ return false;
+ if (!IRPanasonicAc::validChecksum(results->state, nbits / 8)) return false;
+ }
+
+ // Success
+ results->decode_type = PANASONIC_AC;
+ results->bits = nbits;
+ return true;
+}
+#endif // DECODE_PANASONIC_AC
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Panasonic.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Panasonic.h
new file mode 100644
index 000000000000..762631fe79ea
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Panasonic.h
@@ -0,0 +1,145 @@
+// Copyright 2018 David Conran
+
+#ifndef IR_PANASONIC_H_
+#define IR_PANASONIC_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifdef ARDUINO
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// PPPP AAA N N AAA SSSS OOO N N IIIII CCCC
+// P P A A NN N A A S O O NN N I C
+// PPPP AAAAA N N N AAAAA SSS O O N N N I C
+// P A A N NN A A S O O N NN I C
+// P A A N N A A SSSS OOO N N IIIII CCCC
+
+// Panasonic A/C support heavily influenced by:
+// https://github.com/ToniA/ESPEasy/blob/HeatpumpIR/lib/HeatpumpIR/PanasonicHeatpumpIR.cpp
+
+// Constants
+const uint16_t kPanasonicFreq = 36700;
+const uint16_t kPanasonicAcExcess = 0;
+// Much higher than usual. See issue #540.
+const uint16_t kPanasonicAcTolerance = 40;
+
+const uint8_t kPanasonicAcAuto = 0; // 0b0000
+const uint8_t kPanasonicAcDry = 2; // 0b0010
+const uint8_t kPanasonicAcCool = 3; // 0b0011
+const uint8_t kPanasonicAcHeat = 4; // 0b0010
+const uint8_t kPanasonicAcFan = 6; // 0b0110
+const uint8_t kPanasonicAcFanMin = 0;
+const uint8_t kPanasonicAcFanMax = 4;
+const uint8_t kPanasonicAcFanAuto = 7;
+const uint8_t kPanasonicAcFanOffset = 3;
+const uint8_t kPanasonicAcPower = 1; // 0b1
+const uint8_t kPanasonicAcMinTemp = 16; // Celsius
+const uint8_t kPanasonicAcMaxTemp = 30; // Celsius
+const uint8_t kPanasonicAcFanModeTemp = 27; // Celsius
+const uint8_t kPanasonicAcQuiet = 1; // 0b1
+const uint8_t kPanasonicAcPowerful = 0x20; // 0b100000
+// CKP models have Powerful and Quiet bits swapped.
+const uint8_t kPanasonicAcQuietCkp = 0x20; // 0b100000
+const uint8_t kPanasonicAcPowerfulCkp = 1; // 0b1
+const uint8_t kPanasonicAcSwingVAuto = 0xF;
+const uint8_t kPanasonicAcSwingVUp = 0x1;
+const uint8_t kPanasonicAcSwingVDown = 0x5;
+const uint8_t kPanasonicAcSwingHAuto = 0xD;
+const uint8_t kPanasonicAcSwingHMiddle = 0x6;
+const uint8_t kPanasonicAcSwingHFullLeft = 0x9;
+const uint8_t kPanasonicAcSwingHLeft = 0xA;
+const uint8_t kPanasonicAcSwingHRight = 0xB;
+const uint8_t kPanasonicAcSwingHFullRight = 0xC;
+const uint8_t kPanasonicAcChecksumInit = 0xF4;
+const uint8_t kPanasonicAcOnTimer = 0b00000010;
+const uint8_t kPanasonicAcOffTimer = 0b00000100;
+const uint16_t kPanasonicAcTimeMax = 23 * 60 + 59; // Mins since midnight.
+const uint16_t kPanasonicAcTimeSpecial = 0x600;
+
+const uint8_t kPanasonicKnownGoodState[kPanasonicAcStateLength] = {
+ 0x02, 0x20, 0xE0, 0x04, 0x00, 0x00, 0x00, 0x06, 0x02,
+ 0x20, 0xE0, 0x04, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
+ 0x00, 0x0E, 0xE0, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00};
+
+enum panasonic_ac_remote_model_t {
+ kPanasonicUnknown = 0,
+ kPanasonicLke = 1,
+ kPanasonicNke = 2,
+ kPanasonicDke = 3,
+ kPanasonicJke = 4,
+ kPanasonicCkp = 5,
+};
+
+class IRPanasonicAc {
+ public:
+ explicit IRPanasonicAc(uint16_t pin);
+
+ void stateReset();
+#if SEND_PANASONIC
+ void send();
+#endif // SEND_PANASONIC
+ void begin();
+ void on();
+ void off();
+ void setPower(const bool state);
+ bool getPower();
+ void setTemp(const uint8_t temp, const bool remember = true);
+ uint8_t getTemp();
+ void setFan(const uint8_t fan);
+ uint8_t getFan();
+ void setMode(const uint8_t mode);
+ uint8_t getMode();
+ void setRaw(const uint8_t state[]);
+ uint8_t *getRaw();
+ static bool validChecksum(uint8_t *state,
+ const uint16_t length = kPanasonicAcStateLength);
+ static uint8_t calcChecksum(uint8_t *state,
+ const uint16_t length = kPanasonicAcStateLength);
+ void setQuiet(const bool state);
+ bool getQuiet();
+ void setPowerful(const bool state);
+ bool getPowerful();
+ void setModel(const panasonic_ac_remote_model_t model);
+ panasonic_ac_remote_model_t getModel();
+ void setSwingVertical(const uint8_t elevation);
+ uint8_t getSwingVertical();
+ void setSwingHorizontal(const uint8_t direction);
+ uint8_t getSwingHorizontal();
+ static uint16_t encodeTime(const uint8_t hours, const uint8_t mins);
+ uint16_t getClock();
+ void setClock(const uint16_t mins_since_midnight);
+ uint16_t getOnTimer();
+ void setOnTimer(const uint16_t mins_since_midnight, const bool enable = true);
+ void cancelOnTimer();
+ bool isOnTimerEnabled();
+ uint16_t getOffTimer();
+ void setOffTimer(const uint16_t mins_since_midnight,
+ const bool enable = true);
+ void cancelOffTimer();
+ bool isOffTimerEnabled();
+#ifdef ARDUINO
+ String toString();
+ static String timeToString(const uint16_t mins_since_midnight);
+#else
+ std::string toString();
+ static std::string timeToString(const uint16_t mins_since_midnight);
+#endif
+#ifndef UNIT_TEST
+
+ private:
+#endif
+ uint8_t remote_state[kPanasonicAcStateLength];
+ uint8_t _swingh;
+ uint8_t _temp;
+ void fixChecksum(const uint16_t length = kPanasonicAcStateLength);
+ static uint8_t calcChecksum(const uint8_t *state,
+ const uint16_t length = kPanasonicAcStateLength);
+ IRsend _irsend;
+};
+
+#endif // IR_PANASONIC_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Pioneer.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Pioneer.cpp
new file mode 100644
index 000000000000..9134e36966d6
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Pioneer.cpp
@@ -0,0 +1,143 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2017, 2018 David Conran
+// Copyright 2018 Kamil Palczewski
+
+#define __STDC_LIMIT_MACROS
+#include
+#include
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+#include "ir_NEC.h"
+
+// PPPP III OOO N N EEEE EEEE RRRR
+// P P I O O NN N E E R R
+// PPPP I O O N N N EEE EEE RRRR
+// P I O O N NN E E R R
+// P III OOO N N EEEE EEEE R RR
+
+// Ref:
+// http://adrian-kingston.com/IRFormatPioneer.htm
+
+#if SEND_PIONEER
+// Send a raw Pioneer formatted message.
+//
+// Args:
+// data: The message to be sent.
+// nbits: The number of bits of the message to be sent.
+// Typically kPioneerBits.
+// repeat: The number of times the command is to be repeated.
+//
+// Status: BETA / Expected to be working.
+//
+// Ref:
+// http://adrian-kingston.com/IRFormatPioneer.htm
+void IRsend::sendPioneer(const uint64_t data, const uint16_t nbits,
+ const uint16_t repeat) {
+ // If nbits is to big, or is odd, abort.
+ if (nbits > sizeof(data) * 8 || nbits % 2 == 1) return;
+
+ // send 1st part of the code
+ sendNEC(data >> (nbits / 2), nbits / 2, 0);
+ // send 2nd part of the code
+ sendNEC(data & (((uint64_t)1 << (nbits / 2)) - 1), nbits / 2, repeat);
+}
+
+// Calculate the raw Pioneer data code based on two NEC sub-codes
+// Args:
+// address A 16-bit "published" NEC value.
+// command: A 16-bit "published" NEC value.
+// Returns:
+// A raw 64-bit Pioneer message code.
+//
+// Status: BETA / Expected to work.
+//
+// Note:
+// Address & Command can be take from a decode result OR from the spreadsheets
+// located at:
+// https://www.pioneerelectronics.com/PUSA/Support/Home-Entertainment-Custom-Install/IR+Codes/A+V+Receivers
+// where the first part is considered the address,
+// and the second the command.
+// e.g.
+// "A556+AF20" is an Address of 0xA556 & a Command of 0xAF20.
+uint64_t IRsend::encodePioneer(const uint16_t address, const uint16_t command) {
+ return (((uint64_t)encodeNEC(address >> 8, address & 0xFF)) << 32) |
+ encodeNEC(command >> 8, command & 0xFF);
+}
+#endif // SEND_PIONEER
+
+#if DECODE_PIONEER
+// Decode the supplied Pioneer message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kPioneerBits.
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Should be working. (Self decodes & real examples)
+//
+bool IRrecv::decodePioneer(decode_results *results, const uint16_t nbits,
+ const bool strict) {
+ if (results->rawlen < 2 * (nbits + kHeader + kFooter) - 1)
+ return false; // Can't possibly be a valid Pioneer message.
+ if (strict && nbits != kPioneerBits)
+ return false; // Not strictly an Pioneer message.
+
+ uint64_t data = 0;
+ uint16_t offset = kStartOffset;
+
+ for (uint16_t section = 0; section < 2; section++) {
+ // Header
+ if (!matchMark(results->rawbuf[offset], kNecHdrMark)) return false;
+ // Calculate how long the lowest tick time is based on the header mark.
+ uint32_t mark_tick =
+ results->rawbuf[offset++] * kRawTick / kNecHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kNecHdrSpace)) return false;
+ // Calculate how long the common tick time is based on the header space.
+ uint32_t space_tick =
+ results->rawbuf[offset++] * kRawTick / kNecHdrSpaceTicks;
+ //
+ // Data
+ match_result_t data_result = matchData(
+ &(results->rawbuf[offset]), nbits / 2, kNecBitMarkTicks * mark_tick,
+ kNecOneSpaceTicks * space_tick, kNecBitMarkTicks * mark_tick,
+ kNecZeroSpaceTicks * space_tick);
+ if (data_result.success == false) return false;
+ uint8_t command = data_result.data >> 8;
+ uint8_t command_inverted = data_result.data;
+ uint8_t address = data_result.data >> 24;
+ uint8_t address_inverted = data_result.data >> 16;
+ // Compliance
+ if (strict) {
+ if (command != (command_inverted ^ 0xFF))
+ return false; // Command integrity failed.
+ if (address != (address_inverted ^ 0xFF))
+ return false; // Address integrity failed.
+ }
+ data = (data << (nbits / 2)) + data_result.data;
+ offset += data_result.used;
+ // NEC-like commands and addresses are technically in LSB first order so the
+ // final versions have to be reversed.
+ uint16_t code = reverseBits((command << 8) + address, 16);
+ if (section)
+ results->command = code;
+ else
+ results->address = code;
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kNecBitMarkTicks * mark_tick))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kNecMinGapTicks * space_tick))
+ return false;
+ }
+
+ // Success
+ results->bits = nbits;
+ results->value = data;
+ results->decode_type = PIONEER;
+ return true;
+}
+#endif // DECODE_PIONEER
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Pronto.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Pronto.cpp
similarity index 81%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Pronto.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Pronto.cpp
index ca76f0848b62..9ab5c76d0708 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Pronto.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Pronto.cpp
@@ -2,7 +2,6 @@
#include
#include "IRsend.h"
-#include "IRtimer.h"
// PPPPPP tt
// PP PP rr rr oooo nn nnn tt oooo
@@ -11,12 +10,12 @@
// PP rr oooo nn nn tttt oooo
// Constants
-#define PRONTO_FREQ_FACTOR 0.241246
-#define PRONTO_TYPE_OFFSET 0U
-#define PRONTO_FREQ_OFFSET 1U
-#define PRONTO_SEQ_1_LEN_OFFSET 2U
-#define PRONTO_SEQ_2_LEN_OFFSET 3U
-#define PRONTO_DATA_OFFSET 4U
+const float kProntoFreqFactor = 0.241246;
+const uint16_t kProntoTypeOffset = 0;
+const uint16_t kProntoFreqOffset = 1;
+const uint16_t kProntoSeq1LenOffset = 2;
+const uint16_t kProntoSeq2LenOffset = 3;
+const uint16_t kProntoDataOffset = 4;
#if SEND_PRONTO
// Send a Pronto Code formatted message.
@@ -50,29 +49,29 @@
// 0x0030, 0x0018, 0x0018, 0x0018, 0x0018, 0x0018, 0x0030, 0x0018,
// 0x0018, 0x03f6};
// // Send the Pronto(Sony) code. Repeat twice as Sony's require that.
-// sendPronto(prontoCode, 46, SONY_MIN_REPEAT);
+// sendPronto(prontoCode, 46, kSonyMinRepeat);
//
// Ref:
// http://www.etcwiki.org/wiki/Pronto_Infrared_Format
// http://www.remotecentral.com/features/irdisp2.htm
void IRsend::sendPronto(uint16_t data[], uint16_t len, uint16_t repeat) {
// Check we have enough data to work out what to send.
- if (len < PRONTO_MIN_LENGTH) return;
+ if (len < kProntoMinLength) return;
// We only know how to deal with 'raw' pronto codes types. Reject all others.
- if (data[PRONTO_TYPE_OFFSET] != 0) return;
+ if (data[kProntoTypeOffset] != 0) return;
// Pronto frequency is in Hz.
- uint16_t hz = (uint16_t) (1000000U / (data[PRONTO_FREQ_OFFSET] *
- PRONTO_FREQ_FACTOR));
+ uint16_t hz =
+ (uint16_t)(1000000U / (data[kProntoFreqOffset] * kProntoFreqFactor));
enableIROut(hz);
// Grab the length of the two sequences.
- uint16_t seq_1_len = data[PRONTO_SEQ_1_LEN_OFFSET] * 2;
- uint16_t seq_2_len = data[PRONTO_SEQ_2_LEN_OFFSET] * 2;
+ uint16_t seq_1_len = data[kProntoSeq1LenOffset] * 2;
+ uint16_t seq_2_len = data[kProntoSeq2LenOffset] * 2;
// Calculate where each sequence starts in the buffer.
- uint16_t seq_1_start = PRONTO_DATA_OFFSET;
- uint16_t seq_2_start = PRONTO_DATA_OFFSET + seq_1_len;
+ uint16_t seq_1_start = kProntoDataOffset;
+ uint16_t seq_2_start = kProntoDataOffset + seq_1_len;
uint32_t periodic_time = calcUSecPeriod(hz, false);
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_RC5_RC6.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_RC5_RC6.cpp
similarity index 70%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_RC5_RC6.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_RC5_RC6.cpp
index 65aaf88d7971..ef1500d60dcd 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_RC5_RC6.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_RC5_RC6.cpp
@@ -21,30 +21,31 @@
// Ref:
// https://en.wikipedia.org/wiki/RC-5
// http://www.sbprojects.com/knowledge/ir/rc5.php
-#define MIN_RC5_SAMPLES 11U
-#define MIN_RC6_SAMPLES 1U
-#define RC5_T1 889U
-#define RC5_MIN_COMMAND_LENGTH 113778UL
-#define RC5_MIN_GAP (RC5_MIN_COMMAND_LENGTH - RC5_RAW_BITS * (2 * RC5_T1))
-#define RC5_TOGGLE_MASK 0x800U // (The 12th bit)
+
+const uint16_t kRc5T1 = 889;
+const uint32_t kRc5MinCommandLength = 113778;
+const uint32_t kRc5MinGap = kRc5MinCommandLength - kRC5RawBits * (2 * kRc5T1);
+const uint16_t kRc5ToggleMask = 0x800; // The 12th bit.
+const uint16_t kRc5SamplesMin = 11;
+
// RC-6
// Ref:
// https://en.wikipedia.org/wiki/RC-6
// http://www.pcbheaven.com/userpages/The_Philips_RC6_Protocol/
-#define RC6_TICK 444U
-#define RC6_HDR_MARK_TICKS 6U
-#define RC6_HDR_MARK (RC6_HDR_MARK_TICKS * RC6_TICK)
-#define RC6_HDR_SPACE_TICKS 2U
-#define RC6_HDR_SPACE (RC6_HDR_SPACE_TICKS * RC6_TICK)
-#define RC6_RPT_LENGTH_TICKS 187U
-#define RC6_RPT_LENGTH (RC6_RPT_LENGTH_TICKS * RC6_TICK)
-#define RC6_TOGGLE_MASK 0x10000UL // (The 17th bit)
-#define RC6_36_TOGGLE_MASK 0x8000U // (The 16th bit)
-// Common (getRClevel())
-#define MARK 0U
-#define SPACE 1U
+const uint16_t kRc6Tick = 444;
+const uint16_t kRc6HdrMarkTicks = 6;
+const uint16_t kRc6HdrMark = kRc6HdrMarkTicks * kRc6Tick;
+const uint16_t kRc6HdrSpaceTicks = 2;
+const uint16_t kRc6HdrSpace = kRc6HdrSpaceTicks * kRc6Tick;
+const uint16_t kRc6RptLengthTicks = 187;
+const uint32_t kRc6RptLength = kRc6RptLengthTicks * kRc6Tick;
+const uint32_t kRc6ToggleMask = 0x10000UL; // The 17th bit.
+const uint16_t kRc6_36ToggleMask = 0x8000; // The 16th bit.
+// Common (getRClevel())
+const int16_t kMark = 0;
+const int16_t kSpace = 1;
#if SEND_RC5
// Send a Philips RC-5/RC-5X packet.
@@ -68,14 +69,13 @@
// TODO(anyone):
// Testing of the RC-5X components.
void IRsend::sendRC5(uint64_t data, uint16_t nbits, uint16_t repeat) {
- if (nbits > sizeof(data) * 8)
- return; // We can't send something that big.
+ if (nbits > sizeof(data) * 8) return; // We can't send something that big.
bool skipSpace = true;
bool field_bit = true;
// Set 36kHz IR carrier frequency & a 1/4 (25%) duty cycle.
enableIROut(36, 25);
- if (nbits >= RC5X_BITS) { // Is this a RC-5X message?
+ if (nbits >= kRC5XBits) { // Is this a RC-5X message?
// field bit is the inverted MSB of RC-5X data.
field_bit = ((data >> (nbits - 1)) ^ 1) & 1;
nbits--;
@@ -90,28 +90,28 @@ void IRsend::sendRC5(uint64_t data, uint16_t nbits, uint16_t repeat) {
if (skipSpace)
skipSpace = false; // First time through, we assume the leading space().
else
- space(RC5_T1);
- mark(RC5_T1);
+ space(kRc5T1);
+ mark(kRc5T1);
// Field/Second start bit.
if (field_bit) { // Send a 1. Normal for RC-5.
- space(RC5_T1);
- mark(RC5_T1);
+ space(kRc5T1);
+ mark(kRc5T1);
} else { // Send a 0. Special case for RC-5X. Means 7th command bit is 1.
- mark(RC5_T1);
- space(RC5_T1);
+ mark(kRc5T1);
+ space(kRc5T1);
}
// Data
for (uint64_t mask = 1ULL << (nbits - 1); mask; mask >>= 1)
if (data & mask) { // 1
- space(RC5_T1); // 1 is space, then mark.
- mark(RC5_T1);
- } else { // 0
- mark(RC5_T1); // 0 is mark, then space.
- space(RC5_T1);
+ space(kRc5T1); // 1 is space, then mark.
+ mark(kRc5T1);
+ } else { // 0
+ mark(kRc5T1); // 0 is mark, then space.
+ space(kRc5T1);
}
// Footer
- space(std::max(RC5_MIN_GAP, RC5_MIN_COMMAND_LENGTH - usecTimer.elapsed()));
+ space(std::max(kRc5MinGap, kRc5MinCommandLength - usecTimer.elapsed()));
}
}
@@ -132,8 +132,7 @@ void IRsend::sendRC5(uint64_t data, uint16_t nbits, uint16_t repeat) {
// https://en.wikipedia.org/wiki/RC-5
uint16_t IRsend::encodeRC5(uint8_t address, uint8_t command,
bool key_released) {
- return (key_released << (RC5_BITS - 1)) |
- ((address & 0x1f) << 6) |
+ return (key_released << (kRC5Bits - 1)) | ((address & 0x1f) << 6) |
(command & 0x3F);
}
@@ -157,8 +156,8 @@ uint16_t IRsend::encodeRC5X(uint8_t address, uint8_t command,
// The 2nd start/field bit (MSB of the return value) is the value of the 7th
// command bit.
bool s2 = (command >> 6) & 1;
- return ((uint16_t) s2 << (RC5X_BITS - 1)) |
- encodeRC5(address, command, key_released);
+ return ((uint16_t)s2 << (kRC5XBits - 1)) |
+ encodeRC5(address, command, key_released);
}
// Flip the toggle bit of a Philips RC-5/RC-5X data message.
@@ -175,9 +174,7 @@ uint16_t IRsend::encodeRC5X(uint8_t address, uint8_t command,
// Ref:
// http://www.sbprojects.com/knowledge/ir/rc5.php
// https://en.wikipedia.org/wiki/RC-5
-uint64_t IRsend::toggleRC5(uint64_t data) {
- return data ^ RC5_TOGGLE_MASK;
-}
+uint64_t IRsend::toggleRC5(uint64_t data) { return data ^ kRc5ToggleMask; }
#endif // SEND_RC5
#if SEND_RC6
@@ -199,9 +196,8 @@ uint64_t IRsend::toggleRC5(uint64_t data) {
// http://www.sbprojects.com/knowledge/ir/rc6.php
// http://www.righto.com/2010/12/64-bit-rc6-codes-arduino-and-xbox.html
uint64_t IRsend::toggleRC6(uint64_t data, uint16_t nbits) {
- if (nbits == RC6_36_BITS)
- return data ^ RC6_36_TOGGLE_MASK;
- return data ^ RC6_TOGGLE_MASK;
+ if (nbits == kRC6_36Bits) return data ^ kRc6_36ToggleMask;
+ return data ^ kRc6ToggleMask;
}
// Encode a Philips RC-6 data message.
@@ -221,13 +217,12 @@ uint64_t IRsend::toggleRC6(uint64_t data, uint16_t nbits) {
// http://www.sbprojects.com/knowledge/ir/rc6.php
// http://www.righto.com/2010/12/64-bit-rc6-codes-arduino-and-xbox.html
// http://www.pcbheaven.com/userpages/The_Philips_RC6_Protocol/
-uint64_t IRsend::encodeRC6(uint32_t address, uint8_t command,
- uint16_t mode) {
+uint64_t IRsend::encodeRC6(uint32_t address, uint8_t command, uint16_t mode) {
switch (mode) {
- case RC6_MODE0_BITS:
+ case kRC6Mode0Bits:
return ((address & 0xFFF) << 8) | (command & 0xFF);
- case RC6_36_BITS:
- return ((uint64_t) (address & 0xFFFFFFF) << 8) | (command & 0xFF);
+ case kRC6_36Bits:
+ return ((uint64_t)(address & 0xFFFFFFF) << 8) | (command & 0xFF);
default:
return 0;
}
@@ -250,25 +245,24 @@ uint64_t IRsend::encodeRC6(uint32_t address, uint8_t command,
// https://en.wikipedia.org/wiki/Manchester_code
void IRsend::sendRC6(uint64_t data, uint16_t nbits, uint16_t repeat) {
// Check we can send the number of bits requested.
- if (nbits > sizeof(data) * 8)
- return;
+ if (nbits > sizeof(data) * 8) return;
// Set 36kHz IR carrier frequency & a 1/3 (33%) duty cycle.
enableIROut(36, 33);
for (uint16_t r = 0; r <= repeat; r++) {
// Header
- mark(RC6_HDR_MARK);
- space(RC6_HDR_SPACE);
+ mark(kRc6HdrMark);
+ space(kRc6HdrSpace);
// Start bit.
- mark(RC6_TICK); // mark, then space == 0x1.
- space(RC6_TICK);
+ mark(kRc6Tick); // mark, then space == 0x1.
+ space(kRc6Tick);
// Data
uint16_t bitTime;
for (uint64_t i = 1, mask = 1ULL << (nbits - 1); mask; i++, mask >>= 1) {
if (i == 4) // The fourth bit we send is a "double width trailer bit".
- bitTime = 2 * RC6_TICK; // double-wide trailer bit
+ bitTime = 2 * kRc6Tick; // double-wide trailer bit
else
- bitTime = RC6_TICK; // Normal bit
- if (data & mask) { // 1
+ bitTime = kRc6Tick; // Normal bit
+ if (data & mask) { // 1
mark(bitTime);
space(bitTime);
} else { // 0
@@ -277,12 +271,12 @@ void IRsend::sendRC6(uint64_t data, uint16_t nbits, uint16_t repeat) {
}
}
// Footer
- space(RC6_RPT_LENGTH);
+ space(kRc6RptLength);
}
}
#endif // SEND_RC6
-#if (DECODE_RC5 || DECODE_RC6)
+#if (DECODE_RC5 || DECODE_RC6 || DECODE_LASERTAG)
// 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,
@@ -294,47 +288,65 @@ void IRsend::sendRC6(uint64_t data, uint16_t nbits, uint16_t repeat) {
// offset: Ptr to the currect offset to the rawbuf.
// used: Ptr to the current used counter.
// bitTime: Time interval of single bit in microseconds.
+// maxwidth: Maximum number of successive levels to find in a single level
+// (default 3)
// Returns:
// int: MARK, SPACE, or -1 for error (The measured time interval is not a
// multiple of t1.)
// Ref:
// https://en.wikipedia.org/wiki/Manchester_code
-int16_t IRrecv::getRClevel(decode_results *results, uint16_t *offset,
- uint16_t *used, uint16_t bitTime) {
- if (*offset >= results->rawlen)
- return SPACE; // After end of recorded buffer, assume SPACE.
+int16_t IRrecv::getRClevel(decode_results *results, uint16_t *offset,
+ uint16_t *used, uint16_t bitTime, uint8_t tolerance,
+ int16_t excess, uint16_t delta, uint8_t maxwidth) {
+ DPRINT("DEBUG: getRClevel: offset = ");
+ DPRINTLN(uint64ToString(*offset));
+ DPRINT("DEBUG: getRClevel: rawlen = ");
+ DPRINTLN(uint64ToString(results->rawlen));
+ if (*offset >= results->rawlen) {
+ DPRINTLN("DEBUG: getRClevel: SPACE, past end of rawbuf");
+ return kSpace; // After end of recorded buffer, assume SPACE.
+ }
uint16_t width = results->rawbuf[*offset];
// If the value of offset is odd, it's a MARK. Even, it's a SPACE.
- uint16_t val = ((*offset) % 2) ? MARK : SPACE;
+ uint16_t val = ((*offset) % 2) ? kMark : kSpace;
// Check to see if we have hit an inter-message gap (> 20ms).
- if (val == SPACE && width > 20000)
- return SPACE;
- int16_t correction = (val == MARK) ? MARK_EXCESS : -MARK_EXCESS;
+ if (val == kSpace &&
+ (width > 20000 - delta || width > maxwidth * bitTime + delta)) {
+ DPRINTLN("DEBUG: getRClevel: SPACE, hit end of mesg gap.");
+ return kSpace;
+ }
+ int16_t correction = (val == kMark) ? excess : -excess;
// Calculate the look-ahead for our current position in the buffer.
uint16_t avail;
// Note: We want to match in greedy order as the other way leads to
// mismatches due to overlaps induced by the correction and tolerance
// values.
- if (match(width, 3 * bitTime + correction))
- avail = 3;
- else if (match(width, 2 * bitTime + correction))
- avail = 2;
- else if (match(width, bitTime + correction))
- avail = 1;
- else
+ for (avail = maxwidth; avail > 0; avail--) {
+ if (match(width, avail * bitTime + correction, tolerance, delta)) {
+ break;
+ }
+ }
+ if (!avail) {
+ DPRINTLN("DEBUG: getRClevel: Unexpected width. Exiting.");
return -1; // The width is not what we expected.
+ }
- (*used)++; // Count another one of the avail slots as used.
+ (*used)++; // Count another one of the avail slots as used.
if (*used >= avail) { // Are we out of look-ahead/avail slots?
// Yes, so reset the used counter, and move the offset ahead.
*used = 0;
(*offset)++;
}
+ if (val == kMark) {
+ DPRINTLN("DEBUG: getRClevel: MARK");
+ } else {
+ DPRINTLN("DEBUG: getRClevel: SPACE");
+ }
return val;
}
-#endif // (DECODE_RC5 || DECODE_RC6)
+#endif // (DECODE_RC5 || DECODE_RC6 || DECODE_LASERTAG)
#if DECODE_RC5
// Decode the supplied RC-5/RC5X message.
@@ -358,28 +370,28 @@ int16_t IRrecv::getRClevel(decode_results *results, uint16_t *offset,
// TODO(anyone):
// Serious testing of the RC-5X and strict aspects needs to be done.
bool IRrecv::decodeRC5(decode_results *results, uint16_t nbits, bool strict) {
- if (results->rawlen < MIN_RC5_SAMPLES + HEADER - 1) return false;
+ if (results->rawlen < kRc5SamplesMin + kHeader - 1) return false;
// Compliance
- if (strict && nbits != RC5_BITS && nbits != RC5X_BITS)
+ if (strict && nbits != kRC5Bits && nbits != kRC5XBits)
return false; // It's neither RC-5 or RC-5X.
- uint16_t offset = OFFSET_START;
+ uint16_t offset = kStartOffset;
uint16_t used = 0;
bool is_rc5x = false;
uint64_t data = 0;
// Header
// Get start bit #1.
- if (getRClevel(results, &offset, &used, RC5_T1) != MARK) return false;
+ if (getRClevel(results, &offset, &used, kRc5T1) != kMark) return false;
// Get field/start bit #2 (inverted bit-7 of the command if RC-5X protocol)
uint16_t actual_bits = 1;
- int16_t levelA = getRClevel(results, &offset, &used, RC5_T1);
- int16_t levelB = getRClevel(results, &offset, &used, RC5_T1);
- if (levelA == SPACE && levelB == MARK) { // Matched a 1.
+ int16_t levelA = getRClevel(results, &offset, &used, kRc5T1);
+ int16_t levelB = getRClevel(results, &offset, &used, kRc5T1);
+ if (levelA == kSpace && levelB == kMark) { // Matched a 1.
is_rc5x = false;
- } else if (levelA == MARK && levelB == SPACE) { // Matched a 0.
- if (nbits <= RC5_BITS) return false; // Field bit must be '1' for RC5.
+ } else if (levelA == kMark && levelB == kSpace) { // Matched a 0.
+ if (nbits <= kRC5Bits) return false; // Field bit must be '1' for RC5.
is_rc5x = true;
data = 1;
} else {
@@ -388,11 +400,11 @@ bool IRrecv::decodeRC5(decode_results *results, uint16_t nbits, bool strict) {
// Data
for (; offset < results->rawlen; actual_bits++) {
- int16_t levelA = getRClevel(results, &offset, &used, RC5_T1);
- int16_t levelB = getRClevel(results, &offset, &used, RC5_T1);
- if (levelA == SPACE && levelB == MARK)
+ int16_t levelA = getRClevel(results, &offset, &used, kRc5T1);
+ int16_t levelB = getRClevel(results, &offset, &used, kRc5T1);
+ if (levelA == kSpace && levelB == kMark)
data = (data << 1) | 1; // 1
- else if (levelA == MARK && levelB == SPACE)
+ else if (levelA == kMark && levelB == kSpace)
data <<= 1; // 0
else
break;
@@ -401,8 +413,8 @@ bool IRrecv::decodeRC5(decode_results *results, uint16_t nbits, bool strict) {
// Compliance
if (actual_bits < nbits) return false; // Less data than we expected.
- if (strict && actual_bits != RC5_BITS &&
- actual_bits != RC5X_BITS) return false;
+ if (strict && actual_bits != kRC5Bits && actual_bits != kRC5XBits)
+ return false;
// Success
results->value = data;
@@ -411,7 +423,7 @@ bool IRrecv::decodeRC5(decode_results *results, uint16_t nbits, bool strict) {
results->repeat = false;
if (is_rc5x) {
results->decode_type = RC5X;
- results->command |= ((uint32_t) is_rc5x) << 6;
+ results->command |= ((uint32_t)is_rc5x) << 6;
} else {
results->decode_type = RC5;
actual_bits--; // RC5 doesn't count the field bit as data.
@@ -439,7 +451,7 @@ bool IRrecv::decodeRC5(decode_results *results, uint16_t nbits, bool strict) {
// TODO(anyone):
// Testing of the strict compliance aspects.
bool IRrecv::decodeRC6(decode_results *results, uint16_t nbits, bool strict) {
- if (results->rawlen < HEADER + 2 + 4) // Up to the double-wide T bit.
+ if (results->rawlen < kHeader + 2 + 4) // Up to the double-wide T bit.
return false; // Smaller than absolute smallest possible RC6 message.
if (strict) { // Compliance
@@ -449,31 +461,31 @@ bool IRrecv::decodeRC6(decode_results *results, uint16_t nbits, bool strict) {
// Also due to potential melding with the start bit, we can only count
// the start bit as 1, instead of a more typical 2 value. The header still
// remains as normal.
- if (results->rawlen < nbits + HEADER + 1)
+ if (results->rawlen < nbits + kHeader + 1)
return false; // Don't have enough entries/samples to be valid.
switch (nbits) {
- case RC6_MODE0_BITS:
- case RC6_36_BITS:
+ case kRC6Mode0Bits:
+ case kRC6_36Bits:
break;
default:
return false; // Asking for the wrong number of bits.
}
}
- uint16_t offset = OFFSET_START;
+ uint16_t offset = kStartOffset;
// Header
- if (!matchMark(results->rawbuf[offset], RC6_HDR_MARK)) return false;
+ if (!matchMark(results->rawbuf[offset], kRc6HdrMark)) return false;
// Calculate how long the common tick time is based on the header mark.
- uint32_t tick = results->rawbuf[offset++] * RAWTICK / RC6_HDR_MARK_TICKS;
- if (!matchSpace(results->rawbuf[offset++], RC6_HDR_SPACE_TICKS * tick))
+ uint32_t tick = results->rawbuf[offset++] * kRawTick / kRc6HdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset++], kRc6HdrSpaceTicks * tick))
return false;
uint16_t used = 0;
// Get the start bit. e.g. 1.
- if (getRClevel(results, &offset, &used, tick) != MARK) return false;
- if (getRClevel(results, &offset, &used, tick) != SPACE) return false;
+ if (getRClevel(results, &offset, &used, tick) != kMark) return false;
+ if (getRClevel(results, &offset, &used, tick) != kSpace) return false;
uint16_t actual_bits;
uint64_t data = 0;
@@ -483,17 +495,15 @@ bool IRrecv::decodeRC6(decode_results *results, uint16_t nbits, bool strict) {
int16_t levelA, levelB; // Next two levels
levelA = getRClevel(results, &offset, &used, tick);
// T bit is double wide; make sure second half matches
- if (actual_bits == 3 &&
- levelA != getRClevel(results, &offset, &used, tick))
+ if (actual_bits == 3 && levelA != getRClevel(results, &offset, &used, tick))
return false;
levelB = getRClevel(results, &offset, &used, tick);
// T bit is double wide; make sure second half matches
- if (actual_bits == 3 &&
- levelB != getRClevel(results, &offset, &used, tick))
+ if (actual_bits == 3 && levelB != getRClevel(results, &offset, &used, tick))
return false;
- if (levelA == MARK && levelB == SPACE) // reversed compared to RC5
- data = (data << 1) | 1; // 1
- else if (levelA == SPACE && levelB == MARK)
+ if (levelA == kMark && levelB == kSpace) // reversed compared to RC5
+ data = (data << 1) | 1; // 1
+ else if (levelA == kSpace && levelB == kMark)
data <<= 1; // 0
else
break;
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_RCMM.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_RCMM.cpp
similarity index 58%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_RCMM.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_RCMM.cpp
index 362702b663ba..1b03d2c0724d 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_RCMM.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_RCMM.cpp
@@ -17,28 +17,28 @@
// Constants
// Ref:
// http://www.sbprojects.com/knowledge/ir/rcmm.php
-#define RCMM_TICK 28U // Technically it would be 27.777*
-#define RCMM_HDR_MARK_TICKS 15U
-#define RCMM_HDR_MARK 416U
-#define RCMM_HDR_SPACE_TICKS 10U
-#define RCMM_HDR_SPACE 277U
-#define RCMM_BIT_MARK_TICKS 6U
-#define RCMM_BIT_MARK 166U
-#define RCMM_BIT_SPACE_0_TICKS 10U
-#define RCMM_BIT_SPACE_0 277U
-#define RCMM_BIT_SPACE_1_TICKS 16U
-#define RCMM_BIT_SPACE_1 444U
-#define RCMM_BIT_SPACE_2_TICKS 22U
-#define RCMM_BIT_SPACE_2 611U
-#define RCMM_BIT_SPACE_3_TICKS 28U
-#define RCMM_BIT_SPACE_3 777U
-#define RCMM_RPT_LENGTH_TICKS 992U
-#define RCMM_RPT_LENGTH 27778U
-#define RCMM_MIN_GAP_TICKS 120U
-#define RCMM_MIN_GAP 3360U
+const uint16_t kRcmmTick = 28; // Technically it would be 27.777*
+const uint16_t kRcmmHdrMarkTicks = 15;
+const uint16_t kRcmmHdrMark = 416;
+const uint16_t kRcmmHdrSpaceTicks = 10;
+const uint16_t kRcmmHdrSpace = 277;
+const uint16_t kRcmmBitMarkTicks = 6;
+const uint16_t kRcmmBitMark = 166;
+const uint16_t kRcmmBitSpace0Ticks = 10;
+const uint16_t kRcmmBitSpace0 = 277;
+const uint16_t kRcmmBitSpace1Ticks = 16;
+const uint16_t kRcmmBitSpace1 = 444;
+const uint16_t kRcmmBitSpace2Ticks = 22;
+const uint16_t kRcmmBitSpace2 = 611;
+const uint16_t kRcmmBitSpace3Ticks = 28;
+const uint16_t kRcmmBitSpace3 = 777;
+const uint16_t kRcmmRptLengthTicks = 992;
+const uint32_t kRcmmRptLength = 27778;
+const uint16_t kRcmmMinGapTicks = 120;
+const uint32_t kRcmmMinGap = 3360;
// Use a tolerance of +/-10% when matching some data spaces.
-#define RCMM_TOLERANCE 10U
-#define RCMM_EXCESS 50U
+const uint8_t kRcmmTolerance = 10;
+const uint16_t kRcmmExcess = 50;
#if SEND_RCMM
// Send a Philips RC-MM packet.
@@ -60,27 +60,35 @@ void IRsend::sendRCMM(uint64_t data, uint16_t nbits, uint16_t repeat) {
for (uint16_t r = 0; r <= repeat; r++) {
usecs.reset();
// Header
- mark(RCMM_HDR_MARK);
- space(RCMM_HDR_SPACE);
+ mark(kRcmmHdrMark);
+ space(kRcmmHdrSpace);
// Data
uint64_t mask = 0b11ULL << (nbits - 2);
// RC-MM sends data 2 bits at a time.
for (int32_t i = nbits; i > 0; i -= 2) {
- mark(RCMM_BIT_MARK);
+ mark(kRcmmBitMark);
// Grab the next Most Significant Bits to send.
switch ((data & mask) >> (i - 2)) {
- case 0b00: space(RCMM_BIT_SPACE_0); break;
- case 0b01: space(RCMM_BIT_SPACE_1); break;
- case 0b10: space(RCMM_BIT_SPACE_2); break;
- case 0b11: space(RCMM_BIT_SPACE_3); break;
+ case 0b00:
+ space(kRcmmBitSpace0);
+ break;
+ case 0b01:
+ space(kRcmmBitSpace1);
+ break;
+ case 0b10:
+ space(kRcmmBitSpace2);
+ break;
+ case 0b11:
+ space(kRcmmBitSpace3);
+ break;
}
mask >>= 2;
}
// Footer
- mark(RCMM_BIT_MARK);
- // Protocol requires us to wait at least RCMM_RPT_LENGTH usecs from the
- // start or RCMM_MIN_GAP usecs.
- space(std::max(RCMM_RPT_LENGTH - usecs.elapsed(), RCMM_MIN_GAP));
+ mark(kRcmmBitMark);
+ // Protocol requires us to wait at least kRcmmRptLength usecs from the
+ // start or kRcmmMinGap usecs.
+ space(std::max(kRcmmRptLength - usecs.elapsed(), kRcmmMinGap));
}
}
#endif
@@ -90,7 +98,7 @@ void IRsend::sendRCMM(uint64_t data, uint16_t nbits, uint16_t repeat) {
// Places successful decode information in the results pointer.
// Args:
// results: Ptr to the data to decode and where to store the decode result.
-// nbits: Nr. of bits to expect in the data portion. Typically RCMM_BITS.
+// nbits: Nr. of bits to expect in the data portion. Typically kRCMMBits.
// strict: Flag to indicate if we strictly adhere to the specification.
// Returns:
// boolean: True if it can decode it, false if it can't.
@@ -101,67 +109,65 @@ void IRsend::sendRCMM(uint64_t data, uint16_t nbits, uint16_t repeat) {
// http://www.sbprojects.com/knowledge/ir/rcmm.php
bool IRrecv::decodeRCMM(decode_results *results, uint16_t nbits, bool strict) {
uint64_t data = 0;
- uint16_t offset = OFFSET_START;
+ uint16_t offset = kStartOffset;
if (results->rawlen <= 4)
return false; // Not enough entries to ever be RCMM.
// Calc the maximum size in bits, the message can be, or that we can accept.
- int16_t maxBitSize = std::min((uint16_t) results->rawlen - 4,
- (uint16_t) sizeof(data) * 8);
+ int16_t maxBitSize =
+ std::min((uint16_t)results->rawlen - 5, (uint16_t)sizeof(data) * 8);
// Compliance
if (strict) {
// Technically the spec says bit sizes should be 12 xor 24. however
// 32 bits has been seen from a device. We are going to assume
// 12 <= bits <= 32 is the 'required' bit length for the spec.
- if (maxBitSize < 12 || maxBitSize > 32)
- return false;
+ if (maxBitSize < 12 || maxBitSize > 32) return false;
if (maxBitSize < nbits)
return false; // Short cut, we can never reach the expected nr. of bits.
}
// Header decode
- if (!matchMark(results->rawbuf[offset], RCMM_HDR_MARK)) return false;
+ if (!matchMark(results->rawbuf[offset], kRcmmHdrMark)) return false;
// Calculate how long the common tick time is based on the header mark.
- uint32_t m_tick = results->rawbuf[offset++] * RAWTICK / RCMM_HDR_MARK_TICKS;
- if (!matchSpace(results->rawbuf[offset], RCMM_HDR_SPACE)) return false;
+ uint32_t m_tick = results->rawbuf[offset++] * kRawTick / kRcmmHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kRcmmHdrSpace)) return false;
// Calculate how long the common tick time is based on the header space.
- uint32_t s_tick = results->rawbuf[offset++] * RAWTICK / RCMM_HDR_SPACE_TICKS;
+ uint32_t s_tick = results->rawbuf[offset++] * kRawTick / kRcmmHdrSpaceTicks;
// Data decode
// RC-MM has two bits of data per mark/space pair.
uint16_t actualBits;
for (actualBits = 0; actualBits < maxBitSize; actualBits += 2, offset++) {
- if (!match(results->rawbuf[offset++], RCMM_BIT_MARK_TICKS * m_tick))
+ if (!match(results->rawbuf[offset++], kRcmmBitMarkTicks * m_tick))
return false;
data <<= 2;
// Use non-default tolerance & excess for matching some of the spaces as the
// defaults are too generous and causes mis-matches in some cases.
- if (match(results->rawbuf[offset], RCMM_BIT_SPACE_0_TICKS * s_tick,
- TOLERANCE))
+ if (match(results->rawbuf[offset], kRcmmBitSpace0Ticks * s_tick,
+ kTolerance))
data += 0;
- else if (match(results->rawbuf[offset], RCMM_BIT_SPACE_1_TICKS * s_tick,
- TOLERANCE))
+ else if (match(results->rawbuf[offset], kRcmmBitSpace1Ticks * s_tick,
+ kTolerance))
data += 1;
- else if (match(results->rawbuf[offset], RCMM_BIT_SPACE_2_TICKS * s_tick,
- RCMM_TOLERANCE))
+ else if (match(results->rawbuf[offset], kRcmmBitSpace2Ticks * s_tick,
+ kRcmmTolerance))
data += 2;
- else if (match(results->rawbuf[offset], RCMM_BIT_SPACE_3_TICKS * s_tick,
- RCMM_TOLERANCE))
+ else if (match(results->rawbuf[offset], kRcmmBitSpace3Ticks * s_tick,
+ kRcmmTolerance))
data += 3;
else
return false;
}
// Footer decode
- if (!match(results->rawbuf[offset++], RCMM_BIT_MARK_TICKS * m_tick))
+ if (!match(results->rawbuf[offset++], kRcmmBitMarkTicks * m_tick))
return false;
if (offset < results->rawlen &&
- !matchAtLeast(results->rawbuf[offset], RCMM_MIN_GAP_TICKS * s_tick))
+ !matchAtLeast(results->rawbuf[offset], kRcmmMinGapTicks * s_tick))
return false;
// Compliance
- if (strict && actualBits != nbits)
- return false;
+ if (strict && actualBits != nbits) return false;
// Success
results->value = data;
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Samsung.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Samsung.cpp
new file mode 100644
index 000000000000..d943f8cf976e
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Samsung.cpp
@@ -0,0 +1,590 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2017 David Conran
+
+#include "ir_Samsung.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// SSSS AAA MMM SSSS U U N N GGGG
+// S A A M M M S U U NN N G
+// SSS AAAAA M M M SSS U U N N N G GG
+// S A A M M S U U N NN G G
+// SSSS A A M M SSSS UUU N N GGG
+
+// Samsung originally added from https://github.com/shirriff/Arduino-IRremote/
+
+// Constants
+// Ref:
+// http://elektrolab.wz.cz/katalog/samsung_protocol.pdf
+const uint16_t kSamsungTick = 560;
+const uint16_t kSamsungHdrMarkTicks = 8;
+const uint16_t kSamsungHdrMark = kSamsungHdrMarkTicks * kSamsungTick;
+const uint16_t kSamsungHdrSpaceTicks = 8;
+const uint16_t kSamsungHdrSpace = kSamsungHdrSpaceTicks * kSamsungTick;
+const uint16_t kSamsungBitMarkTicks = 1;
+const uint16_t kSamsungBitMark = kSamsungBitMarkTicks * kSamsungTick;
+const uint16_t kSamsungOneSpaceTicks = 3;
+const uint16_t kSamsungOneSpace = kSamsungOneSpaceTicks * kSamsungTick;
+const uint16_t kSamsungZeroSpaceTicks = 1;
+const uint16_t kSamsungZeroSpace = kSamsungZeroSpaceTicks * kSamsungTick;
+const uint16_t kSamsungRptSpaceTicks = 4;
+const uint16_t kSamsungRptSpace = kSamsungRptSpaceTicks * kSamsungTick;
+const uint16_t kSamsungMinMessageLengthTicks = 193;
+const uint32_t kSamsungMinMessageLength =
+ kSamsungMinMessageLengthTicks * kSamsungTick;
+const uint16_t kSamsungMinGapTicks =
+ kSamsungMinMessageLengthTicks -
+ (kSamsungHdrMarkTicks + kSamsungHdrSpaceTicks +
+ kSamsungBits * (kSamsungBitMarkTicks + kSamsungOneSpaceTicks) +
+ kSamsungBitMarkTicks);
+const uint32_t kSamsungMinGap = kSamsungMinGapTicks * kSamsungTick;
+
+const uint16_t kSamsungAcHdrMark = 690;
+const uint16_t kSamsungAcHdrSpace = 17844;
+const uint8_t kSamsungAcSections = 2;
+const uint16_t kSamsungAcSectionMark = 3086;
+const uint16_t kSamsungAcSectionSpace = 8864;
+const uint16_t kSamsungAcSectionGap = 2886;
+const uint16_t kSamsungAcBitMark = 586;
+const uint16_t kSamsungAcOneSpace = 1432;
+const uint16_t kSamsungAcZeroSpace = 436;
+
+#if SEND_SAMSUNG
+// Send a Samsung formatted message.
+// Samsung has a separate message to indicate a repeat, like NEC does.
+// TODO(crankyoldgit): Confirm that is actually how Samsung sends a repeat.
+// The refdoc doesn't indicate it is true.
+//
+// Args:
+// data: The message to be sent.
+// nbits: The bit size of the message being sent. typically kSamsungBits.
+// repeat: The number of times the message is to be repeated.
+//
+// Status: BETA / Should be working.
+//
+// Ref: http://elektrolab.wz.cz/katalog/samsung_protocol.pdf
+void IRsend::sendSAMSUNG(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ sendGeneric(kSamsungHdrMark, kSamsungHdrSpace, kSamsungBitMark,
+ kSamsungOneSpace, kSamsungBitMark, kSamsungZeroSpace,
+ kSamsungBitMark, kSamsungMinGap, kSamsungMinMessageLength, data,
+ nbits, 38, true, repeat, 33);
+}
+
+// Construct a raw Samsung message from the supplied customer(address) &
+// command.
+//
+// Args:
+// customer: The customer code. (aka. Address)
+// command: The command code.
+// Returns:
+// A raw 32-bit Samsung message suitable for sendSAMSUNG().
+//
+// Status: BETA / Should be working.
+uint32_t IRsend::encodeSAMSUNG(uint8_t customer, uint8_t command) {
+ customer = reverseBits(customer, sizeof(customer) * 8);
+ command = reverseBits(command, sizeof(command) * 8);
+ return ((command ^ 0xFF) | (command << 8) | (customer << 16) |
+ (customer << 24));
+}
+#endif
+
+#if DECODE_SAMSUNG
+// Decode the supplied Samsung message.
+// Samsung messages whilst 32 bits in size, only contain 16 bits of distinct
+// data. e.g. In transmition order:
+// customer_byte + customer_byte(same) + address_byte + invert(address_byte)
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: Nr. of bits to expect in the data portion. Typically kSamsungBits.
+// strict: Flag to indicate if we strictly adhere to the specification.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: STABLE
+//
+// Note:
+// LG 32bit protocol appears near identical to the Samsung protocol.
+// They differ on their compliance criteria and how they repeat.
+// Ref:
+// http://elektrolab.wz.cz/katalog/samsung_protocol.pdf
+bool IRrecv::decodeSAMSUNG(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < 2 * nbits + kHeader + kFooter - 1)
+ return false; // Can't possibly be a valid Samsung message.
+ if (strict && nbits != kSamsungBits)
+ return false; // We expect Samsung to be 32 bits of message.
+
+ uint64_t data = 0;
+ uint16_t offset = kStartOffset;
+
+ // Header
+ if (!matchMark(results->rawbuf[offset], kSamsungHdrMark)) return false;
+ // Calculate how long the common tick time is based on the header mark.
+ uint32_t m_tick = results->rawbuf[offset++] * kRawTick / kSamsungHdrMarkTicks;
+ if (!matchSpace(results->rawbuf[offset], kSamsungHdrSpace)) return false;
+ // Calculate how long the common tick time is based on the header space.
+ uint32_t s_tick =
+ results->rawbuf[offset++] * kRawTick / kSamsungHdrSpaceTicks;
+ // Data
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), nbits,
+ kSamsungBitMarkTicks * m_tick, kSamsungOneSpaceTicks * s_tick,
+ kSamsungBitMarkTicks * m_tick, kSamsungZeroSpaceTicks * s_tick);
+ if (data_result.success == false) return false;
+ data = data_result.data;
+ offset += data_result.used;
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kSamsungBitMarkTicks * m_tick))
+ return false;
+ if (offset < results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset], kSamsungMinGapTicks * s_tick))
+ return false;
+
+ // Compliance
+
+ // According to the spec, the customer (address) code is the first 8
+ // transmitted bits. It's then repeated. Check for that.
+ uint8_t address = data >> 24;
+ if (strict && address != ((data >> 16) & 0xFF)) return false;
+ // Spec says the command code is the 3rd block of transmitted 8-bits,
+ // followed by the inverted command code.
+ uint8_t command = (data & 0xFF00) >> 8;
+ if (strict && command != ((data & 0xFF) ^ 0xFF)) return false;
+
+ // Success
+ results->bits = nbits;
+ results->value = data;
+ results->decode_type = SAMSUNG;
+ // command & address need to be reversed as they are transmitted LSB first,
+ results->command = reverseBits(command, sizeof(command) * 8);
+ results->address = reverseBits(address, sizeof(address) * 8);
+ return true;
+}
+#endif
+
+#if SEND_SAMSUNG_AC
+// Send a Samsung A/C message.
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kSamsungAcStateLength)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: ALPHA / Untested.
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/505
+void IRsend::sendSamsungAC(uint8_t data[], uint16_t nbytes, uint16_t repeat) {
+ if (nbytes < kSamsungAcStateLength && nbytes % kSamsungACSectionLength)
+ return; // Not an appropriate number of bytes to send a proper message.
+
+ enableIROut(38);
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // Header
+ mark(kSamsungAcHdrMark);
+ space(kSamsungAcHdrSpace);
+ // Send in 7 byte sections.
+ for (uint16_t offset = 0; offset < nbytes;
+ offset += kSamsungACSectionLength) {
+ sendGeneric(kSamsungAcSectionMark, kSamsungAcSectionSpace,
+ kSamsungAcBitMark, kSamsungAcOneSpace, kSamsungAcBitMark,
+ kSamsungAcZeroSpace, kSamsungAcBitMark, kSamsungAcSectionGap,
+ data + offset, kSamsungACSectionLength, // 7 bytes == 56 bits
+ 38000, false, 0, 50); // Send in LSBF order
+ }
+ // Complete made up guess at inter-message gap.
+ space(100000 - kSamsungAcSectionGap);
+ }
+}
+#endif // SEND_SAMSUNG_AC
+
+IRSamsungAc::IRSamsungAc(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRSamsungAc::stateReset() {
+ for (uint8_t i = 0; i < kSamsungAcExtendedStateLength; i++)
+ remote_state[i] = 0x0;
+ remote_state[0] = 0x02;
+ remote_state[1] = 0x92;
+ remote_state[2] = 0x0F;
+ remote_state[6] = 0xF0;
+ remote_state[7] = 0x01;
+ remote_state[8] = 0x02;
+ remote_state[9] = 0xAE;
+ remote_state[10] = 0x71;
+ remote_state[12] = 0x15;
+ remote_state[13] = 0xF0;
+}
+
+void IRSamsungAc::begin() { _irsend.begin(); }
+
+uint8_t IRSamsungAc::calcChecksum(const uint8_t state[],
+ const uint16_t length) {
+ uint8_t sum = 0;
+ uint8_t currentbyte;
+ // Safety check so we don't go outside the array.
+ if (length <= 5) return 255;
+ // Shamelessly inspired by:
+ // https://github.com/adafruit/Raw-IR-decoder-for-Arduino/pull/3/files
+ // Count most of the '1' bits after the checksum location.
+ for (uint8_t i = length - 5; i < length - 1; i++) {
+ currentbyte = state[i];
+ if (i == length - 5) currentbyte = state[length - 5] & 0b11111110;
+ for (; currentbyte; currentbyte >>= 1)
+ if (currentbyte & 1) sum++;
+ }
+ return (28 - sum) & 0xF;
+}
+
+bool IRSamsungAc::validChecksum(const uint8_t state[], const uint16_t length) {
+ if (length <= 5) return true; // No checksum to compare with. Assume okay.
+ return (state[length - 6] >> 4) == calcChecksum(state, length);
+}
+
+// Update the checksum for the internal state.
+void IRSamsungAc::checksum(uint16_t length) {
+ if (length < 9) return;
+ remote_state[length - 6] &= 0x0F;
+ remote_state[length - 6] |= (calcChecksum(remote_state, length) << 4);
+}
+
+#if SEND_SAMSUNG_AC
+void IRSamsungAc::send(const bool calcchecksum) {
+ if (calcchecksum) checksum();
+ _irsend.sendSamsungAC(remote_state);
+}
+#endif // SEND_SAMSUNG_AC
+
+#if SEND_SAMSUNG_AC
+void IRSamsungAc::sendExtended(const bool calcchecksum) {
+ if (calcchecksum) checksum();
+ uint8_t extended_state[kSamsungAcExtendedStateLength] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xD2, 0x0F, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+ // Copy/convert the internal state to an extended state.
+ for (uint16_t i = 0; i < kSamsungACSectionLength; i++)
+ extended_state[i] = remote_state[i];
+ for (uint16_t i = kSamsungACSectionLength; i < kSamsungAcStateLength; i++)
+ extended_state[i + kSamsungACSectionLength] = remote_state[i];
+ // Send it.
+ _irsend.sendSamsungAC(extended_state, kSamsungAcExtendedStateLength);
+}
+#endif // SEND_SAMSUNG_AC
+
+uint8_t *IRSamsungAc::getRaw() {
+ checksum();
+ return remote_state;
+}
+
+void IRSamsungAc::setRaw(const uint8_t new_code[], const uint16_t length) {
+ for (uint8_t i = 0; i < length && i < kSamsungAcExtendedStateLength; i++) {
+ remote_state[i] = new_code[i];
+ }
+ // Shrink the extended state into a normal state.
+ if (length > kSamsungAcStateLength) {
+ for (uint8_t i = kSamsungAcStateLength; i < length; i++)
+ remote_state[i - kSamsungACSectionLength] = remote_state[i];
+ }
+}
+
+void IRSamsungAc::on() {
+ remote_state[1] &= ~kSamsungAcPowerMask1;
+ remote_state[6] |= kSamsungAcPowerMask2;
+}
+
+void IRSamsungAc::off() {
+ remote_state[1] |= kSamsungAcPowerMask1;
+ remote_state[6] &= ~kSamsungAcPowerMask2;
+}
+
+void IRSamsungAc::setPower(const bool state) {
+ if (state)
+ on();
+ else
+ off();
+}
+
+bool IRSamsungAc::getPower() {
+ return ((remote_state[6] & kSamsungAcPowerMask2) != 0) &&
+ ((remote_state[1] & kSamsungAcPowerMask1) == 0);
+}
+
+// Set the temp. in deg C
+void IRSamsungAc::setTemp(const uint8_t temp) {
+ uint8_t newtemp = std::max(kSamsungAcMinTemp, temp);
+ newtemp = std::min(kSamsungAcMaxTemp, newtemp);
+ remote_state[11] = (remote_state[11] & ~kSamsungAcTempMask) |
+ ((newtemp - kSamsungAcMinTemp) << 4);
+}
+
+// Return the set temp. in deg C
+uint8_t IRSamsungAc::getTemp() {
+ return ((remote_state[11] & kSamsungAcTempMask) >> 4) + kSamsungAcMinTemp;
+}
+
+void IRSamsungAc::setMode(const uint8_t mode) {
+ // If we get an unexpected mode, default to AUTO.
+ uint8_t newmode = mode;
+ if (newmode > kSamsungAcHeat) newmode = kSamsungAcAuto;
+ remote_state[12] = (remote_state[12] & ~kSamsungAcModeMask) | (newmode << 4);
+
+ // Auto mode has a special fan setting valid only in auto mode.
+ if (newmode == kSamsungAcAuto) {
+ setFan(kSamsungAcFanAuto2);
+ } else {
+ if (getFan() == kSamsungAcFanAuto2) // Non-Auto can't have this fan setting
+ setFan(kSamsungAcFanAuto); // Default to something safe.
+ }
+}
+
+uint8_t IRSamsungAc::getMode() {
+ return (remote_state[12] & kSamsungAcModeMask) >> 4;
+}
+
+void IRSamsungAc::setFan(const uint8_t speed) {
+ switch (speed) {
+ case kSamsungAcFanAuto:
+ case kSamsungAcFanLow:
+ case kSamsungAcFanMed:
+ case kSamsungAcFanHigh:
+ case kSamsungAcFanTurbo:
+ if (getMode() == kSamsungAcAuto) return; // Not valid in Auto mode.
+ break;
+ case kSamsungAcFanAuto2: // Special fan setting for when in Auto mode.
+ if (getMode() != kSamsungAcAuto) return;
+ break;
+ default:
+ return;
+ }
+ remote_state[12] = (remote_state[12] & ~kSamsungAcFanMask) | (speed << 1);
+}
+
+uint8_t IRSamsungAc::getFan() {
+ return ((remote_state[12] & kSamsungAcFanMask) >> 1);
+}
+
+bool IRSamsungAc::getSwing() {
+ // TODO(Hollako): Explain why sometimes the LSB of remote_state[9] is a 1.
+ // e.g. 0xAE or 0XAF for swing move.
+ return ((remote_state[9] & kSamsungAcSwingMask) >> 4) == kSamsungAcSwingMove;
+}
+
+void IRSamsungAc::setSwing(const bool state) {
+ // TODO(Hollako): Explain why sometimes the LSB of remote_state[9] is a 1.
+ // e.g. 0xAE or 0XAF for swing move.
+ remote_state[9] &= ~kSamsungAcSwingMask; // Clear the previous swing state.
+ if (state)
+ remote_state[9] |= (kSamsungAcSwingMove << 4);
+ else
+ remote_state[9] |= (kSamsungAcSwingStop << 4);
+}
+
+bool IRSamsungAc::getBeep() { return remote_state[13] & kSamsungAcBeepMask; }
+
+void IRSamsungAc::setBeep(const bool state) {
+ if (state)
+ remote_state[13] |= kSamsungAcBeepMask;
+ else
+ remote_state[13] &= ~kSamsungAcBeepMask;
+}
+
+bool IRSamsungAc::getClean() {
+ return (remote_state[10] & kSamsungAcCleanMask10) &&
+ (remote_state[11] & kSamsungAcCleanMask11);
+}
+
+void IRSamsungAc::setClean(const bool state) {
+ if (state) {
+ remote_state[10] |= kSamsungAcCleanMask10;
+ remote_state[11] |= kSamsungAcCleanMask11;
+ } else {
+ remote_state[10] &= ~kSamsungAcCleanMask10;
+ remote_state[11] &= ~kSamsungAcCleanMask11;
+ }
+}
+
+// Very unsure this is correct.
+bool IRSamsungAc::getQuiet() {
+ return remote_state[11] & kSamsungAcQuietMask11;
+}
+
+// Very unsure this is correct.
+void IRSamsungAc::setQuiet(const bool state) {
+ if (state) {
+ remote_state[11] |= kSamsungAcQuietMask11;
+ setFan(kSamsungAcFanAuto); // Quiet mode seems to set fan speed to auto.
+ } else {
+ remote_state[11] &= ~kSamsungAcQuietMask11;
+ }
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRSamsungAc::toString() {
+ String result = "";
+#else
+std::string IRSamsungAc::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kSamsungAcAuto:
+ result += " (AUTO)";
+ break;
+ case kSamsungAcCool:
+ result += " (COOL)";
+ break;
+ case kSamsungAcHeat:
+ result += " (HEAT)";
+ break;
+ case kSamsungAcDry:
+ result += " (DRY)";
+ break;
+ case kSamsungAcFan:
+ result += " (FAN)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kSamsungAcFanAuto:
+ case kSamsungAcFanAuto2:
+ result += " (AUTO)";
+ break;
+ case kSamsungAcFanLow:
+ result += " (LOW)";
+ break;
+ case kSamsungAcFanMed:
+ result += " (MED)";
+ break;
+ case kSamsungAcFanHigh:
+ result += " (HIGH)";
+ break;
+ case kSamsungAcFanTurbo:
+ result += " (TURBO)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ break;
+ }
+ result += ", Swing: ";
+ if (getSwing())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Beep: ";
+ if (getBeep())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Clean: ";
+ if (getBeep())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Quiet: ";
+ if (getQuiet())
+ result += "On";
+ else
+ result += "Off";
+ return result;
+}
+
+#if DECODE_SAMSUNG_AC
+// Decode the supplied Samsung A/C message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kSamsungAcBits
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Appears to mostly work.
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/505
+bool IRrecv::decodeSamsungAC(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < 2 * nbits + kHeader * 3 + kFooter * 2 - 1)
+ return false; // Can't possibly be a valid Samsung A/C message.
+ if (nbits != kSamsungAcBits && nbits != kSamsungAcExtendedBits) return false;
+
+ uint16_t offset = kStartOffset;
+ uint16_t dataBitsSoFar = 0;
+ match_result_t data_result;
+
+ // Message Header
+ if (!matchMark(results->rawbuf[offset++], kSamsungAcBitMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kSamsungAcHdrSpace)) return false;
+ // Section(s)
+ for (uint16_t pos = kSamsungACSectionLength, i = 0; pos <= nbits / 8;
+ pos += kSamsungACSectionLength) {
+ uint64_t sectiondata = 0;
+ // Section Header
+ if (!matchMark(results->rawbuf[offset++], kSamsungAcSectionMark))
+ return false;
+ if (!matchSpace(results->rawbuf[offset++], kSamsungAcSectionSpace))
+ return false;
+ // Section Data
+ // Keep reading bytes until we either run out of section or state to fill.
+ for (; offset <= results->rawlen - 16 && i < pos;
+ i++, dataBitsSoFar += 8, offset += data_result.used) {
+ data_result = matchData(&(results->rawbuf[offset]), 8, kSamsungAcBitMark,
+ kSamsungAcOneSpace, kSamsungAcBitMark,
+ kSamsungAcZeroSpace, kTolerance, 0, false);
+ if (data_result.success == false) {
+ DPRINT("DEBUG: offset = ");
+ DPRINTLN(offset + data_result.used);
+ return false; // Fail
+ }
+ results->state[i] = data_result.data;
+ sectiondata = (sectiondata << 8) + data_result.data;
+ }
+ DPRINTLN("DEBUG: sectiondata = 0x" + uint64ToString(sectiondata, 16));
+ // Section Footer
+ if (!matchMark(results->rawbuf[offset++], kSamsungAcBitMark)) return false;
+ if (pos < nbits / 8) { // Inter-section gap.
+ if (!matchSpace(results->rawbuf[offset++], kSamsungAcSectionGap))
+ return false;
+ } else { // Last section / End of message gap.
+ if (offset <= results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kSamsungAcSectionGap))
+ return false;
+ }
+ }
+ // Compliance
+ // Re-check we got the correct size/length due to the way we read the data.
+ if (dataBitsSoFar != nbits) return false;
+ // Is the signature correct?
+ DPRINTLN("DEBUG: Checking signature.");
+ if (results->state[0] != 0x02 || results->state[2] != 0x0F) return false;
+ if (results->state[1] != 0x92 && results->state[1] != 0xB2) return false;
+ if (strict) {
+ // Is the checksum valid?
+ if (!IRSamsungAc::validChecksum(results->state, nbits / 8)) {
+ DPRINTLN("DEBUG: Checksum failed!");
+ return false;
+ }
+ }
+ // Success
+ results->decode_type = SAMSUNG_AC;
+ results->bits = dataBitsSoFar;
+ // No need to record the state as we stored it as we decoded it.
+ // As we use result->state, we don't record value, address, or command as it
+ // is a union data type.
+ return true;
+}
+#endif // DECODE_SAMSUNG_AC
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Samsung.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Samsung.h
new file mode 100644
index 000000000000..f80b47d20baf
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Samsung.h
@@ -0,0 +1,107 @@
+// Samsung A/C
+//
+// Copyright 2018 David Conran
+
+#ifndef IR_SAMSUNG_H_
+#define IR_SAMSUNG_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifndef UNIT_TEST
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// SSSS AAA MMM SSSS U U N N GGGG
+// S A A M M M S U U NN N G
+// SSS AAAAA M M M SSS U U N N N G GG
+// S A A M M S U U N NN G G
+// SSSS A A M M SSSS UUU N N GGG
+
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/505
+
+// Constants
+const uint8_t kSamsungAcAuto = 0;
+const uint8_t kSamsungAcCool = 1;
+const uint8_t kSamsungAcDry = 2;
+const uint8_t kSamsungAcFan = 3;
+const uint8_t kSamsungAcHeat = 4;
+const uint8_t kSamsungAcModeMask = 0x70;
+const uint8_t kSamsungAcFanAuto = 0;
+const uint8_t kSamsungAcFanLow = 2;
+const uint8_t kSamsungAcFanMed = 4;
+const uint8_t kSamsungAcFanHigh = 5;
+const uint8_t kSamsungAcFanAuto2 = 6;
+const uint8_t kSamsungAcFanTurbo = 7;
+const uint8_t kSamsungAcMinTemp = 16; // 16C
+const uint8_t kSamsungAcMaxTemp = 30; // 30C
+const uint8_t kSamsungAcAutoTemp = 25; // 25C
+const uint8_t kSamsungAcTempMask = 0xF0;
+const uint8_t kSamsungAcPowerMask1 = 0x20;
+const uint8_t kSamsungAcPowerMask2 = 0x30;
+const uint8_t kSamsungAcFanMask = 0x0E;
+const uint8_t kSamsungAcSwingMask = 0x70;
+const uint8_t kSamsungAcSwingMove = 0b010;
+const uint8_t kSamsungAcSwingStop = 0b111;
+const uint8_t kSamsungAcBeepMask = 0x02;
+const uint8_t kSamsungAcCleanMask10 = 0x80;
+const uint8_t kSamsungAcCleanMask11 = 0x02;
+const uint8_t kSamsungAcQuietMask11 = 0x01;
+
+const uint16_t kSamsungACSectionLength = 7;
+const uint64_t kSamsungAcPowerSection = 0x1D20F00000000;
+
+// Classes
+class IRSamsungAc {
+ public:
+ explicit IRSamsungAc(uint16_t pin);
+
+ void stateReset();
+#if SEND_SAMSUNG_AC
+ void send(const bool calcchecksum = true);
+ void sendExtended(const bool calcchecksum = true);
+#endif // SEND_SAMSUNG_AC
+ void begin();
+ void on();
+ void off();
+ void setPower(const bool state);
+ bool getPower();
+ void setTemp(const uint8_t temp);
+ uint8_t getTemp();
+ void setFan(const uint8_t speed);
+ uint8_t getFan();
+ void setMode(const uint8_t mode);
+ uint8_t getMode();
+ void setSwing(const bool state);
+ bool getSwing();
+ void setBeep(const bool state);
+ bool getBeep();
+ void setClean(const bool state);
+ bool getClean();
+ void setQuiet(const bool state);
+ bool getQuiet();
+ uint8_t* getRaw();
+ void setRaw(const uint8_t new_code[],
+ const uint16_t length = kSamsungAcStateLength);
+ static bool validChecksum(const uint8_t state[],
+ const uint16_t length = kSamsungAcStateLength);
+ static uint8_t calcChecksum(const uint8_t state[],
+ const uint16_t length = kSamsungAcStateLength);
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
+
+ private:
+ // The state of the IR remote in IR code form.
+ uint8_t remote_state[kSamsungAcExtendedStateLength];
+ void checksum(const uint16_t length = kSamsungAcStateLength);
+ IRsend _irsend;
+};
+
+#endif // IR_SAMSUNG_H_
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Sanyo.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Sanyo.cpp
similarity index 70%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Sanyo.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Sanyo.cpp
index cbb13a3291df..b2b4d7830ece 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Sanyo.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Sanyo.cpp
@@ -5,7 +5,6 @@
#include
#include "IRrecv.h"
#include "IRsend.h"
-#include "IRtimer.h"
// SSSS AAA N N Y Y OOO
// S A A NN N Y Y O O
@@ -21,31 +20,35 @@
// Sanyo SA 8650B
// Ref:
// https://github.com/z3t0/Arduino-IRremote/blob/master/ir_Sanyo.cpp
-#define SANYO_SA8650B_HDR_MARK 3500U // seen range 3500
-#define SANYO_SA8650B_HDR_SPACE 950U // seen 950
-#define SANYO_SA8650B_ONE_MARK 2400U // seen 2400
-#define SANYO_SA8650B_ZERO_MARK 700U // seen 700
+
+const uint16_t kSanyoSa8650bHdrMark = 3500; // seen range 3500
+const uint16_t kSanyoSa8650bHdrSpace = 950; // seen 950
+const uint16_t kSanyoSa8650bOneMark = 2400; // seen 2400
+const uint16_t kSanyoSa8650bZeroMark = 700; // seen 700
// usually see 713 - not using ticks as get number wrapround
-#define SANYO_SA8650B_DOUBLE_SPACE_USECS 800U
-#define SANYO_SA8650B_RPT_LENGTH 45000U
+const uint16_t kSanyoSa8650bDoubleSpaceUsecs = 800;
+const uint16_t kSanyoSa8650bRptLength = 45000;
// Sanyo LC7461
// Ref:
// https://github.com/marcosamarinho/IRremoteESP8266/blob/master/ir_Sanyo.cpp
// http://slydiman.narod.ru/scr/kb/sanyo.htm
// http://pdf.datasheetcatalog.com/datasheet/sanyo/LC7461.pdf
-#define SANYO_LC7461_ADDRESS_MASK ((1 << SANYO_LC7461_ADDRESS_BITS) - 1)
-#define SANYO_LC7461_COMMAND_MASK ((1 << SANYO_LC7461_COMMAND_BITS) - 1)
-#define SANYO_LC7461_HDR_MARK 9000U
-#define SANYO_LC7461_HDR_SPACE 4500U
-#define SANYO_LC7461_BIT_MARK 560U // 1T
-#define SANYO_LC7461_ONE_SPACE 1690U // 3T
-#define SANYO_LC7461_ZERO_SPACE 560U // 1T
-#define SANYO_LC7461_MIN_COMMAND_LENGTH 108000UL
-#define SANYO_LC7461_MIN_GAP SANYO_LC7461_MIN_COMMAND_LENGTH - \
- (SANYO_LC7461_HDR_MARK + SANYO_LC7461_HDR_SPACE + SANYO_LC7461_BITS * \
- (SANYO_LC7461_BIT_MARK + (SANYO_LC7461_ONE_SPACE + \
- SANYO_LC7461_ZERO_SPACE) / 2) \
- + SANYO_LC7461_BIT_MARK)
+
+const uint16_t kSanyoLc7461AddressMask = (1 << kSanyoLC7461AddressBits) - 1;
+const uint16_t kSanyoLc7461CommandMask = (1 << kSanyoLC7461CommandBits) - 1;
+const uint16_t kSanyoLc7461HdrMark = 9000;
+const uint16_t kSanyoLc7461HdrSpace = 4500;
+const uint16_t kSanyoLc7461BitMark = 560; // 1T
+const uint16_t kSanyoLc7461OneSpace = 1690; // 3T
+const uint16_t kSanyoLc7461ZeroSpace = 560; // 1T
+const uint32_t kSanyoLc7461MinCommandLength = 108000;
+
+const uint16_t kSanyoLc7461MinGap =
+ kSanyoLc7461MinCommandLength -
+ (kSanyoLc7461HdrMark + kSanyoLc7461HdrSpace +
+ kSanyoLC7461Bits * (kSanyoLc7461BitMark +
+ (kSanyoLc7461OneSpace + kSanyoLc7461ZeroSpace) / 2) +
+ kSanyoLc7461BitMark);
#if SEND_SANYO
// Construct a Sanyo LC7461 message.
@@ -62,18 +65,18 @@
// According with LIRC, this protocol is used on Sanyo, Aiwa and Chinon
uint64_t IRsend::encodeSanyoLC7461(uint16_t address, uint8_t command) {
// Mask our input values to ensure the correct bit sizes.
- address &= SANYO_LC7461_ADDRESS_MASK;
- command &= SANYO_LC7461_COMMAND_MASK;
+ address &= kSanyoLc7461AddressMask;
+ command &= kSanyoLc7461CommandMask;
uint64_t data = address;
- address ^= SANYO_LC7461_ADDRESS_MASK; // Invert the 13 LSBs.
+ address ^= kSanyoLc7461AddressMask; // Invert the 13 LSBs.
// Append the now inverted address.
- data = (data << SANYO_LC7461_ADDRESS_BITS) | address;
+ data = (data << kSanyoLC7461AddressBits) | address;
// Append the command.
- data = (data << SANYO_LC7461_COMMAND_BITS) | command;
- command ^= SANYO_LC7461_COMMAND_MASK; // Invert the command.
+ data = (data << kSanyoLC7461CommandBits) | command;
+ command ^= kSanyoLc7461CommandMask; // Invert the command.
// Append the now inverted command.
- data = (data << SANYO_LC7461_COMMAND_BITS) | command;
+ data = (data << kSanyoLC7461CommandBits) | command;
return data;
}
@@ -128,31 +131,30 @@ void IRsend::sendSanyoLC7461(uint64_t data, uint16_t nbits, uint16_t repeat) {
// http://pdf.datasheetcatalog.com/datasheet/sanyo/LC7461.pdf
bool IRrecv::decodeSanyoLC7461(decode_results *results, uint16_t nbits,
bool strict) {
- if (strict && nbits != SANYO_LC7461_BITS)
+ if (strict && nbits != kSanyoLC7461Bits)
return false; // Not strictly in spec.
// This protocol is basically a 42-bit variant of the NEC protocol.
if (!decodeNEC(results, nbits, false))
return false; // Didn't match a NEC format (without strict)
// Bits 30 to 42+.
- uint16_t address = results->value >> (SANYO_LC7461_BITS -
- SANYO_LC7461_ADDRESS_BITS);
+ uint16_t address =
+ results->value >> (kSanyoLC7461Bits - kSanyoLC7461AddressBits);
// Bits 9 to 16.
- uint8_t command = (results->value >> SANYO_LC7461_COMMAND_BITS) &
- SANYO_LC7461_COMMAND_MASK;
+ uint8_t command =
+ (results->value >> kSanyoLC7461CommandBits) & kSanyoLc7461CommandMask;
// Compliance
if (strict) {
- if (results->bits != nbits)
- return false;
+ if (results->bits != nbits) return false;
// Bits 17 to 29.
uint16_t inverted_address =
- (results->value >> (SANYO_LC7461_COMMAND_BITS * 2)) &
- SANYO_LC7461_ADDRESS_MASK;
+ (results->value >> (kSanyoLC7461CommandBits * 2)) &
+ kSanyoLc7461AddressMask;
// Bits 1-8.
- uint8_t inverted_command = results->value & SANYO_LC7461_COMMAND_MASK;
- if ((address ^ SANYO_LC7461_ADDRESS_MASK) != inverted_address)
+ uint8_t inverted_command = results->value & kSanyoLc7461CommandMask;
+ if ((address ^ kSanyoLc7461AddressMask) != inverted_address)
return false; // Address integrity check failed.
- if ((command ^ SANYO_LC7461_COMMAND_MASK) != inverted_command)
+ if ((command ^ kSanyoLc7461CommandMask) != inverted_command)
return false; // Command integrity check failed.
}
@@ -183,9 +185,9 @@ bool IRrecv::decodeSanyoLC7461(decode_results *results, uint16_t nbits,
// Ref:
// https://github.com/z3t0/Arduino-IRremote/blob/master/ir_Sanyo.cpp
bool IRrecv::decodeSanyo(decode_results *results, uint16_t nbits, bool strict) {
- if (results->rawlen < 2 * nbits + HEADER - 1)
+ if (results->rawlen < 2 * nbits + kHeader - 1)
return false; // Shorter than shortest possible.
- if (strict && nbits != SANYO_SA8650B_BITS)
+ if (strict && nbits != kSanyoSA8650BBits)
return false; // Doesn't match the spec.
uint16_t offset = 0;
@@ -193,9 +195,9 @@ bool IRrecv::decodeSanyo(decode_results *results, uint16_t nbits, bool strict) {
// TODO(crankyoldgit): This repeat code looks like garbage, it should never
// match or if it does, it won't be reliable. We should probably just
// remove it.
- if (results->rawbuf[offset++] < SANYO_SA8650B_DOUBLE_SPACE_USECS) {
+ if (results->rawbuf[offset++] < kSanyoSa8650bDoubleSpaceUsecs) {
results->bits = 0;
- results->value = REPEAT;
+ results->value = kRepeat;
results->decode_type = SANYO;
results->address = 0;
results->command = 0;
@@ -204,27 +206,27 @@ bool IRrecv::decodeSanyo(decode_results *results, uint16_t nbits, bool strict) {
}
// Header
- if (!matchMark(results->rawbuf[offset++], SANYO_SA8650B_HDR_MARK))
+ if (!matchMark(results->rawbuf[offset++], kSanyoSa8650bHdrMark))
return false;
// NOTE: These next two lines look very wrong. Treat as suspect.
- if (!matchMark(results->rawbuf[offset++], SANYO_SA8650B_HDR_MARK))
+ if (!matchMark(results->rawbuf[offset++], kSanyoSa8650bHdrMark))
return false;
// Data
uint64_t data = 0;
while (offset + 1 < results->rawlen) {
- if (!matchSpace(results->rawbuf[offset], SANYO_SA8650B_HDR_SPACE))
+ if (!matchSpace(results->rawbuf[offset], kSanyoSa8650bHdrSpace))
break;
offset++;
- if (matchMark(results->rawbuf[offset], SANYO_SA8650B_ONE_MARK))
+ if (matchMark(results->rawbuf[offset], kSanyoSa8650bOneMark))
data = (data << 1) | 1; // 1
- else if (matchMark(results->rawbuf[offset], SANYO_SA8650B_ZERO_MARK))
+ else if (matchMark(results->rawbuf[offset], kSanyoSa8650bZeroMark))
data <<= 1; // 0
else
return false;
offset++;
}
- if (strict && SANYO_SA8650B_BITS > (offset - 1U) / 2U)
+ if (strict && kSanyoSA8650BBits > (offset - 1U) / 2U)
return false;
// Success
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Sharp.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Sharp.cpp
similarity index 68%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Sharp.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Sharp.cpp
index 1a0bb35569ee..ae1b59c74d51 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Sharp.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Sharp.cpp
@@ -4,7 +4,6 @@
#include
#include "IRrecv.h"
#include "IRsend.h"
-#include "IRtimer.h"
#include "IRutils.h"
// SSSS H H AAA RRRR PPPP
@@ -13,32 +12,37 @@
// S H H A A R R P
// SSSS H H A A R R P
+// Equipment it seems compatible with:
+// * Sharp LC-52D62U
+// *
+//
+
// Constants
// period time = 1/38000Hz = 26.316 microseconds.
// Ref:
// GlobalCache's IR Control Tower data.
// http://www.sbprojects.com/knowledge/ir/sharp.php
-#define SHARP_TICK 26U
-#define SHARP_BIT_MARK_TICKS 10U
-#define SHARP_BIT_MARK (SHARP_BIT_MARK_TICKS * SHARP_TICK)
-#define SHARP_ONE_SPACE_TICKS 70U
-#define SHARP_ONE_SPACE (SHARP_ONE_SPACE_TICKS * SHARP_TICK)
-#define SHARP_ZERO_SPACE_TICKS 30U
-#define SHARP_ZERO_SPACE (SHARP_ZERO_SPACE_TICKS * SHARP_TICK)
-#define SHARP_GAP_TICKS 1677U
-#define SHARP_GAP (SHARP_GAP_TICKS * SHARP_TICK)
-
+const uint16_t kSharpTick = 26;
+const uint16_t kSharpBitMarkTicks = 10;
+const uint16_t kSharpBitMark = kSharpBitMarkTicks * kSharpTick;
+const uint16_t kSharpOneSpaceTicks = 70;
+const uint16_t kSharpOneSpace = kSharpOneSpaceTicks * kSharpTick;
+const uint16_t kSharpZeroSpaceTicks = 30;
+const uint16_t kSharpZeroSpace = kSharpZeroSpaceTicks * kSharpTick;
+const uint16_t kSharpGapTicks = 1677;
+const uint16_t kSharpGap = kSharpGapTicks * kSharpTick;
// Address(5) + Command(8) + Expansion(1) + Check(1)
-#define SHARP_TOGGLE_MASK ((1 << (SHARP_BITS - SHARP_ADDRESS_BITS)) - 1)
-#define SHARP_ADDRESS_MASK ((1 << SHARP_ADDRESS_BITS) - 1)
-#define SHARP_COMMAND_MASK ((1 << SHARP_COMMAND_BITS) - 1)
+const uint64_t kSharpToggleMask =
+ ((uint64_t)1 << (kSharpBits - kSharpAddressBits)) - 1;
+const uint64_t kSharpAddressMask = ((uint64_t)1 << kSharpAddressBits) - 1;
+const uint64_t kSharpCommandMask = ((uint64_t)1 << kSharpCommandBits) - 1;
#if (SEND_SHARP || SEND_DENON)
// Send a (raw) Sharp message
//
// Args:
// data: Contents of the message to be sent.
-// nbits: Nr. of bits of data to be sent. Typically SHARP_BITS.
+// nbits: Nr. of bits of data to be sent. Typically kSharpBits.
// repeat: Nr. of additional times the message is to be sent.
//
// Status: BETA / Previously working fine.
@@ -56,28 +60,20 @@
// http://www.mwftr.com/ucF08/LEC14%20PIC%20IR.pdf
// http://www.hifi-remote.com/johnsfine/DecodeIR.html#Sharp
void IRsend::sendSharpRaw(uint64_t data, uint16_t nbits, uint16_t repeat) {
- // Set 38kHz IR carrier frequency & a 1/3 (33%) duty cycle.
- enableIROut(38, 33);
-
for (uint16_t i = 0; i <= repeat; i++) {
// Protocol demands that the data be sent twice; once normally,
// then with all but the address bits inverted.
// Note: Previously this used to be performed 3 times (normal, inverted,
// normal), however all data points to that being incorrect.
for (uint8_t n = 0; n < 2; n++) {
- // No Header
-
- // Data
- sendData(SHARP_BIT_MARK, SHARP_ONE_SPACE,
- SHARP_BIT_MARK, SHARP_ZERO_SPACE,
- data, nbits, true);
- // Footer
- mark(SHARP_BIT_MARK);
- space(SHARP_GAP);
-
+ sendGeneric(0, 0, // No Header
+ kSharpBitMark, kSharpOneSpace, kSharpBitMark, kSharpZeroSpace,
+ kSharpBitMark, kSharpGap, data, nbits, 38, true,
+ 0, // Repeats are handled already.
+ 33);
// Invert the data per protocol. This is always called twice, so it's
// retured to original upon exiting the inner loop.
- data ^= SHARP_TOGGLE_MASK;
+ data ^= kSharpToggleMask;
}
}
}
@@ -110,17 +106,17 @@ uint32_t IRsend::encodeSharp(uint16_t address, uint16_t command,
uint16_t expansion, uint16_t check,
bool MSBfirst) {
// Mask any unexpected bits.
- address &= ((1 << SHARP_ADDRESS_BITS) - 1);
- command &= ((1 << SHARP_COMMAND_BITS) - 1);
+ address &= ((1 << kSharpAddressBits) - 1);
+ command &= ((1 << kSharpCommandBits) - 1);
expansion &= 1;
check &= 1;
if (!MSBfirst) { // Correct bit order if needed.
- address = reverseBits(address, SHARP_ADDRESS_BITS);
- command = reverseBits(command, SHARP_COMMAND_BITS);
+ address = reverseBits(address, kSharpAddressBits);
+ command = reverseBits(command, kSharpCommandBits);
}
// Concatinate all the bits.
- return (address << (SHARP_COMMAND_BITS + 2)) | (command << 2) |
+ return (address << (kSharpCommandBits + 2)) | (command << 2) |
(expansion << 1) | check;
}
@@ -129,7 +125,7 @@ uint32_t IRsend::encodeSharp(uint16_t address, uint16_t command,
// Args:
// address: Address value to be sent.
// command: Command value to be sent.
-// nbits: Nr. of bits of data to be sent. Typically SHARP_BITS.
+// nbits: Nr. of bits of data to be sent. Typically kSharpBits.
// repeat: Nr. of additional times the message is to be sent.
//
// Status: DEPRICATED / Previously working fine.
@@ -159,13 +155,13 @@ void IRsend::sendSharp(uint16_t address, uint16_t command, uint16_t nbits,
//
// Args:
// results: Ptr to the data to decode and where to store the decode result.
-// nbits: Nr. of data bits to expect. Typically SHARP_BITS.
+// nbits: Nr. of data bits to expect. Typically kSharpBits.
// strict: Flag indicating if we should perform strict matching.
// expansion: Should we expect the expansion bit to be set. Default is true.
// Returns:
// boolean: True if it can decode it, false if it can't.
//
-// Status: BETA / Should work okay.
+// Status: STABLE / Working fine.
//
// Note:
// This procedure returns a value suitable for use in sendSharpRaw().
@@ -178,90 +174,83 @@ void IRsend::sendSharp(uint16_t address, uint16_t command, uint16_t nbits,
// http://www.hifi-remote.com/johnsfine/DecodeIR.html#Sharp
bool IRrecv::decodeSharp(decode_results *results, uint16_t nbits, bool strict,
bool expansion) {
- if (results->rawlen < 2 * nbits + FOOTER - 1)
+ if (results->rawlen < 2 * nbits + kFooter - 1)
return false; // Not enough entries to be a Sharp message.
// Compliance
if (strict) {
- if (nbits != SHARP_BITS)
- return false; // Request is out of spec.
+ if (nbits != kSharpBits) return false; // Request is out of spec.
// DISABLED - See TODO
#ifdef UNIT_TEST
// An in spec message has the data sent normally, then inverted. So we
// expect twice as many entries than to just get the results.
- if (results->rawlen < 2 * (2 * nbits + FOOTER))
- return false;
+ if (results->rawlen < 2 * (2 * nbits + kFooter)) return false;
#endif
}
uint64_t data = 0;
- uint16_t offset = OFFSET_START;
+ uint16_t offset = kStartOffset;
// No header
// But try to auto-calibrate off the initial mark signal.
- if (!matchMark(results->rawbuf[offset], SHARP_BIT_MARK, 35)) return false;
+ if (!matchMark(results->rawbuf[offset], kSharpBitMark, 35)) return false;
// Calculate how long the common tick time is based on the header mark.
- uint32_t tick = results->rawbuf[offset] * RAWTICK / SHARP_BIT_MARK_TICKS;
+ uint32_t tick = results->rawbuf[offset] * kRawTick / kSharpBitMarkTicks;
// Data
for (uint16_t i = 0; i < nbits; i++, offset++) {
- // Use a higher tolerance value for SHARP_BIT_MARK as it is quite small.
- if (!matchMark(results->rawbuf[offset++], SHARP_BIT_MARK_TICKS * tick, 35))
+ // Use a higher tolerance value for kSharpBitMark as it is quite small.
+ if (!matchMark(results->rawbuf[offset++], kSharpBitMarkTicks * tick, 35))
return false;
- if (matchSpace(results->rawbuf[offset], SHARP_ONE_SPACE_TICKS * tick))
+ if (matchSpace(results->rawbuf[offset], kSharpOneSpaceTicks * tick))
data = (data << 1) | 1; // 1
- else if (matchSpace(results->rawbuf[offset], SHARP_ZERO_SPACE_TICKS * tick))
+ else if (matchSpace(results->rawbuf[offset], kSharpZeroSpaceTicks * tick))
data <<= 1; // 0
else
return false;
}
// Footer
- if (!match(results->rawbuf[offset++], SHARP_BIT_MARK_TICKS * tick))
+ if (!match(results->rawbuf[offset++], kSharpBitMarkTicks * tick))
return false;
if (offset < results->rawlen &&
- !matchAtLeast(results->rawbuf[offset], SHARP_GAP_TICKS * tick))
+ !matchAtLeast(results->rawbuf[offset], kSharpGapTicks * tick))
return false;
// Compliance
if (strict) {
// Check the state of the expansion bit is what we expect.
- if ((data & 0b10) >> 1 != expansion)
- return false;
+ if ((data & 0b10) >> 1 != expansion) return false;
// The check bit should be cleared in a normal message.
- if (data & 0b1)
- return false;
- // DISABLED - See TODO
+ if (data & 0b1) return false;
+ // DISABLED - See TODO
#ifdef UNIT_TEST
// Grab the second copy of the data (i.e. inverted)
// Header
// i.e. The inter-data/command repeat gap.
- if (!matchSpace(results->rawbuf[offset++], SHARP_GAP_TICKS * tick))
+ if (!matchSpace(results->rawbuf[offset++], kSharpGapTicks * tick))
return false;
// Data
uint64_t second_data = 0;
for (uint16_t i = 0; i < nbits; i++, offset++) {
- // Use a higher tolerance value for SHARP_BIT_MARK as it is quite small.
- if (!matchMark(results->rawbuf[offset++], SHARP_BIT_MARK_TICKS * tick,
- 35))
+ // Use a higher tolerance value for kSharpBitMark as it is quite small.
+ if (!matchMark(results->rawbuf[offset++], kSharpBitMarkTicks * tick, 35))
return false;
- if (matchSpace(results->rawbuf[offset], SHARP_ONE_SPACE_TICKS * tick))
+ if (matchSpace(results->rawbuf[offset], kSharpOneSpaceTicks * tick))
second_data = (second_data << 1) | 1; // 1
- else if (matchSpace(results->rawbuf[offset],
- SHARP_ZERO_SPACE_TICKS * tick))
+ else if (matchSpace(results->rawbuf[offset], kSharpZeroSpaceTicks * tick))
second_data <<= 1; // 0
else
return false;
}
// Footer
- if (!match(results->rawbuf[offset++], SHARP_BIT_MARK_TICKS * tick))
+ if (!match(results->rawbuf[offset++], kSharpBitMarkTicks * tick))
return false;
if (offset < results->rawlen &&
- !matchAtLeast(results->rawbuf[offset], SHARP_GAP_TICKS * tick))
+ !matchAtLeast(results->rawbuf[offset], kSharpGapTicks * tick))
return false;
// Check that second_data has been inverted correctly.
- if (data != (second_data ^ SHARP_TOGGLE_MASK))
- return false;
+ if (data != (second_data ^ kSharpToggleMask)) return false;
#endif // UNIT_TEST
}
@@ -270,9 +259,9 @@ bool IRrecv::decodeSharp(decode_results *results, uint16_t nbits, bool strict,
results->bits = nbits;
results->value = data;
// Address & command are actually transmitted in LSB first order.
- results->address = reverseBits(data, nbits) & SHARP_ADDRESS_MASK;
- results->command = reverseBits((data >> 2) & SHARP_COMMAND_MASK,
- SHARP_COMMAND_BITS);
+ results->address = reverseBits(data, nbits) & kSharpAddressMask;
+ results->command =
+ reverseBits((data >> 2) & kSharpCommandMask, kSharpCommandBits);
return true;
}
#endif // (DECODE_SHARP || DECODE_DENON)
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Sherwood.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Sherwood.cpp
similarity index 71%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Sherwood.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Sherwood.cpp
index 97e75067a8ac..8af7dfb349a2 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Sherwood.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Sherwood.cpp
@@ -14,16 +14,15 @@
//
// Args:
// data: The contents of the command you want to send.
-// nbits: The bit size of the command being sent. (SHERWOOD_BITS)
+// nbits: The bit size of the command being sent. (kSherwoodBits)
// repeat: The nr. of times you want the command to be repeated. (Default: 1)
//
// Status: STABLE / Known working.
//
// Note:
// Sherwood remote codes appear to be NEC codes with a manditory repeat code.
-// i.e. repeat should be >= SHERWOOD_MIN_REPEAT (1).
-void IRsend::sendSherwood(uint64_t data, uint16_t nbits,
- uint16_t repeat) {
- sendNEC(data, nbits, std::max((uint16_t) SHERWOOD_MIN_REPEAT, repeat));
+// i.e. repeat should be >= kSherwoodMinRepeat (1).
+void IRsend::sendSherwood(uint64_t data, uint16_t nbits, uint16_t repeat) {
+ sendNEC(data, nbits, std::max((uint16_t)kSherwoodMinRepeat, repeat));
}
#endif
diff --git a/lib/IRremoteESP8266-2.2.1.02/src/ir_Sony.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Sony.cpp
similarity index 62%
rename from lib/IRremoteESP8266-2.2.1.02/src/ir_Sony.cpp
rename to lib/IRremoteESP8266-2.5.2.03/src/ir_Sony.cpp
index fd2652d1dc9f..efa6e6a46ca3 100644
--- a/lib/IRremoteESP8266-2.2.1.02/src/ir_Sony.cpp
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Sony.cpp
@@ -5,7 +5,6 @@
#include
#include "IRrecv.h"
#include "IRsend.h"
-#include "IRtimer.h"
#include "IRutils.h"
// SSSS OOO N N Y Y
@@ -20,19 +19,19 @@
// Constants
// Ref:
// http://www.sbprojects.com/knowledge/ir/sirc.php
-#define SONY_TICK 200U
-#define SONY_HDR_MARK_TICKS 12U
-#define SONY_HDR_MARK (SONY_HDR_MARK_TICKS * SONY_TICK)
-#define SONY_SPACE_TICKS 3U
-#define SONY_SPACE (SONY_SPACE_TICKS * SONY_TICK)
-#define SONY_ONE_MARK_TICKS 6U
-#define SONY_ONE_MARK (SONY_ONE_MARK_TICKS * SONY_TICK)
-#define SONY_ZERO_MARK_TICKS 3U
-#define SONY_ZERO_MARK (SONY_ZERO_MARK_TICKS * SONY_TICK)
-#define SONY_RPT_LENGTH_TICKS 225U
-#define SONY_RPT_LENGTH (SONY_RPT_LENGTH_TICKS * SONY_TICK)
-#define SONY_MIN_GAP_TICKS 50U
-#define SONY_MIN_GAP (SONY_MIN_GAP_TICKS * SONY_TICK)
+const uint16_t kSonyTick = 200;
+const uint16_t kSonyHdrMarkTicks = 12;
+const uint16_t kSonyHdrMark = kSonyHdrMarkTicks * kSonyTick;
+const uint16_t kSonySpaceTicks = 3;
+const uint16_t kSonySpace = kSonySpaceTicks * kSonyTick;
+const uint16_t kSonyOneMarkTicks = 6;
+const uint16_t kSonyOneMark = kSonyOneMarkTicks * kSonyTick;
+const uint16_t kSonyZeroMarkTicks = 3;
+const uint16_t kSonyZeroMark = kSonyZeroMarkTicks * kSonyTick;
+const uint16_t kSonyRptLengthTicks = 225;
+const uint16_t kSonyRptLength = kSonyRptLengthTicks * kSonyTick;
+const uint16_t kSonyMinGapTicks = 50;
+const uint16_t kSonyMinGap = kSonyMinGapTicks * kSonyTick;
#if SEND_SONY
// Send a Sony/SIRC(Serial Infra-Red Control) message.
@@ -51,24 +50,10 @@
// Ref:
// http://www.sbprojects.com/knowledge/ir/sirc.php
void IRsend::sendSony(uint64_t data, uint16_t nbits, uint16_t repeat) {
- // Sony devices use a 40kHz IR carrier frequency & a 1/3 (33%) duty cycle.
- enableIROut(40, 33);
- IRtimer usecs = IRtimer();
-
- for (uint16_t i = 0; i <= repeat; i++) { // Typically loop 3 or more times.
- usecs.reset();
- // Header
- mark(SONY_HDR_MARK);
- space(SONY_SPACE);
- // Data
- sendData(SONY_ONE_MARK, SONY_SPACE, SONY_ZERO_MARK, SONY_SPACE,
- data, nbits, true);
- // Footer
- // The Sony protocol requires us to wait 45ms from start of a code to the
- // start of the next one. A 10ms minimum gap is also required.
- space(std::max(SONY_MIN_GAP, SONY_RPT_LENGTH - usecs.elapsed()));
- }
- // A space() is always performed last, so no need to turn off the LED.
+ sendGeneric(kSonyHdrMark, kSonySpace, kSonyOneMark, kSonySpace, kSonyZeroMark,
+ kSonySpace,
+ 0, // No Footer mark.
+ kSonyMinGap, kSonyRptLength, data, nbits, 40, true, repeat, 33);
}
// Convert Sony/SIRC command, address, & extended bits into sendSony format.
@@ -81,8 +66,8 @@ void IRsend::sendSony(uint64_t data, uint16_t nbits, uint16_t repeat) {
// A sendSony compatible data message.
//
// Status: BETA / Should be working.
-uint32_t IRsend::encodeSony(uint16_t nbits, uint16_t command,
- uint16_t address, uint16_t extended) {
+uint32_t IRsend::encodeSony(uint16_t nbits, uint16_t command, uint16_t address,
+ uint16_t extended) {
uint32_t result = 0;
switch (nbits) {
case 12: // 5 address bits.
@@ -120,7 +105,7 @@ uint32_t IRsend::encodeSony(uint16_t nbits, uint16_t command,
// Ref:
// http://www.sbprojects.com/knowledge/ir/sirc.php
bool IRrecv::decodeSony(decode_results *results, uint16_t nbits, bool strict) {
- if (results->rawlen < 2 * nbits + HEADER - 1)
+ if (results->rawlen < 2 * nbits + kHeader - 1)
return false; // Message is smaller than we expected.
// Compliance
@@ -136,31 +121,30 @@ bool IRrecv::decodeSony(decode_results *results, uint16_t nbits, bool strict) {
}
uint64_t data = 0;
- uint16_t offset = OFFSET_START;
+ uint16_t offset = kStartOffset;
uint16_t actualBits;
uint32_t timeSoFar = 0; // Time in uSecs of the message length.
// Header
- timeSoFar += results->rawbuf[offset] * RAWTICK;
- if (!matchMark(results->rawbuf[offset], SONY_HDR_MARK))
- return false;
+ timeSoFar += results->rawbuf[offset] * kRawTick;
+ if (!matchMark(results->rawbuf[offset], kSonyHdrMark)) return false;
// Calculate how long the common tick time is based on the header mark.
- uint32_t tick = results->rawbuf[offset++] * RAWTICK / SONY_HDR_MARK_TICKS;
+ uint32_t tick = results->rawbuf[offset++] * kRawTick / kSonyHdrMarkTicks;
// Data
for (actualBits = 0; offset < results->rawlen - 1; actualBits++, offset++) {
- // The gap after a Sony packet for a repeat should be SONY_MIN_GAP or
- // (SONY_RPT_LENGTH - timeSoFar) according to the spec.
- if (matchSpace(results->rawbuf[offset], SONY_MIN_GAP_TICKS * tick) ||
- matchAtLeast(results->rawbuf[offset], SONY_RPT_LENGTH - timeSoFar))
+ // The gap after a Sony packet for a repeat should be kSonyMinGap or
+ // (kSonyRptLength - timeSoFar) according to the spec.
+ if (matchSpace(results->rawbuf[offset], kSonyMinGapTicks * tick) ||
+ matchAtLeast(results->rawbuf[offset], kSonyRptLength - timeSoFar))
break; // Found a repeat space.
- timeSoFar += results->rawbuf[offset] * RAWTICK;
- if (!matchSpace(results->rawbuf[offset++], SONY_SPACE_TICKS * tick))
+ timeSoFar += results->rawbuf[offset] * kRawTick;
+ if (!matchSpace(results->rawbuf[offset++], kSonySpaceTicks * tick))
return false;
- timeSoFar += results->rawbuf[offset] * RAWTICK;
- if (matchMark(results->rawbuf[offset], SONY_ONE_MARK_TICKS * tick))
+ timeSoFar += results->rawbuf[offset] * kRawTick;
+ if (matchMark(results->rawbuf[offset], kSonyOneMarkTicks * tick))
data = (data << 1) | 1;
- else if (matchMark(results->rawbuf[offset], SONY_ZERO_MARK_TICKS * tick))
+ else if (matchMark(results->rawbuf[offset], kSonyZeroMarkTicks * tick))
data <<= 1;
else
return false;
@@ -179,14 +163,14 @@ bool IRrecv::decodeSony(decode_results *results, uint16_t nbits, bool strict) {
data = reverseBits(data, actualBits);
// Decode the address & command from raw decode value.
switch (actualBits) {
- case 12: // 7 command bits, 5 address bits.
- case 15: // 7 command bits, 8 address bits.
+ case 12: // 7 command bits, 5 address bits.
+ case 15: // 7 command bits, 8 address bits.
results->command = data & 0x7F; // Bits 0-6
- results->address = data >> 7; // Bits 7-14
+ results->address = data >> 7; // Bits 7-14
break;
case 20: // 7 command bits, 5 address bits, 8 extended (command) bits.
results->command = (data & 0x7F) + ((data >> 12) << 7); // Bits 0-6,12-19
- results->address = (data >> 7) & 0x1F; // Bits 7-11
+ results->address = (data >> 7) & 0x1F; // Bits 7-11
break;
default: // Shouldn't happen, but just in case.
results->address = 0;
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Toshiba.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Toshiba.cpp
new file mode 100644
index 000000000000..817b5fbaa598
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Toshiba.cpp
@@ -0,0 +1,340 @@
+// Copyright 2017 David Conran
+
+#include "ir_Toshiba.h"
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// TTTTTTT OOOOO SSSSS HH HH IIIII BBBBB AAA
+// TTT OO OO SS HH HH III BB B AAAAA
+// TTT OO OO SSSSS HHHHHHH III BBBBBB AA AA
+// TTT OO OO SS HH HH III BB BB AAAAAAA
+// TTT OOOO0 SSSSS HH HH IIIII BBBBBB AA AA
+
+// Toshiba A/C support added by David Conran
+//
+// Equipment it seems compatible with:
+// * Toshiba RAS-B13N3KV2 / Akita EVO II
+// * Toshiba RAS-B13N3KVP-E, RAS 18SKP-ES
+// * Toshiba WH-TA04NE, WC-L03SE
+// *
+
+// Constants
+
+// Toshiba A/C
+// Ref:
+// https://github.com/r45635/HVAC-IR-Control/blob/master/HVAC_ESP8266/HVAC_ESP8266T.ino#L77
+const uint16_t kToshibaAcHdrMark = 4400;
+const uint16_t kToshibaAcHdrSpace = 4300;
+const uint16_t kToshibaAcBitMark = 543;
+const uint16_t kToshibaAcOneSpace = 1623;
+const uint16_t kToshibaAcZeroSpace = 472;
+const uint16_t kToshibaAcMinGap = 7048;
+
+#if SEND_TOSHIBA_AC
+// Send a Toshiba A/C message.
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kToshibaACStateLength)
+// repeat: Nr. of times the message is to be repeated.
+// (Default = kToshibaACMinRepeat).
+//
+// Status: StABLE / Working.
+//
+void IRsend::sendToshibaAC(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kToshibaACStateLength)
+ return; // Not enough bytes to send a proper message.
+ sendGeneric(kToshibaAcHdrMark, kToshibaAcHdrSpace, kToshibaAcBitMark,
+ kToshibaAcOneSpace, kToshibaAcBitMark, kToshibaAcZeroSpace,
+ kToshibaAcBitMark, kToshibaAcMinGap, data, nbytes, 38, true,
+ repeat, 50);
+}
+#endif // SEND_TOSHIBA_AC
+
+// Code to emulate Toshiba A/C IR remote control unit.
+// Inspired and derived from the work done at:
+// https://github.com/r45635/HVAC-IR-Control
+//
+// Status: STABLE / Working.
+//
+// Initialise the object.
+IRToshibaAC::IRToshibaAC(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+// Reset the state of the remote to a known good state/sequence.
+void IRToshibaAC::stateReset() {
+ // The state of the IR remote in IR code form.
+ // Known good state obtained from:
+ // https://github.com/r45635/HVAC-IR-Control/blob/master/HVAC_ESP8266/HVAC_ESP8266T.ino#L103
+ // Note: Can't use the following because it requires -std=c++11
+ // uint8_t remote_state[kToshibaACStateLength] = {
+ // 0xF2, 0x0D, 0x03, 0xFC, 0x01, 0x00, 0x00, 0x00, 0x00 };
+ remote_state[0] = 0xF2;
+ remote_state[1] = 0x0D;
+ remote_state[2] = 0x03;
+ remote_state[3] = 0xFC;
+ remote_state[4] = 0x01;
+ for (uint8_t i = 5; i < kToshibaACStateLength; i++) remote_state[i] = 0;
+ mode_state = remote_state[6] & 0b00000011;
+ checksum(); // Calculate the checksum
+}
+
+// Configure the pin for output.
+void IRToshibaAC::begin() { _irsend.begin(); }
+
+#if SEND_TOSHIBA_AC
+// Send the current desired state to the IR LED.
+void IRToshibaAC::send() {
+ checksum(); // Ensure correct checksum before sending.
+ _irsend.sendToshibaAC(remote_state);
+}
+#endif // SEND_TOSHIBA_AC
+
+// Return a pointer to the internal state date of the remote.
+uint8_t* IRToshibaAC::getRaw() {
+ checksum();
+ return remote_state;
+}
+
+// Override the internal state with the new state.
+void IRToshibaAC::setRaw(uint8_t newState[]) {
+ for (uint8_t i = 0; i < kToshibaACStateLength; i++) {
+ remote_state[i] = newState[i];
+ }
+ mode_state = getMode(true);
+}
+
+// Calculate the checksum for a given array.
+// Args:
+// state: The array to calculate the checksum over.
+// length: The size of the array.
+// Returns:
+// The 8 bit checksum value.
+uint8_t IRToshibaAC::calcChecksum(const uint8_t state[],
+ const uint16_t length) {
+ uint8_t checksum = 0;
+ // Only calculate it for valid lengths.
+ if (length > 1) {
+ // Checksum is simple XOR of all bytes except the last one.
+ for (uint8_t i = 0; i < length - 1; i++) checksum ^= state[i];
+ }
+ return checksum;
+}
+
+// Verify the checksum is valid for a given state.
+// Args:
+// state: The array to verify the checksum of.
+// length: The size of the state.
+// Returns:
+// A boolean.
+bool IRToshibaAC::validChecksum(const uint8_t state[], const uint16_t length) {
+ return (length > 1 && state[length - 1] == calcChecksum(state, length));
+}
+
+// Calculate & set the checksum for the current internal state of the remote.
+void IRToshibaAC::checksum(const uint16_t length) {
+ // Stored the checksum value in the last byte.
+ if (length > 1) remote_state[length - 1] = calcChecksum(remote_state, length);
+}
+
+// Set the requested power state of the A/C to off.
+void IRToshibaAC::on() {
+ // state = ON;
+ remote_state[6] &= ~kToshibaAcPower;
+ setMode(mode_state);
+}
+
+// Set the requested power state of the A/C to off.
+void IRToshibaAC::off() {
+ // state = OFF;
+ remote_state[6] |= (kToshibaAcPower | 0b00000011);
+}
+
+// Set the requested power state of the A/C.
+void IRToshibaAC::setPower(bool state) {
+ if (state)
+ on();
+ else
+ off();
+}
+
+// Return the requested power state of the A/C.
+bool IRToshibaAC::getPower() {
+ return ((remote_state[6] & kToshibaAcPower) == 0);
+}
+
+// Set the temp. in deg C
+void IRToshibaAC::setTemp(uint8_t temp) {
+ temp = std::max((uint8_t)kToshibaAcMinTemp, temp);
+ temp = std::min((uint8_t)kToshibaAcMaxTemp, temp);
+ remote_state[5] = (temp - kToshibaAcMinTemp) << 4;
+}
+
+// Return the set temp. in deg C
+uint8_t IRToshibaAC::getTemp() {
+ return ((remote_state[5] >> 4) + kToshibaAcMinTemp);
+}
+
+// Set the speed of the fan, 0-5.
+// 0 is auto, 1-5 is the speed, 5 is Max.
+void IRToshibaAC::setFan(uint8_t fan) {
+ // Bounds check
+ if (fan > kToshibaAcFanMax)
+ fan = kToshibaAcFanMax; // Set the fan to maximum if out of range.
+ if (fan > kToshibaAcFanAuto) fan++;
+ remote_state[6] &= 0b00011111; // Clear the previous fan state
+ remote_state[6] |= (fan << 5);
+}
+
+// Return the requested state of the unit's fan.
+uint8_t IRToshibaAC::getFan() {
+ uint8_t fan = remote_state[6] >> 5;
+ if (fan == kToshibaAcFanAuto) return kToshibaAcFanAuto;
+ return --fan;
+}
+
+// Get the requested climate operation mode of the a/c unit.
+// Args:
+// useRaw: Indicate to get the mode from the state array. (Default: false)
+// Returns:
+// A uint8_t containing the A/C mode.
+uint8_t IRToshibaAC::getMode(bool useRaw) {
+ if (useRaw)
+ return (remote_state[6] & 0b00000011);
+ else
+ return mode_state;
+}
+
+// Set the requested climate operation mode of the a/c unit.
+void IRToshibaAC::setMode(uint8_t mode) {
+ // If we get an unexpected mode, default to AUTO.
+ switch (mode) {
+ case kToshibaAcAuto:
+ break;
+ case kToshibaAcCool:
+ break;
+ case kToshibaAcDry:
+ break;
+ case kToshibaAcHeat:
+ break;
+ default:
+ mode = kToshibaAcAuto;
+ }
+ mode_state = mode;
+ // Only adjust the remote_state if we have power set to on.
+ if (getPower()) {
+ remote_state[6] &= 0b11111100; // Clear the previous mode.
+ remote_state[6] |= mode_state;
+ }
+}
+
+// Convert the internal state into a human readable string.
+#ifdef ARDUINO
+String IRToshibaAC::toString() {
+ String result = "";
+#else
+std::string IRToshibaAC::toString() {
+ std::string result = "";
+#endif // ARDUINO
+ result += "Power: ";
+ if (getPower())
+ result += "On";
+ else
+ result += "Off";
+ result += ", Mode: " + uint64ToString(getMode());
+ switch (getMode()) {
+ case kToshibaAcAuto:
+ result += " (AUTO)";
+ break;
+ case kToshibaAcCool:
+ result += " (COOL)";
+ break;
+ case kToshibaAcHeat:
+ result += " (HEAT)";
+ break;
+ case kToshibaAcDry:
+ result += " (DRY)";
+ break;
+ default:
+ result += " (UNKNOWN)";
+ }
+ result += ", Temp: " + uint64ToString(getTemp()) + "C";
+ result += ", Fan: " + uint64ToString(getFan());
+ switch (getFan()) {
+ case kToshibaAcFanAuto:
+ result += " (AUTO)";
+ break;
+ case kToshibaAcFanMax:
+ result += " (MAX)";
+ break;
+ }
+ return result;
+}
+
+#if DECODE_TOSHIBA_AC
+// Decode a Toshiba AC IR message if possible.
+// Places successful decode information in the results pointer.
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kToshibaACBits.
+// strict: Flag to indicate if we strictly adhere to the specification.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: STABLE / Working.
+//
+// Ref:
+//
+bool IRrecv::decodeToshibaAC(decode_results* results, uint16_t nbits,
+ bool strict) {
+ uint16_t offset = kStartOffset;
+ uint16_t dataBitsSoFar = 0;
+
+ // Have we got enough data to successfully decode?
+ if (results->rawlen < kToshibaACBits + kHeader + kFooter - 1)
+ return false; // Can't possibly be a valid message.
+
+ // Compliance
+ if (strict && nbits != kToshibaACBits)
+ return false; // Must be called with the correct nr. of bytes.
+
+ // Header
+ if (!matchMark(results->rawbuf[offset++], kToshibaAcHdrMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kToshibaAcHdrSpace)) return false;
+
+ // Data
+ for (uint8_t i = 0; i < kToshibaACStateLength; i++) {
+ // Read a byte's worth of data.
+ match_result_t data_result =
+ matchData(&(results->rawbuf[offset]), 8, kToshibaAcBitMark,
+ kToshibaAcOneSpace, kToshibaAcBitMark, kToshibaAcZeroSpace);
+ if (data_result.success == false) return false; // Fail
+ dataBitsSoFar += 8;
+ results->state[i] = (uint8_t)data_result.data;
+ offset += data_result.used;
+ }
+
+ // Footer
+ if (!matchMark(results->rawbuf[offset++], kToshibaAcBitMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kToshibaAcMinGap)) return false;
+
+ // Compliance
+ if (strict) {
+ // Check that the checksum of the message is correct.
+ if (!IRToshibaAC::validChecksum(results->state)) return false;
+ }
+
+ // Success
+ results->decode_type = TOSHIBA_AC;
+ results->bits = dataBitsSoFar;
+ // No need to record the state as we stored it as we decoded it.
+ // As we use result->state, we don't record value, address, or command as it
+ // is a union data type.
+ return true;
+}
+#endif // DECODE_TOSHIBA_AC
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Toshiba.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Toshiba.h
new file mode 100644
index 000000000000..1a1e6cdc81a1
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Toshiba.h
@@ -0,0 +1,85 @@
+// Copyright 2017 David Conran
+#ifndef IR_TOSHIBA_H_
+#define IR_TOSHIBA_H_
+
+#define __STDC_LIMIT_MACROS
+#include
+#ifdef ARDUINO
+#include
+#else
+#include
+#endif
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// TTTTTTT OOOOO SSSSS HH HH IIIII BBBBB AAA
+// TTT OO OO SS HH HH III BB B AAAAA
+// TTT OO OO SSSSS HHHHHHH III BBBBBB AA AA
+// TTT OO OO SS HH HH III BB BB AAAAAAA
+// TTT OOOO0 SSSSS HH HH IIIII BBBBBB AA AA
+
+// Toshiba A/C support added by David Conran
+
+// Constants
+const uint8_t kToshibaAcAuto = 0;
+const uint8_t kToshibaAcCool = 1;
+const uint8_t kToshibaAcDry = 2;
+const uint8_t kToshibaAcHeat = 3;
+const uint8_t kToshibaAcPower = 4;
+const uint8_t kToshibaAcFanAuto = 0;
+const uint8_t kToshibaAcFanMax = 5;
+const uint8_t kToshibaAcMinTemp = 17; // 17C
+const uint8_t kToshibaAcMaxTemp = 30; // 30C
+
+// Legacy defines. (Deperecated)
+#define TOSHIBA_AC_AUTO kToshibaAcAuto
+#define TOSHIBA_AC_COOL kToshibaAcCool
+#define TOSHIBA_AC_DRY kToshibaAcDry
+#define TOSHIBA_AC_HEAT kToshibaAcHeat
+#define TOSHIBA_AC_POWER kToshibaAcPower
+#define TOSHIBA_AC_FAN_AUTO kToshibaAcFanAuto
+#define TOSHIBA_AC_FAN_MAX kToshibaAcFanMax
+#define TOSHIBA_AC_MIN_TEMP kToshibaAcMinTemp
+#define TOSHIBA_AC_MAX_TEMP kToshibaAcMaxTemp
+
+class IRToshibaAC {
+ public:
+ explicit IRToshibaAC(uint16_t pin);
+
+ void stateReset();
+#if SEND_TOSHIBA_AC
+ void send();
+#endif // SEND_TOSHIBA_AC
+ void begin();
+ void on();
+ void off();
+ void setPower(bool state);
+ bool getPower();
+ void setTemp(uint8_t temp);
+ uint8_t getTemp();
+ void setFan(uint8_t fan);
+ uint8_t getFan();
+ void setMode(uint8_t mode);
+ uint8_t getMode(bool useRaw = false);
+ void setRaw(uint8_t newState[]);
+ uint8_t* getRaw();
+ static bool validChecksum(const uint8_t state[],
+ const uint16_t length = kToshibaACStateLength);
+#ifdef ARDUINO
+ String toString();
+#else
+ std::string toString();
+#endif
+#ifndef UNIT_TEST
+
+ private:
+#endif
+ uint8_t remote_state[kToshibaACStateLength];
+ void checksum(const uint16_t length = kToshibaACStateLength);
+ static uint8_t calcChecksum(const uint8_t state[],
+ const uint16_t length = kToshibaACStateLength);
+ uint8_t mode_state;
+ IRsend _irsend;
+};
+
+#endif // IR_TOSHIBA_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Trotec.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Trotec.cpp
new file mode 100644
index 000000000000..0bece2664a60
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Trotec.cpp
@@ -0,0 +1,127 @@
+// Copyright 2017 stufisher
+
+#include "ir_Trotec.h"
+#include "IRremoteESP8266.h"
+#include "IRutils.h"
+
+// Constants
+const uint16_t kTrotecHdrMark = 5952;
+const uint16_t kTrotecHdrSpace = 7364;
+const uint16_t kTrotecOneMark = 592;
+const uint16_t kTrotecOneSpace = 1560;
+const uint16_t kTrotecZeroMark = 592;
+const uint16_t kTrotecZeroSpace = 592;
+const uint16_t kTrotecGap = 6184;
+const uint16_t kTrotecGapEnd = 1500; // made up value
+
+#if SEND_TROTEC
+
+void IRsend::sendTrotec(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kTrotecStateLength) return;
+
+ for (uint16_t r = 0; r <= repeat; r++) {
+ sendGeneric(kTrotecHdrMark, kTrotecHdrSpace, kTrotecOneMark,
+ kTrotecOneSpace, kTrotecZeroMark, kTrotecZeroSpace,
+ kTrotecOneMark, kTrotecGap, data, nbytes, 36, false,
+ 0, // Repeats handled elsewhere
+ 50);
+ // More footer
+ enableIROut(36);
+ mark(kTrotecOneMark);
+ space(kTrotecGapEnd);
+ }
+}
+#endif // SEND_TROTEC
+
+IRTrotecESP::IRTrotecESP(uint16_t pin) : _irsend(pin) { stateReset(); }
+
+void IRTrotecESP::begin() { _irsend.begin(); }
+
+#if SEND_TROTEC
+void IRTrotecESP::send() {
+ checksum();
+ _irsend.sendTrotec(trotec);
+}
+#endif // SEND_TROTEC
+
+void IRTrotecESP::checksum() {
+ uint8_t sum = 0;
+ uint8_t i;
+
+ for (i = 2; i < 8; i++) sum += trotec[i];
+
+ trotec[8] = sum & 0xFF;
+}
+
+void IRTrotecESP::stateReset() {
+ for (uint8_t i = 2; i < kTrotecStateLength; i++) trotec[i] = 0x0;
+
+ trotec[0] = kTrotecIntro1;
+ trotec[1] = kTrotecIntro2;
+
+ setPower(false);
+ setTemp(kTrotecDefTemp);
+ setSpeed(kTrotecFanMed);
+ setMode(kTrotecAuto);
+}
+
+uint8_t* IRTrotecESP::getRaw() {
+ checksum();
+ return trotec;
+}
+
+void IRTrotecESP::setPower(bool state) {
+ if (state)
+ trotec[2] |= (kTrotecOn << 3);
+ else
+ trotec[2] &= ~(kTrotecOn << 3);
+}
+
+uint8_t IRTrotecESP::getPower() { return trotec[2] & (kTrotecOn << 3); }
+
+void IRTrotecESP::setSpeed(uint8_t speed) {
+ trotec[2] = (trotec[2] & 0xcf) | (speed << 4);
+}
+
+uint8_t IRTrotecESP::getSpeed() { return trotec[2] & 0x30; }
+
+void IRTrotecESP::setMode(uint8_t mode) {
+ trotec[2] = (trotec[2] & 0xfc) | mode;
+}
+
+uint8_t IRTrotecESP::getMode() { return trotec[2] & 0x03; }
+
+void IRTrotecESP::setTemp(uint8_t temp) {
+ if (temp < kTrotecMinTemp)
+ temp = kTrotecMinTemp;
+ else if (temp > kTrotecMaxTemp)
+ temp = kTrotecMaxTemp;
+
+ trotec[3] = (trotec[3] & 0x80) | (temp - kTrotecMinTemp);
+}
+
+uint8_t IRTrotecESP::getTemp() { return trotec[3] & 0x7f; }
+
+void IRTrotecESP::setSleep(bool sleep) {
+ if (sleep)
+ trotec[3] |= (kTrotecSleepOn << 7);
+ else
+ trotec[3] &= ~(kTrotecSleepOn << 7);
+}
+
+bool IRTrotecESP::getSleep(void) { return trotec[3] & (kTrotecSleepOn << 7); }
+
+void IRTrotecESP::setTimer(uint8_t timer) {
+ if (timer > kTrotecMaxTimer) timer = kTrotecMaxTimer;
+
+ if (timer) {
+ trotec[5] |= (kTrotecTimerOn << 6);
+ trotec[6] = timer;
+ } else {
+ trotec[5] &= ~(kTrotecTimerOn << 6);
+ trotec[6] = 0;
+ }
+}
+
+uint8_t IRTrotecESP::getTimer() { return trotec[6]; }
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Trotec.h b/lib/IRremoteESP8266-2.5.2.03/src/ir_Trotec.h
new file mode 100644
index 000000000000..040d9a722d5d
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Trotec.h
@@ -0,0 +1,92 @@
+// Copyright 2017 stufisher
+
+#ifndef IR_TROTEC_H_
+#define IR_TROTEC_H_
+
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+
+// Constants
+// Byte 0
+const uint8_t kTrotecIntro1 = 0x12;
+
+// Byte 1
+const uint8_t kTrotecIntro2 = 0x34;
+
+// Byte 2
+const uint8_t kTrotecAuto = 0;
+const uint8_t kTrotecCool = 1;
+const uint8_t kTrotecDry = 2;
+const uint8_t kTrotecFan = 3;
+
+const uint8_t kTrotecOn = 1;
+const uint8_t kTrotecOff = 0;
+
+const uint8_t kTrotecFanLow = 1;
+const uint8_t kTrotecFanMed = 2;
+const uint8_t kTrotecFanHigh = 3;
+
+// Byte 3
+const uint8_t kTrotecMinTemp = 18;
+const uint8_t kTrotecDefTemp = 25;
+const uint8_t kTrotecMaxTemp = 32;
+
+const uint8_t kTrotecSleepOn = 1;
+
+// Byte 5
+const uint8_t kTrotecTimerOn = 1;
+
+// Byte 6
+const uint8_t kTrotecMinTimer = 0;
+const uint8_t kTrotecMaxTimer = 23;
+
+// Legacy defines. (Deperecated)
+#define TROTEC_AUTO kTrotecAuto
+#define TROTEC_COOL kTrotecCool
+#define TROTEC_DRY kTrotecDry
+#define TROTEC_FAN kTrotecFan
+#define TROTEC_FAN_LOW kTrotecFanLow
+#define TROTEC_FAN_MED kTrotecFanMed
+#define TROTEC_FAN_HIGH kTrotecFanHigh
+#define TROTEC_MIN_TEMP kTrotecMinTemp
+#define TROTEC_MAX_TEMP kTrotecMaxTemp
+#define TROTEC_MIN_TIMER kTrotecMinTimer
+#define TROTEC_MAX_TIMER kTrotecMaxTimer
+
+class IRTrotecESP {
+ public:
+ explicit IRTrotecESP(uint16_t pin);
+
+#if SEND_TROTEC
+ void send();
+#endif // SEND_TROTEC
+ void begin();
+
+ void setPower(bool state);
+ uint8_t getPower();
+
+ void setTemp(uint8_t temp);
+ uint8_t getTemp();
+
+ void setSpeed(uint8_t fan);
+ uint8_t getSpeed();
+
+ uint8_t getMode();
+ void setMode(uint8_t mode);
+
+ bool getSleep();
+ void setSleep(bool sleep);
+
+ uint8_t getTimer();
+ void setTimer(uint8_t timer);
+
+ uint8_t* getRaw();
+
+ private:
+ uint8_t trotec[kTrotecStateLength];
+ void stateReset();
+ void checksum();
+ IRsend _irsend;
+};
+
+#endif // IR_TROTEC_H_
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Whirlpool.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Whirlpool.cpp
new file mode 100644
index 000000000000..67151399103f
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Whirlpool.cpp
@@ -0,0 +1,149 @@
+// Copyright 2018 David Conran
+//
+// Code to emulate Whirlpool protocol compatible devices.
+// Should be compatible with:
+// * SPIS409L, SPIS412L, SPIW409L, SPIW412L, SPIW418L
+//
+
+#include
+#ifndef ARDUINO
+#include
+#endif
+#include "IRrecv.h"
+#include "IRremoteESP8266.h"
+#include "IRsend.h"
+#include "IRutils.h"
+
+// WW WW HH HH IIIII RRRRRR LL PPPPPP OOOOO OOOOO LL
+// WW WW HH HH III RR RR LL PP PP OO OO OO OO LL
+// WW W WW HHHHHHH III RRRRRR LL PPPPPP OO OO OO OO LL
+// WW WWW WW HH HH III RR RR LL PP OO OO OO OO LL
+// WW WW HH HH IIIII RR RR LLLLLLL PP OOOO0 OOOO0 LLLLLLL
+
+// Constants
+// Ref: https://github.com/markszabo/IRremoteESP8266/issues/509
+const uint16_t kWhirlpoolAcHdrMark = 8950;
+const uint16_t kWhirlpoolAcHdrSpace = 4484;
+const uint16_t kWhirlpoolAcBitMark = 597;
+const uint16_t kWhirlpoolAcOneSpace = 1649;
+const uint16_t kWhirlpoolAcZeroSpace = 533;
+const uint16_t kWhirlpoolAcGap = 7920;
+const uint32_t kWhirlpoolAcMinGap = 100000; // Completely made up value.
+const uint8_t kWhirlpoolAcSections = 3;
+
+#if SEND_WHIRLPOOL_AC
+// Send a Whirlpool A/C message.
+//
+// Args:
+// data: An array of bytes containing the IR command.
+// nbytes: Nr. of bytes of data in the array. (>=kWhirlpoolAcStateLength)
+// repeat: Nr. of times the message is to be repeated. (Default = 0).
+//
+// Status: ALPHA / Untested.
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/509
+void IRsend::sendWhirlpoolAC(unsigned char data[], uint16_t nbytes,
+ uint16_t repeat) {
+ if (nbytes < kWhirlpoolAcStateLength)
+ return; // Not enough bytes to send a proper message.
+ for (uint16_t r = 0; r <= repeat; r++) {
+ // Section 1
+ sendGeneric(kWhirlpoolAcHdrMark, kWhirlpoolAcHdrSpace, kWhirlpoolAcBitMark,
+ kWhirlpoolAcOneSpace, kWhirlpoolAcBitMark,
+ kWhirlpoolAcZeroSpace, kWhirlpoolAcBitMark, kWhirlpoolAcGap,
+ data, 6, // 6 bytes == 48 bits
+ 38000, // Complete guess of the modulation frequency.
+ false, 0, 50);
+ // Section 2
+ sendGeneric(0, 0, kWhirlpoolAcBitMark, kWhirlpoolAcOneSpace,
+ kWhirlpoolAcBitMark, kWhirlpoolAcZeroSpace, kWhirlpoolAcBitMark,
+ kWhirlpoolAcGap, data + 6, 8, // 8 bytes == 64 bits
+ 38000, // Complete guess of the modulation frequency.
+ false, 0, 50);
+ // Section 3
+ sendGeneric(0, 0, kWhirlpoolAcBitMark, kWhirlpoolAcOneSpace,
+ kWhirlpoolAcBitMark, kWhirlpoolAcZeroSpace, kWhirlpoolAcBitMark,
+ kWhirlpoolAcMinGap, data + 14, 7, // 7 bytes == 56 bits
+ 38000, // Complete guess of the modulation frequency.
+ false, 0, 50);
+ }
+}
+#endif // SEND_WHIRLPOOL_AC
+
+#if DECODE_WHIRLPOOL_AC
+// Decode the supplied Whirlpool A/C message.
+//
+// Args:
+// results: Ptr to the data to decode and where to store the decode result.
+// nbits: The number of data bits to expect. Typically kWhirlpoolAcBits
+// strict: Flag indicating if we should perform strict matching.
+// Returns:
+// boolean: True if it can decode it, false if it can't.
+//
+// Status: ALPHA / Untested.
+//
+//
+// Ref:
+// https://github.com/markszabo/IRremoteESP8266/issues/509
+bool IRrecv::decodeWhirlpoolAC(decode_results *results, uint16_t nbits,
+ bool strict) {
+ if (results->rawlen < 2 * nbits + 4 + kHeader + kFooter - 1)
+ return false; // Can't possibly be a valid Whirlpool A/C message.
+ if (strict) {
+ if (nbits != kWhirlpoolAcBits) return false;
+ }
+
+ uint16_t offset = kStartOffset;
+ uint16_t dataBitsSoFar = 0;
+ uint16_t i = 0;
+ match_result_t data_result;
+ uint8_t sectionSize[kWhirlpoolAcSections] = {6, 8, 7};
+
+ // Header
+ if (!matchMark(results->rawbuf[offset++], kWhirlpoolAcHdrMark)) return false;
+ if (!matchSpace(results->rawbuf[offset++], kWhirlpoolAcHdrSpace))
+ return false;
+
+ // Data Section
+ // Keep reading bytes until we either run out of section or state to fill.
+ for (uint8_t section = 0, pos = 0; section < kWhirlpoolAcSections;
+ section++) {
+ pos += sectionSize[section];
+ for (; offset <= results->rawlen - 16 && i < pos;
+ i++, dataBitsSoFar += 8, offset += data_result.used) {
+ data_result =
+ matchData(&(results->rawbuf[offset]), 8, kWhirlpoolAcBitMark,
+ kWhirlpoolAcOneSpace, kWhirlpoolAcBitMark,
+ kWhirlpoolAcZeroSpace, kTolerance, kMarkExcess, false);
+ if (data_result.success == false) break; // Fail
+ // Data is in LSB order. We need to reverse it.
+ results->state[i] = (uint8_t)data_result.data;
+ }
+ // Section Footer
+ if (!matchMark(results->rawbuf[offset++], kWhirlpoolAcBitMark))
+ return false;
+ if (section < kWhirlpoolAcSections - 1) { // Inter-section gaps.
+ if (!matchSpace(results->rawbuf[offset++], kWhirlpoolAcGap)) return false;
+ } else { // Last section / End of message gap.
+ if (offset <= results->rawlen &&
+ !matchAtLeast(results->rawbuf[offset++], kWhirlpoolAcGap))
+ return false;
+ }
+ }
+
+ // Compliance
+ if (strict) {
+ // Re-check we got the correct size/length due to the way we read the data.
+ if (dataBitsSoFar != kWhirlpoolAcBits) return false;
+ }
+
+ // Success
+ results->decode_type = WHIRLPOOL_AC;
+ results->bits = dataBitsSoFar;
+ // No need to record the state as we stored it as we decoded it.
+ // As we use result->state, we don't record value, address, or command as it
+ // is a union data type.
+ return true;
+}
+#endif // WHIRLPOOL_AC
diff --git a/lib/IRremoteESP8266-2.5.2.03/src/ir_Whynter.cpp b/lib/IRremoteESP8266-2.5.2.03/src/ir_Whynter.cpp
new file mode 100644
index 000000000000..555c50788c03
--- /dev/null
+++ b/lib/IRremoteESP8266-2.5.2.03/src/ir_Whynter.cpp
@@ -0,0 +1,135 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2017 David Conran
+
+#include 
- [iTead Sonoff TH10/TH16 with temperature sensor](https://www.itead.cc/smart-home/sonoff-th.html)
@@ -90,9 +95,15 @@ The following devices are supported:
- [MagicHome PWM LED controller](https://github.com/arendst/Sonoff-Tasmota/wiki/MagicHome-LED-strip-controller)
- AriLux AL-LC01, AL-LC06 and AL-LC11 PWM LED controller
- [Supla device - Espablo-inCan mod. for electrical Installation box](https://forum.supla.org/viewtopic.php?f=33&t=2188)
-- [BlitzWolf BW-SHP2 Smart Socket with Energy Monitoring](https://www.banggood.com/BlitzWolf-BW-SHP2-Smart-WIFI-Socket-EU-Plug-220V-16A-Work-with-Amazon-Alexa-Google-Assistant-p-1292899.html)
+- [BlitzWolf BW-SHP2 Smart Socket with Energy Monitoring](https://www.banggood.com/BlitzWolf-BW-SHP2-Smart-WIFI-Socket-EU-Plug-220V-16A-Work-with-Amazon-Alexa-Google-Assistant-p-1292899.html)
- [Luani HVIO board](https://luani.de/projekte/esp8266-hvio/)
-- Wemos D1 mini, NodeMcu and Ledunia
+- [Wemos D1 mini](https://wiki.wemos.cc/products:d1:d1_mini)
+- [HuaFan Smart Socket](https://github.com/arendst/Sonoff-Tasmota/wiki/HuaFan-Smart-Socket)
+- [Hyleton-313 Smart Plug](https://github.com/arendst/Sonoff-Tasmota/wiki/Hyleton-313-Smart-Plug)
+- [Allterco Shelly 1](https://shelly.cloud/shelly1-open-source/)
+- [Allterco Shelly 2 with Energy Monitoring](https://shelly.cloud/shelly2/)
+- NodeMcu and Ledunia
+- [KS-602 based switches like GresaTek, Jesiya, NewRice, Lyasi etc](https://ucexperiment.wordpress.com/2017/11/14/reprogramming-a-lyasi-wifi-wall-switch-with-esp8285/)
### Contribute
You can contribute to Sonoff-Tasmota by
@@ -108,21 +119,27 @@ You can contribute to Sonoff-Tasmota by
Libraries used with Sonoff-Tasmota are:
- [ESP8266 core for Arduino](https://github.com/esp8266/Arduino)
- [Adafruit CCS811](https://github.com/adafruit/Adafruit_CCS811)
+- [Adafruit ILI9341](https://github.com/adafruit/Adafruit_ILI9341)
+- [Adafruit LED Backpack](https://github.com/adafruit/Adafruit-LED-Backpack-Library)
- [Adafruit SGP30](https://github.com/adafruit/Adafruit_SGP30)
+- [Adafruit SSD1306](https://github.com/adafruit/Adafruit_SSD1306)
+- [Adafruit GFX](https://github.com/adafruit/Adafruit-GFX-Library)
- [ArduinoJson](https://arduinojson.org/)
+- [arduino mqtt](https://github.com/256dpi/arduino-mqtt)
- [Bosch BME680](https://github.com/BoschSensortec/BME680_driver)
- [C2 Programmer](http://app.cear.ufpb.br/~lucas.hartmann/tag/efm8bb1/)
-- [Esp8266MqttClient](https://github.com/tuanpmt/ESP8266MQTTClient)
+- [esp-epaper-29-ws-20171230-gemu](https://github.com/gemu2015/Sonoff-Tasmota/tree/displays/lib)
- [esp-knx-ip](https://github.com/envy/esp-knx-ip)
-- [esp-mqtt-arduino](https://github.com/i-n-g-o/esp-mqtt-arduino)
-- [ESPAsyncUDP](https://github.com/me-no-dev/ESPAsyncUDP)
- [I2Cdevlib](https://github.com/jrowberg/i2cdevlib)
- [IRremoteEsp8266](https://github.com/markszabo/IRremoteESP8266)
- [JobaTsl2561](https://github.com/joba-1/Joba_Tsl2561)
+- [Liquid Cristal](https://github.com/marcoschwartz/LiquidCrystal_I2C)
- [MultiChannelGasSensor](http://wiki.seeedstudio.com/Grove-Multichannel_Gas_Sensor/)
- [NeoPixelBus](https://github.com/Makuna/NeoPixelBus)
+- [NewPing](https://bitbucket.org/teckel12/arduino-new-ping/wiki/Home)
- [OneWire](https://github.com/PaulStoffregen/OneWire)
- [PubSubClient](https://github.com/knolleary/pubsubclient)
+- [rc-switch](https://github.com/sui77/rc-switch)
#### People inspiring me
People helping to keep the show on the road:
@@ -136,16 +153,19 @@ People helping to keep the show on the road:
- Flexiti for his initial timer implementation
- reloxx13 for his [TasmoAdmin](https://github.com/reloxx13/TasmoAdmin) management tool
- Joachim Banzhaf for his TSL2561 library and driver
-- Gijs Noorlander for his MHZ19 and SenseAir drivers
+- Gijs Noorlander for his MHZ19, SenseAir and updated PubSubClient drivers
- Emontnemery for his HomeAssistant Discovery concept and many code tuning tips
- Aidan Mountford for his HSB support
- Daniel Ztolnai for his Serial Bridge implementation
-- Gerhard Mutz for his SGP30 and Sunrise/Sunset driver
+- Gerhard Mutz for his SGP30, Sunrise/Sunset and display support drivers
- Nuno Ferreira for his HC-SR04 driver
- Adrian Scillato for his (security)fixes and implementing and maintaining KNX
- Gennaro Tortone for implementing and maintaining Eastron drivers
- Raymond Mouthaan for managing Wemos Wiki information
-- Norbert Richter, Frogmore42 and Jason2866 for providing many issue answers
+- Norbert Richter for his decode-config.py tool
+- Andre Thomas for providing [thehackbox](http://thehackbox.org/tasmota/) OTA support and daily development builds
+- Joel Stein and digiblur for their Tuya research and driver
+- Frogmore42 and Jason2866 for providing many issue answers
- Many more providing Tips, Pocs or PRs
### License
diff --git a/REFERENCE.md b/REFERENCE.md
new file mode 100644
index 000000000000..22bd77899db7
--- /dev/null
+++ b/REFERENCE.md
@@ -0,0 +1,17 @@
+## Tasmota Reference
+Tasmota backgound information.
+
+## Supported Smart Switch with Energy Monitoring GPIO usage
+Module | GPIO00 | GPIO01 | GPIO02 | GPIO03 | GPIO04 | GPIO05 | GPIO12 | GPIO13 | GPIO14 | GPIO15
+-------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------
+Sonoff Pow | KEY1 | - | - | - | - | NRG_SEL | REL1 | NRG_CF1 | HLW_CF | LED1
+Sonoff Pow R2 | KEY1 | RXD | - | TXD | - | - | REL1 | LED1_INV | - | -
+Shelly 2 | - | RXD | - | TXD | REL1 | REL2 | SWT1 | - | SWT2 | -
+Huafan SS | LED1_INV | - | - | LED2_INV | KEY1 | REL1_INV | NRG_CF1 | NRG_SEL | HLW_CF | -
+KMC 70011 | KEY1 | - | - | - | HLW_CF | NRG_CF1 | NRG_SEL | LED1_INV | REL1 | -
+Teckin | - | KEY1 | - | LED2_INV | HJL_CF | NRG_CF1 | NRG_SEL_INV | LED1_INV | REL1 | -
+AplicWDP303075 | - | - | - | KEY1 | HLW_CF | NRG_CF1 | NRG_SEL_INV | LED1_INV | REL1 | -
+Gosund SP1 v23 | - | LED1_INV | - | KEY1 | HJL_CF | NRG_CF1 | NRG_SEL_INV | LED2_INV | REL1 | -
+SK03 Outdoor | KEY1 | - | - | - | HLW_CF | NRG_CF1 | NRG_SEL_INV | LED2_INV | LED1_INV | REL1
+BlitzWolf SHP | LED2_INV | - | LED1_INV | - | - | HJL_CF | NRG_SEL_INV | KEY1 | NRG_CF1 | REL1
+Teckin US | LED2_INV | - | LED1_INV | - | REL1 | HJL_CF | NRG_SEL_INV | KEY1 | NRG_CF1 | -
diff --git a/RELEASENOTES.md b/RELEASENOTES.md
index 7cacefa47c25..1198a61654c4 100644
--- a/RELEASENOTES.md
+++ b/RELEASENOTES.md
@@ -15,156 +15,247 @@ To save memory space all other binaries support **WifiManager only**.
See _changelog.ino how to enable them again.
- Define WIFI_CONFIG_TOOL now contains the default behaviour once a SSID has been configured.
- If no SSID is configured making a wifi connection impossible the new define WIFI_CONFIG_NO_SSID will be used.
-- While define WIFI_CONFIG_NO_SSID is set to WIFI_WPSCONFIG in user_config.h the compiler will check for define USE_WPS and if not enabled WIFI_CONFIG_NO_SSID will default to WIFI_MANAGER using the webserver. If define USE_WEBSERVER is also not enabled WIFI_CONFIG_NO_SSID will default to WIFI_SMARTCONFIG. If define USE_SMARTCONFIG is also not enabled WIFI_CONFIG_NO_SSID will default to a new option WIFI_SERIAL allowing to enter wifi parameters to serial which is always possible.
+- While define WIFI_CONFIG_NO_SSID is set to WIFI_WPSCONFIG in my_user_config.h the compiler will check for define USE_WPS and if not enabled WIFI_CONFIG_NO_SSID will default to WIFI_MANAGER using the webserver. If define USE_WEBSERVER is also not enabled WIFI_CONFIG_NO_SSID will default to WIFI_SMARTCONFIG. If define USE_SMARTCONFIG is also not enabled WIFI_CONFIG_NO_SSID will default to a new option WIFI_SERIAL allowing to enter wifi parameters to serial which is always possible.
+
+## Supported Modules
+The following hardware modules are supported.
+
+Module | Description
+------------------|-----------------------
+01 Sonoff Basic | Sonoff Basic Wifi Smart Switch
+02 Sonoff RF | Sonoff RF Wifi Smart Switch with RF (434MHz) receiver
+03 Sonoff SV | Sonoff SV Safe Voltage Wifi Smart Switch
+04 Sonoff TH | Sonoff TH10/TH16 Wifi Smart Switch with Sensor connection
+05 Sonoff Dual | Sonoff Dual Wifi Smart Switch
+06 Sonoff Pow | Sonoff Pow Wifi Smart Switch with Energy Monitoring
+07 Sonoff 4CH | Sonoff 4CH 4-gang Wifi Smart Switch
+08 Sonoff S2X | Sonoff S20/S26 Wifi Smart Socket
+09 Slampher | Sonoff Slampher Wifi Smart Light Bulb Socket with RF (434MHz) receiver
+10 Sonoff Touch | Sonoff Touch Wifi Light Switch
+11 Sonoff LED | Sonoff Led Wifi Led Pack (Retired)
+12 1 Channel | 1 Channel Inching/Self Locking Wifi Switch 5V/12V
+13 4 Channel | 4 Channel Inching/Self Locking Wifi Switch (Retired)
+14 Motor C/AC | Motor Clockwise/Antoclockwise Wifi Switch (Retired)
+15 ElectroDragon | Electrodragon Wifi IoT Board
+16 EXS Relay(s) | Electronic Experience Store 1 or 2-gang Wifi Module
+17 WiOn | WiOn Wifi Smart Socket
+18 Generic | Any ESP8266/ESP8285 device like WeMos and NodeMCU
+19 Sonoff Dev | Sonoff Dev Wifi Development Board
+20 H801 | H801 Wifi RGBWW Led Controller
+21 Sonoff SC | Sonoff SC Wifi Environmental Monitor
+22 Sonoff BN-SZ | Sonoff BN-SZ01 Wifi Ceiling Led (Retired)
+23 Sonoff 4CH Pro | Sonoff 4CH Pro 4-gang Wifi Smart Switch
+24 Huafan SS | HuaFan Wifi Smart Socket
+25 Sonoff Bridge | Sonoff RF (434MHz) transceive to Wifi Bridge
+26 Sonoff B1 | Sonoff B1 Wifi RGBWW Led Bulb
+27 AiLight | Ai-Thinker RGBW Led Bulb
+28 Sonoff T1 1CH | Sonoff T1 1-gang Wifi Light Switch
+29 Sonoff T1 2CH | Sonoff T1 2-gang Wifi Light Switch
+30 Sonoff T1 3CH | Sonoff T1 3-gang Wifi Light Switch
+31 Supla Espablo | 2-gang Wifi Module
+32 Witty Cloud | Witty Cloud ESP8266 Wifi Development Board
+33 Yunshan Relay | ESP8266 Wifi Network Relay Module
+34 MagicHome | MagicHome, Flux-light and some Arilux LC10 RGB(W) Led Controller
+35 Luani HVIO | Luani ESP8266 Wifi I/O Module
+36 KMC 70011 | KMC Wifi Smart Socket with Energy Monitoring
+37 Arilux LC01 | Arilux AL-LC01 RGB Led Controller
+38 Arilux LC11 | Arilux AL-LC11 RGBWW Led Controller
+39 Sonoff Dual R2 | Sonoff Dual R2 Wifi Smart Switch
+40 Arilux LC06 | Arilux AL-LC06 RGB(WW) Led Controller
+41 Sonoff S31 | Sonoff S31 Wifi Smart Socket with Energy Monitoring
+42 Zengge WF017 | Zengge WF017 Wifi RGB(W) Led Controller
+43 Sonoff Pow R2 | Sonoff Pow R2 Wifi Smart Switch with Energy Monitoring
+44 Sonoff iFan02 | Sonoff iFan02 Wifi Smart Ceiling Fan with Light
+45 BlitzWolf SHP | BlitzWolf BW-SHP2, BW-SHP6, HomeCube SP1, Gosund SP111, Teckin SP22 Wifi Smart Switch with Energy Monitoring
+46 Shelly 1 | Shelly 1 Open Source Wifi Relay Module
+47 Shelly 2 | Shelly 2 Wifi 2-gang Relay Module with Energy Monitoring
+48 Xiaomi Philips | Xiaomi Philips Wifi WW Led Bulb
+49 Neo Coolcam | Neo Coolcam Wifi Smart Socket
+50 ESP Switch | ESP Switch 4-gang Wifi Switch with Leds
+51 OBI Socket | OBI Wifi Smart Socket
+52 Teckin | Teckin SP20 Wifi Smart Switch with Energy Monitoring
+53 AplicWDP303075 | Aplic WDP 303075 CSL Wifi Smart Switch with Energy Monitoring
+54 Tuya Dimmer | MIUO (and other Tuya based) Wifi Dimmer for Incandescent Lights and Led
+55 Gosund SP1 v23 | Gosund SP1 v2.3 Wifi Smart Switch with Energy Monitoring
+56 ARMTR Dimmer | ARMtronix Wifi dimmer for Incandescent Lights and Led
+57 SK03 Outdoor | SK03 Outdoor Wifi Smart Switch with Energy Monitoring
+58 PS-16-DZ | PS-16-DZ Wifi dimmer for Incandescent Lights and Led
+59 Teckin US | Teckin US and ZooZee SA102 Wifi Smart Switch with Energy Monitoring
+60 Manzoku strip | Manzoku Wifi Smart Power Strip with four Relays
## Provided Binary Downloads
-The following binary downloads have been compiled with ESP8266/Arduino library version **2.3.0**
+The following binary downloads have been compiled with ESP8266/Arduino library core version **2.4.2** patched with the Alexa fix.
- **sonoff-minimal.bin** = The Minimal version allows intermediate OTA uploads to support larger versions and does NOT change any persistent parameter. This version **should NOT be used for initial installation**.
- **sonoff-classic.bin** = The Classic version allows **initial installation** using either WifiManager, Wps or SmartConfig.
- **sonoff.bin** = The Sonoff version without Wps and SmartConfig configuration but adds more sensors.
- **sonoff-BG.bin** to **sonoff-TW.bin** = The Sonoff version without Wps and SmartConfig configuration in different languages.
- **sonoff-sensors.bin** = The Sensors version without Wps and SmartConfig configuration but adds even more useful sensors.
+- **sonoff-display.bin** = The Display version without Wps and SmartConfig configuration but adds display support.
- **sonoff-knx.bin** = The Knx version without Wps and SmartConfig configuration and some other features but adds KNX support.
-See [Tasmota ESP/Arduino library version related issues](https://github.com/arendst/Sonoff-Tasmota/wiki/Theo's-Tasmota-Tips#20180523---relation-tasmota-and-esp8266arduino-core-version) why these files are still released using ESP/Arduino library version v2.3.0.
-
### Available Features and Sensors
-| Feature or Sensor | minimal | classic | sonoff | knx | sensors | Remarks
-|--------------------------------|---------|---------|--------|------|---------|--------
-| ESP/Arduino lib v2.3.0 | 340k | 477k | 473k | 492k | 497k |
-| ESP/Arduino lib v2.4.2 | 360k | 491k | 491k | 509k | 513k | No sleep
-| | | | | | |
-| MY_LANGUAGE en-GB | x | x | x | x | x |
-| USE_WPS | - | x | - | - | - | WPS
-| USE_SMARTCONFIG | - | x | - | - | - | SmartConfig
-| USE_ARDUINO_OTA | - | - | - | - | - |
-| MQTT_LIBRARY_TYPE PUBSUBCLIENT | x | x | x | x | x |
-| USE_DOMOTICZ | - | x | x | x | x |
-| USE_HOME_ASSISTANT | - | x | x | x | x |
-| USE_MQTT_TLS | - | - | - | - | - |
-| USE_KNX | - | - | - | x | - |
-| USE_WEBSERVER | x | x | x | x | x | WifiManager
-| USE_EMULATION | - | x | x | - | x |
-| USE_DISCOVERY | - | x | x | x | x |
-| WEBSERVER_ADVERTISE | - | x | x | x | x |
-| MQTT_HOST_DISCOVERY | - | x | x | x | x |
-| USE_TIMERS | - | - | x | x | x |
-| USE_TIMERS_WEB | - | - | x | x | x |
-| USE_SUNRISE | - | - | x | x | x |
-| USE_RULES | - | - | x | x | x |
+| Feature or Sensor | minimal | basic | classic | sonoff | knx | sensors | Remarks
+|--------------------------------|---------|-------|---------|--------|------|---------|--------
+| ESP/Arduino lib v2.3.0 | 346k | 429k | 482k | 504k | 522k | 535k |
+| ESP/Arduino lib v2.4.2 | 366k | 446k | 496k | 522k | 538k | 551k | No wifi sleep
+| | | | | | | |
+| MY_LANGUAGE en-GB | x | x | x | x | x | x |
+| MQTT_LIBRARY_TYPE PUBSUBCLIENT | x | x | x | x | x | x |
+| USE_WPS | - | - | x | - | - | - | WPS
+| USE_SMARTCONFIG | - | - | x | - | - | - | SmartConfig
+| USE_ARDUINO_OTA | - | - | - | - | - | - |
+| USE_DOMOTICZ | - | - | x | x | x | x |
+| USE_HOME_ASSISTANT | - | - | - | x | x | x |
+| USE_MQTT_TLS | - | - | - | - | - | - |
+| USE_KNX | - | - | - | - | x | - |
+| USE_WEBSERVER | x | x | x | x | x | x | WifiManager
+| USE_EMULATION | - | x | x | x | - | x |
+| USE_DISCOVERY | - | - | x | x | x | x |
+| WEBSERVER_ADVERTISE | - | - | x | x | x | x |
+| MQTT_HOST_DISCOVERY | - | - | x | x | x | x |
+| USE_TIMERS | - | x | - | x | x | x |
+| USE_TIMERS_WEB | - | x | - | x | x | x |
+| USE_SUNRISE | - | x | - | x | x | x |
+| USE_RULES | - | x | - | x | x | x |
| | | | | | |
-| USE_ADC_VCC | x | x | x | x | x |
-| USE_DS18B20 | - | - | - | - | - | Single sensor
-| USE_DS18x20 | - | x | x | x | x | Multiple sensors
-| USE_DS18x20_LEGACY | - | - | - | - | - | Multiple sensors
-| | | | | | |
-| Feature or Sensor | minimal | classic | sonoff | knx | sensors |
-| USE_I2C | - | - | x | x | x |
-| USE_SHT | - | - | x | x | x |
-| USE_HTU | - | - | x | x | x |
-| USE_BMP | - | - | x | x | x |
-| USE_BME680 | - | - | - | - | x |
-| USE_BH1750 | - | - | x | x | x |
-| USE_VEML6070 | - | - | - | - | x |
-| USE_ADS1115 | - | - | - | - | x |
-| USE_ADS1115_I2CDEV | - | - | - | - | - |
-| USE_INA219 | - | - | - | - | x |
-| USE_SHT3X | - | - | x | x | x |
-| USE_TSL2561 | - | - | - | - | x |
-| USE_MGS | - | - | - | - | x |
-| USE_SGP30 | - | - | x | x | x |
-| USE_SI1145 | - | - | - | - | x |
-| USE_LM75AD | - | - | x | x | x |
-| USE_APDS9960 | - | - | - | - | - |
-| USE_MCP230xx | - | - | - | - | - |
-| USE_MPR121 | - | - | - | - | - |
-| USE_CCS811 | - | - | - | - | - |
-| USE_MPU6050 | - | - | - | - | - |
-| | | | | | |
-| Feature or Sensor | minimal | classic | sonoff | knx | sensors |
-| USE_SPI | - | - | - | - | - |
-| USE_MHZ19 | - | - | x | x | x |
-| USE_SENSEAIR | - | - | x | x | x |
-| USE_PMS5003 | - | - | x | x | x |
-| USE_NOVA_SDS | - | - | x | x | x |
-| USE_PZEM004T | - | - | x | x | x |
-| USE_SERIAL_BRIDGE | - | - | x | x | x |
-| USE_SDM120 | - | - | - | - | x |
-| USE_SDM630 | - | - | - | - | x |
-| USE_IR_REMOTE | - | - | x | x | x |
-| USE_IR_HVAC | - | - | - | - | x |
-| USE_IR_RECEIVE | - | - | x | x | x |
-| USE_WS2812 | - | x | x | x | x |
-| USE_WS2812_DMA | - | - | - | - | - |
-| USE_ARILUX_RF | - | - | x | x | x |
-| USE_SR04 | - | - | x | x | x |
-| USE_TM1638 | - | - | - | - | - |
-| USE_RF_FLASH | - | - | x | x | x |
+| USE_ADC_VCC | x | x | x | x | x | - |
+| USE_DS18B20 | - | - | - | - | - | - | Single sensor
+| USE_DS18x20 | - | - | x | x | x | x | Multiple sensors
+| USE_DS18x20_LEGACY | - | - | - | - | - | - | Multiple sensors
+| | | | | | | |
+| Feature or Sensor | minimal | basic | classic | sonoff | knx | sensors |
+| USE_I2C | - | - | - | x | x | x |
+| USE_SHT | - | - | - | x | x | x |
+| USE_HTU | - | - | - | x | x | x |
+| USE_BMP | - | - | - | x | x | x |
+| USE_BME680 | - | - | - | - | - | x |
+| USE_BH1750 | - | - | - | x | x | x |
+| USE_VEML6070 | - | - | - | - | - | x |
+| USE_ADS1115 | - | - | - | - | - | x |
+| USE_ADS1115_I2CDEV | - | - | - | - | - | - |
+| USE_INA219 | - | - | - | - | - | x |
+| USE_SHT3X | - | - | - | x | x | x |
+| USE_TSL2561 | - | - | - | - | - | x |
+| USE_MGS | - | - | - | - | - | x |
+| USE_SGP30 | - | - | - | x | x | x |
+| USE_SI1145 | - | - | - | - | - | x |
+| USE_LM75AD | - | - | - | x | x | x |
+| USE_APDS9960 | - | - | - | - | - | - |
+| USE_MCP230xx | - | - | - | - | - | - |
+| USE_PCA9685 | - | - | - | - | - | - |
+| USE_MPR121 | - | - | - | - | - | - |
+| USE_CCS811 | - | - | - | - | - | - |
+| USE_MPU6050 | - | - | - | - | - | - |
+| USE_DS3231 | - | - | - | - | - | - |
+| USE_MGC3130 | - | - | - | - | - | - |
+| | | | | | | |
+| Feature or Sensor | minimal | basic | classic | sonoff | knx | sensors |
+| USE_SPI | - | - | - | - | - | - |
+| USE_MHZ19 | - | - | - | x | x | x |
+| USE_SENSEAIR | - | - | - | x | x | x |
+| USE_PMS5003 | - | - | - | x | x | x |
+| USE_NOVA_SDS | - | - | - | x | x | x |
+| USE_PZEM004T | - | - | - | x | x | x |
+| USE_PZEM_AC | - | - | - | x | x | x |
+| USE_PZEM_DC | - | - | - | x | x | x |
+| USE_MCP39F501 | - | x | - | x | x | x |
+| USE_SERIAL_BRIDGE | - | - | - | x | x | x |
+| USE_SDM120 | - | - | - | - | - | x |
+| USE_SDM630 | - | - | - | - | - | x |
+| USE_MP3_PLAYER | - | - | - | - | - | x |
+| USE_TUYA_DIMMER | - | x | - | x | x | x |
+| USE_ARMTRONIX_DIMMERS | - | x | - | x | x | x |
+| USE_PS_16_DZ | - | x | - | x | x | x |
+| USE_AZ7798 | - | - | - | - | - | - |
+| USE_IR_REMOTE | - | - | - | x | x | x |
+| USE_IR_HVAC | - | - | - | - | - | x |
+| USE_IR_RECEIVE | - | - | - | x | x | x |
+| USE_WS2812 | - | - | x | x | x | x |
+| USE_WS2812_DMA | - | - | - | - | - | - |
+| USE_ARILUX_RF | - | - | - | x | x | x |
+| USE_SR04 | - | - | - | x | x | x |
+| USE_TM1638 | - | - | - | - | - | x |
+| USE_HX711 | - | - | - | x | x | x |
+| USE_RF_FLASH | - | - | - | x | x | x |
+| USE_TX20_WIND_SENSOR | - | - | - | x | x | x |
+| USE_RC_SWITCH | - | - | - | x | x | x |
+| USE_RF_SENSOR | - | - | - | - | - | x | AlectoV2 only
+| USE_DISPLAY | - | - | - | - | - | - |
## Changelog
-Version 6.2.0 20180901
- * Allow user override of define MAX_RULE_VARS and MAX_RULE_TIMERS (#3561)
- * Disable wifi sleep for both Esp8266/Arduino core 2.4.1 and 2.4.2 to solve device freeze caused by Espressif SDK bug (#3554)
- * Change DS18B20 driver to provide better instant results
- * Change some sensor drivers to provide instant results
- * Change define USE_ALL_SENSORS to USE_SENSORS as it doesn't contain all sensors due to duplicate I2C addresses
- * Change some sensor update timings: AdcEvery 200 -> 250, Senseair 300 -> 250, SDM120 300 -> 250, SDM630 300 -> 250
- * Change default Wifi config option from WPS to Wifi Manager if WPS is disabled or Wifi Smartconfig if webserver is disabled or Wifi Serial input if Smartconfig is disabled
- * Change SHT1x driver to provide better instant results and fix I2C interference
- * Change DHT driver to provide better instant results and add decimals to DHT11 (#3164)
- * Change DS18x20 driver to provide better instant results (#3169)
- * Change CounterType 1 from milliseconds to microseconds (#3437)
- * Change scheduler for better sleep support using Uptime, Delay, PulseTime and TelePeriod, Blinktime (#3581)
- * Remove unused functionality from Sonoff-minimal to save space
- * Remove WPS and SmartConfig from sonoff-minimal saving 56k code space
- * Remove TSL2561 debug message and update library (#2415)
- * Remove forced restart when sleep command is executed (#3554)
- * Fix invalid response using more than 4 switches and domoticz
- * Fix sonoff-minimal not using default settings
- * Fix unsecure main webpage update
- * Fix DHT driver mixing values for different sensors (#1797)
- * Fix EnergyReset3 regression not clearing total energy (#2723)
- * Fix rules once regression from v6.1.0 (#3198, #3226)
- * Fix command Scale buffer overflow (#3236)
- * Fix possible WDT due to long MQTT publish handling (#3313)
- * Fix command TimeDst/TimeStd invalid JSON (#3322)
- * Fix handling of default names when using names starting with shortcut character ",0,1 or 2 (#3392, #3600, #3618)
- * Fix LM75AD I2C sensor detection (#3408)
- * Fix iFan02 power on state (#3412, #3530)
- * Fix some Pow R2 and S31 checksum errors using optimized re-sync (#3425)
- * Fix SDM120 reporting wrong negative values to Domoticz (#3521)
- * Fix MQTT reconnection detection when using TasmotaMqtt library (#3558)
- * Fix OtaMagic when file path contains a dash (-) (#3563)
- * Fix Sonoff Bridge data reception when using Portisch EFM8 firmware using in data buffer length (#3605)
- * Add read sensor retry to DS18B20, DS18x20, DHT, SHT1X and HTU21
- * Add user selection of Wifi Smartconfig as define USE_SMARTCONFIG in user_config.h
- * Add boot loop detection and perform some solutions
- * Add wifi and mqtt status led blinkyblinky to be disabled by SetOption31 1. Does not work when LedPower is On (deliberate) (#871, #2230, #3114, #3155)
- * Add support for TM1638 switch (#2226)
- * Add GPIO options ButtonXn, SwitchXn and CounterXn to select INPUT mode instead of INPUT_PULLUP (#2525)
- * Add support for APDS9960 proximity sensor (#3051)
- * Add support for MPR121 controller in input mode for touch buttons (#3142)
- * Add support for MCP230xx for general purpose input expansion and command Sensor29 (#3188)
- * Add default Wifi Configuration tool as define WIFI_CONFIG_NO_SSID in user_config.h if no SSID is configured (#3224)
- * Add command Timers 0/1 to globally disable or enable armed timers (#3270)
- * Add support for CCS811 sensor (#3309)
- * Add Turkish language file (#3332)
- * Add command SerialSend4 to send binary serial data (#3345)
- * Add initial support for sensor MPU6050 (#3352)
- * Add rule triggers Wifi#Connected and Wifi#Disconnected (#3359)
- * Add option + to command Rule to concatenate new rule with existing rules (#3365)
- * Add message when JavaScript is not enabled in webbrowser (#3388)
- * Add build time setting of ButtonTopic and SwitchTopic (#3414)
- * Add iFan02 Fanspeed + and Fanspeed - command options (#3415)
- * Add Individual HSBColorX commands (#3430, #3615)
- * Add output support on MCP23008/MCP23017 (#3436)
- * Add modulo option to rules like rule1 on Time#Minute|5 do backlog power on;delay 200;power off endon (#3466)
- * Add RGB support for Domoticz (#3547)
- * Add all ruletimer values to command RuleTimer result message (#3571)
- * Add command Publish2 for publishing retained MQTT messages (#3593)
- * Add commands ButtonDebounce 40..1000 and SwitchDebounce 40..1000 to have user control over debounce timing. Default is 50mS (#3594)
- * Add RuleX debug options 8,9,10 (StopOnError) to control RuleX execution status after an exception restart (#3607)
- * Add rule variables %sunrise%, %sunset%, %uptime% and %time% (#3608)
- * Add optional MQTT_TELE_RETAIN to Energy Margins message (#3612, 3614)
+Version 6.4.1 20181225
+ * Change RAM usage BMP/BME I2C sensors
+ * Change FallbackTopic from cmnd/\