chriz/OpenMQTT-Gateway
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity
Files
235413a3cda49dfecff1ab3de37f3bcdfd328b95
OpenMQTT-Gateway/main/ZgatewayIR.ino
T
Florian 3a4ccdcc9f Update ESP IR library & IR gateway improvments (#480) 
* update irremoteesp8266

* add new protocols, simplify API and publish protocol name

-added the following protocols:
  #define IR_LEGOPF
  #define IR_MITSUBISHI_HEAVY_88
  #define IR_MITSUBISHI_HEAVY_152
  #define IR_DAIKIN216
  #define IR_SHARP_AC
  #define IR_GOODWEATHER
  #define IR_INAX
  #define IR_DAIKIN160
  #define IR_NEOCLIMA
  #define IR_DAIKIN176
  #define IR_DAIKIN128
  #define IR_AMCOR
  #define IR_DAIKIN152
  #define IR_MITSUBISHI136
  #define IR_MITSUBISHI112
  #define IR_HITACHI_AC424
-changed the send API, now you can use the protocol name directly exemple NEC instead of IR_NEC
-publish the protocol name to MQTT added to the number
-replace long by long long

* missing repeat definitions

and set default repeat value to 0

* move protocol name retrieving outside arduino scope

* put all protocols with capital letters

* modify doc

* add long long activation for arduino json on test_config file
2019-11-02 12:49:05 +01:00

945 lines
34 KiB
Arduino
Raw Blame History

/*
OpenMQTTGateway - ESP8266 or Arduino program for home automation
Act as a wifi or ethernet gateway between your 433mhz/infrared IR signal and a MQTT broker
Send and receiving command by MQTT
This gateway enables to:
- receive MQTT data from a topic and send IR signal corresponding to the received MQTT data
- publish MQTT data to a different topic related to received IR signal
Copyright: (c)Florian ROBERT
This file is part of OpenMQTTGateway.
OpenMQTTGateway is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenMQTTGateway is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "User_config.h"
#ifdef ZgatewayIR
#if defined(ESP8266) || defined(ESP32)
#include <IRremoteESP8266.h>
#include <IRsend.h> // Needed if you want to send IR commands.
#include <IRrecv.h> // Needed if you want to receive IR commands.
#include <IRutils.h>
#ifdef DumpMode // in dump mode we increase the size of the buffer to catch big codes
IRrecv irrecv(IR_RECEIVER_PIN, 1024, 15U, true);
#else
IRrecv irrecv(IR_RECEIVER_PIN);
#endif
IRsend irsend(IR_EMITTER_PIN);
#else
#include <IRremote.h>
IRrecv irrecv(IR_RECEIVER_PIN);
IRsend irsend; //connect IR emitter pin to D9 on arduino, you need to comment #define IR_USE_TIMER2 and uncomment #define IR_USE_TIMER1 on library IRremote.h so as to free pin D3 for RF RECEIVER PIN
#endif
// IR protocol bits definition for Arduino (for ESP9266 they are defined in IRRemoteESP8266.h)
#ifndef NEC_BITS
#define NEC_BITS 32U
#endif
#ifndef SAMSUNG_BITS
#define SAMSUNG_BITS 32U
#endif
#ifndef SHARP_BITS
#define SHARP_ADDRESS_BITS 5U
#define SHARP_COMMAND_BITS 8U
#define SHARP_BITS (SHARP_ADDRESS_BITS + SHARP_COMMAND_BITS + 2) // 15U
#endif
#ifndef RC5_BITS
#define RC5_RAW_BITS 14U
#define RC5_BITS RC5_RAW_BITS - 2U
#endif
#ifndef DISH_BITS
#define DISH_BITS 16U
#endif
#ifndef SONY_12_BITS
#define SONY_12_BITS 12U
#endif
#ifndef LG_BITS
#define LG_BITS 28U
#endif
#ifndef WHYNTER_BITS
#define WHYNTER_BITS 32U
#endif
void setupIR(){
//IR init parameters
#if defined(ESP8266) || defined(ESP32)
irsend.begin();
#endif
irrecv.enableIRIn(); // Start the receiver
trc(F("IR_EMITTER_PIN "));
trc(IR_EMITTER_PIN);
trc(F("IR_RECEIVER_PIN "));
trc(IR_RECEIVER_PIN);
trc(F("ZgatewayIR setup done "));
}
void IRtoMQTT(){
decode_results results;
if (irrecv.decode(&results)){
trc(F("Creating IR buffer"));
StaticJsonBuffer<JSON_MSG_BUFFER> jsonBuffer;
JsonObject& IRdata = jsonBuffer.createObject();
trc(F("Rcv. IR"));
#ifdef ESP32
String taskMessage = "Task running on core ";
taskMessage = taskMessage + xPortGetCoreID();
trc(taskMessage);
#endif
IRdata.set("value", (unsigned long)(results.value));
IRdata.set("protocol", (int)(results.decode_type));
IRdata.set("bits",(int)(results.bits));
#if defined(ESP8266) || defined(ESP32) //resultToHexidecimal is only available with IRremoteESP8266
String hex = resultToHexidecimal(&results);
IRdata.set("hex", (char *)hex.c_str());
IRdata.set("protocol_name", (char *)(typeToString(results.decode_type,false)).c_str());
#endif
String rawCode = "";
// Dump data
for (uint16_t i = 1; i < results.rawlen; i++) {
#if defined(ESP8266) || defined(ESP32)
if (i % 100 == 0) yield(); // Preemptive yield every 100th entry to feed the WDT.
rawCode = rawCode + (results.rawbuf[i] * RAWTICK);
#else
rawCode = rawCode + (results.rawbuf[i] * USECPERTICK);
#endif
if ( i < results.rawlen-1 ) rawCode = rawCode + ","; // ',' not needed on last one
}
trc(rawCode);
IRdata.set("raw", rawCode);
// if needed we directly resend the raw code
#ifdef RawDirectForward
#if defined(ESP8266) || defined(ESP32)
uint16_t rawsend[results.rawlen];
for (uint16_t i = 1; i < results.rawlen; i++) {
if (i % 100 == 0) yield(); // Preemptive yield every 100th entry to feed the WDT.
#else
unsigned int rawsend[results.rawlen];
for (int i = 1; i < results.rawlen; i++) {
#endif
rawsend[i] = results.rawbuf[i];
}
irsend.sendRaw(rawsend, results.rawlen, RawFrequency);
trc(F("raw redirected"));
#endif
irrecv.resume(); // Receive the next value
unsigned long MQTTvalue = IRdata.get<unsigned long long>("value");
trc(MQTTvalue);
if ((pubIRunknownPrtcl == false && IRdata.get<int>("protocol") == -1 )/*|| MQTTvalue == ULONG_MAX*/){ // don't publish unknown IR protocol or data to high
trc(F("--no pub unknwn prt or data to high--"));
} else if (!isAduplicate(MQTTvalue) && MQTTvalue!=0) {// conditions to avoid duplications of IR -->MQTT
trc(F("Adv data IRtoMQTT"));
pub(subjectIRtoMQTT,IRdata);
trc(F("Store val"));
storeValue(MQTTvalue);
if (repeatIRwMQTT){
trc(F("Pub. IR for rpt"));
pub(subjectMQTTtoIR,MQTTvalue);
}
}
}
}
#ifdef simpleReceiving
void MQTTtoIR(char * topicOri, char * datacallback) {
// IR DATA ANALYSIS
//send received MQTT value by IR signal
bool signalSent = false;
uint64_t data = 0;
String strcallback = String(datacallback);
trc(datacallback);
unsigned int s = strcallback.length();
//number of "," value count
int count = 0;
for(int i = 0; i < s; i++)
{
if (datacallback[i] == ',') {
count++;
}
}
if(count == 0){
data = strtoul(datacallback, NULL, 10); // standard sending with unsigned long, we will not be able to pass values > 4294967295
}
#ifdef IR_GC
else if(strstr(topicOri, "GC") != NULL){ // sending GC data from https://irdb.globalcache.com
trc(F("GC"));
//buffer allocation from char datacallback
uint16_t GC[count+1];
String value = "";
int j = 0;
for(int i = 0; i < s; i++)
{
if (datacallback[i] != ',') {
value = value + String(datacallback[i]);
}
if ((datacallback[i] == ',') || (i == s - 1))
{
GC[j]= value.toInt();
value = "";
j++;
}
}
irsend.sendGC(GC, j);
signalSent = true;
}
#endif
#ifdef IR_RAW
else if(strstr(topicOri, "Raw") != NULL){ // sending Raw data
trc(F("Raw"));
//buffer allocation from char datacallback
#if defined(ESP8266) || defined(ESP32)
uint16_t Raw[count+1];
#else
unsigned int Raw[count+1];
#endif
String value = "";
int j = 0;
for(int i = 0; i < s; i++)
{
if (datacallback[i] != ',') {
value = value + String(datacallback[i]);
}
if ((datacallback[i] == ',') || (i == s - 1))
{
Raw[j]= value.toInt();
value = "";
j++;
}
}
irsend.sendRaw(Raw, j, RawFrequency);
signalSent = true;
}
#endif
//We look into the subject to see if a special Bits number is defined
String topic = topicOri;
unsigned int valueBITS = 0;
int pos = topic.lastIndexOf(IRbitsKey);
if (pos != -1){
pos = pos + +strlen(IRbitsKey);
valueBITS = (topic.substring(pos,pos + 2)).toInt();
trc(F("Bits nb:"));
trc(valueBITS);
}
//We look into the subject to see if a special repeat number is defined
uint16_t valueRPT = 0;
int pos2 = topic.lastIndexOf(IRRptKey);
if (pos2 != -1) {
pos2 = pos2 + strlen(IRRptKey);
valueRPT = (topic.substring(pos2,pos2 + 1)).toInt();
trc(F("IR repeat:"));
trc(valueRPT);
}
if(topicOri && (strstr(topicOri, "NEC") == NULL)){
trc("SendId prt");
signalSent = sendIdentifiedProtocol(topicOri, data, datacallback, valueBITS, valueRPT);
}else{
trc(F("Not identified prt using NEC"));
if (valueBITS == 0) valueBITS = NEC_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendNEC(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendNEC(data, valueBITS);
#endif
signalSent = true;
}
if (signalSent){ // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
pub(subjectGTWIRtoMQTT, datacallback);
}
irrecv.enableIRIn(); // ReStart the IR receiver (if not restarted it is not able to receive data)
}
#endif
#ifdef jsonReceiving
void MQTTtoIR(char * topicOri, JsonObject& IRdata) {
if (strcmp(topicOri,subjectMQTTtoIR) == 0){
trc(F("MQTTtoIR json"));
uint64_t data = IRdata["value"];
const char * raw = IRdata["raw"];
const char * datastring = IRdata["datastring"];
if (data != 0 || raw || datastring) {
trc(F("MQTTtoIR value || raw || datasring ok"));
bool signalSent = false;
if(datastring){
trc(F("datastring"));
trc(datastring);
}else{
datastring ="";
}
const char * protocol_name = IRdata["protocol_name"];
unsigned int valueBITS = IRdata["bits"]|0;
uint16_t valueRPT = IRdata["repeat"]|repeatIRwNumber;
if(raw){
trc(F("raw"));
trc(raw);
unsigned int s = strlen(raw);
//number of "," value count
int count = 0;
for(int i = 0; i < s; i++)
{
if (raw[i] == ',') {
count++;
}
}
#ifdef IR_GC
if(strstr(protocol_name, "GC") != NULL){ // sending GC data from https://irdb.globalcache.com
trc(F("GC"));
//buffer allocation from char datacallback
uint16_t GC[count+1];
String value = "";
int j = 0;
for(int i = 0; i < s; i++)
{
if (raw[i] != ',') {
value = value + String(raw[i]);
}
if ((raw[i] == ',') || (i == s - 1))
{
GC[j]= value.toInt();
value = "";
j++;
}
}
irsend.sendGC(GC, j);
signalSent = true;
}
#endif
#ifdef IR_RAW
if(strstr(protocol_name, "Raw") != NULL){ // sending Raw data
trc(F("Raw"));
//buffer allocation from char datacallback
#if defined(ESP8266) || defined(ESP32)
uint16_t Raw[count+1];
#else
unsigned int Raw[count+1];
#endif
String value = "";
int j = 0;
for(int i = 0; i < s; i++)
{
if (raw[i] != ',') {
value = value + String(raw[i]);
}
if ((raw[i] == ',') || (i == s - 1))
{
Raw[j]= value.toInt();
value = "";
j++;
}
}
irsend.sendRaw(Raw, j, RawFrequency);
signalSent = true;
}
#endif
}else if(protocol_name && (strstr(protocol_name, "NEC") == NULL)){
signalSent = sendIdentifiedProtocol(protocol_name, data, datastring, valueBITS, valueRPT);
}else{
trc(F("Using NEC protocol"));
if (valueBITS == 0) valueBITS = NEC_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendNEC(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendNEC(data, valueBITS);
#endif
signalSent = true;
}
if (signalSent){ // we acknowledge the sending by publishing the value to an acknowledgement topic, for the moment even if it is a signal repetition we acknowledge also
trc(F("MQTTtoIR OK"));
pub(subjectGTWIRtoMQTT, IRdata);
}
irrecv.enableIRIn(); // ReStart the IR receiver (if not restarted it is not able to receive data)
}else{
trc(F("MQTTtoIR failed json read"));
}
}
}
#endif
bool sendIdentifiedProtocol(const char * protocol_name, unsigned long long data, const char * datastring, unsigned int valueBITS, uint16_t valueRPT){
unsigned char dataarray[valueBITS];
const char* pointer = datastring;
int i = 0;
while (strlen(pointer) > 0 && i < valueBITS) {
if (pointer[0] == ',') {
pointer++;
}
else
{
dataarray[i] = strtol(pointer, (char**)& pointer, 16);
i++;
}
}
#ifdef IR_WHYNTER
if (strstr(protocol_name, "WHYNTER") != NULL){
if (valueBITS == 0) valueBITS = WHYNTER_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendWhynter(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendWhynter(data, valueBITS);
#endif
return true;
}
#endif
#ifdef IR_LG
if (strstr(protocol_name, "LG") != NULL){
if (valueBITS == 0) valueBITS = LG_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendLG(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendLG(data, valueBITS);
#endif
return true;
}
#endif
#ifdef IR_SONY
if (strstr(protocol_name, "SONY") != NULL){
if (valueBITS == 0) valueBITS = SONY_12_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendSony(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendSony(data, valueBITS);
#endif
return true;
}
#endif
#ifdef IR_DISH
if (strstr(protocol_name, "DISH") != NULL){
if (valueBITS == 0) valueBITS = DISH_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendDISH(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendDISH(data, valueBITS);
#endif
return true;
}
#endif
#ifdef IR_RC5
if (strstr(protocol_name, "RC5") != NULL){
if (valueBITS == 0) valueBITS = RC5_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendRC5(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendRC5(data, valueBITS);
#endif
return true;
}
#endif
#ifdef IR_RC6
if (strstr(protocol_name, "RC6") != NULL){
if (valueBITS == 0) valueBITS = RC6_MODE0_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendRC6(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendRC6(data, valueBITS);
#endif
return true;
}
#endif
#ifdef IR_SHARP
if (strstr(protocol_name, "SHARP") != NULL){
if (valueBITS == 0) valueBITS = SHARP_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendSharpRaw(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendSharpRaw(data, valueBITS);
#endif
return true;
}
#endif
#ifdef IR_SAMSUNG
if (strstr(protocol_name, "SAMSUNG") != NULL){
if (valueBITS == 0) valueBITS = SAMSUNG_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendSAMSUNG(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendSAMSUNG(data, valueBITS);
#endif
return true;
}
#endif
#ifdef IR_JVC
if (strstr(protocol_name, "JVC") != NULL){
if (valueBITS == 0) valueBITS = JVC_BITS;
#if defined(ESP8266) || defined(ESP32)
irsend.sendJVC(data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendJVC(data, valueBITS);
#endif
return true;
}
#endif
#ifdef IR_PANASONIC
if (strstr(protocol_name, "PANASONIC") != NULL){
#if defined(ESP8266) || defined(ESP32)
if (valueBITS == 0) valueBITS = PANASONIC_BITS;
irsend.sendPanasonic(PanasonicAddress, data, valueBITS, valueRPT);
#else
for (int i=0; i <= valueRPT; i++) irsend.sendPanasonic(PanasonicAddress, data);
#endif
return true;
}
#endif
#if defined(ESP8266) || defined(ESP32) // sendings not available on arduino
#ifdef IR_COOLIX
if (strstr(protocol_name, "COOLIX") != NULL){
if (valueBITS == 0) valueBITS = kCoolixBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kCoolixDefaultRepeat);
irsend.sendCOOLIX(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_RCMM
if (strstr(protocol_name, "RCMM") != NULL){
if (valueBITS == 0) valueBITS = kRCMMBits;
irsend.sendRCMM(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_DENON
if (strstr(protocol_name, "DENON") != NULL){
if (valueBITS == 0) valueBITS = DENON_BITS;
irsend.sendDenon(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_GICABLE
if (strstr(protocol_name, "GICABLE") != NULL){
if (valueBITS == 0) valueBITS = kGicableBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kGicableMinRepeat);
irsend.sendGICable(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_SHERWOOD
if (strstr(protocol_name, "SHERWOOD") != NULL){
if (valueBITS == 0) valueBITS = kSherwoodBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kSherwoodMinRepeat);
irsend.sendSherwood(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MITSUBISHI
if (strstr(protocol_name, "MITSUBISHI") != NULL){
if (valueBITS == 0) valueBITS = kMitsubishiBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kMitsubishiMinRepeat);
irsend.sendMitsubishi(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_NIKAI
if (strstr(protocol_name, "NIKAI") != NULL){
if (valueBITS == 0) valueBITS = kNikaiBits;
irsend.sendNikai(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MIDEA
if (strstr(protocol_name, "MIDEA") != NULL){
if (valueBITS == 0) valueBITS = kMideaBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kMideaMinRepeat);
irsend.sendMidea(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MAGIQUEST
if (strstr(protocol_name, "MAGIQUEST") != NULL){
if (valueBITS == 0) valueBITS = kMagiquestBits;
irsend.sendMagiQuest(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_LASERTAG
if (strstr(protocol_name, "LASERTAG") != NULL){
if (valueBITS == 0) valueBITS = kLasertagBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kLasertagMinRepeat);
irsend.sendLasertag(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_CARRIER_AC
if (strstr(protocol_name, "CARRIER_AC") != NULL){
if (valueBITS == 0) valueBITS = kCarrierAcBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kCarrierAcMinRepeat);
irsend.sendCarrierAC(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MITSUBISHI2
if (strstr(protocol_name, "MITSUBISHI2") != NULL){
if (valueBITS == 0) valueBITS = kMitsubishiBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kMitsubishiMinRepeat);
irsend.sendMitsubishi2(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_AIWA_RC_T501
if (strstr(protocol_name, "AIWA_RC_T501") != NULL){
if (valueBITS == 0) valueBITS = kAiwaRcT501Bits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kAiwaRcT501MinRepeats);
irsend.sendAiwaRCT501(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_DAIKIN
if (strstr(protocol_name, "DAIKIN") != NULL){
if (valueBITS == 0) valueBITS = kDaikinStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kDaikinDefaultRepeat);
irsend.sendDaikin(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_KELVINATOR
if (strstr(protocol_name, "KELVINATOR") != NULL){
if (valueBITS == 0) valueBITS = kKelvinatorStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kKelvinatorDefaultRepeat);
irsend.sendKelvinator(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MITSUBISHI_AC
if (strstr(protocol_name, "MITSUBISHI_AC") != NULL){
if (valueBITS == 0) valueBITS = kMitsubishiACStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kMitsubishiACMinRepeat);
irsend.sendMitsubishiAC(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_SANYO
if (strstr(protocol_name, "SANYOLC7461") != NULL){
if (valueBITS == 0) valueBITS = kSanyoLC7461Bits;
irsend.sendSanyoLC7461(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_GREE
if (strstr(protocol_name, "GREE") != NULL){
if (valueBITS == 0) valueBITS = kGreeStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kGreeDefaultRepeat);
irsend.sendGree(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_ARGO
if (strstr(protocol_name, "ARGO") != NULL){
if (valueBITS == 0) valueBITS = kArgoStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kArgoDefaultRepeat);
irsend.sendArgo(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_TROTEC
if (strstr(protocol_name, "TROTEC") != NULL){
if (valueBITS == 0) valueBITS = kTrotecStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kTrotecDefaultRepeat);
irsend.sendTrotec(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_TOSHIBA_AC
if (strstr(protocol_name, "TOSHIBA_AC") != NULL){
if (valueBITS == 0) valueBITS = kToshibaACBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kToshibaACMinRepeat);
irsend.sendToshibaAC(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_FUJITSU_AC
if (strstr(protocol_name, "FUJITSU_AC") != NULL){
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kFujitsuAcMinRepeat);
irsend.sendFujitsuAC(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_HAIER_AC
if (strstr(protocol_name, "HAIER_AC") != NULL){
if (valueBITS == 0) valueBITS = kHaierACStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kHaierAcDefaultRepeat);
irsend.sendHaierAC(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_HITACHI_AC
if (strstr(protocol_name, "HITACHI_AC") != NULL){
if (valueBITS == 0) valueBITS = kHitachiAcStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kHitachiAcDefaultRepeat);
irsend.sendHitachiAC(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_HITACHI_AC1
if (strstr(protocol_name, "HITACHI_AC1") != NULL){
if (valueBITS == 0) valueBITS = kHitachiAc1StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kHitachiAcDefaultRepeat);
irsend.sendHitachiAC1(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_HITACHI_AC2
if (strstr(protocol_name, "HITACHI_AC2") != NULL){
if (valueBITS == 0) valueBITS = kHitachiAc2StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kHitachiAcDefaultRepeat);
irsend.sendHitachiAC2(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_HAIER_AC_YRW02
if (strstr(protocol_name, "HAIER_AC_YRW02") != NULL){
if (valueBITS == 0) valueBITS = kHaierACYRW02StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kHaierAcYrw02DefaultRepeat);
irsend.sendHaierACYRW02(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_WHIRLPOOL_AC
if (strstr(protocol_name, "WHIRLPOOL_AC") != NULL){
if (valueBITS == 0) valueBITS = kWhirlpoolAcStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kWhirlpoolAcDefaultRepeat);
irsend.sendWhirlpoolAC(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_SAMSUNG_AC
if (strstr(protocol_name, "SAMSUNG_AC") != NULL){
if (valueBITS == 0) valueBITS = kSamsungAcStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kSamsungAcDefaultRepeat);
irsend.sendSamsungAC(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_LUTRON
if (strstr(protocol_name, "LUTRON") != NULL){
if (valueBITS == 0) valueBITS = kLutronBits;
irsend.sendLutron(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_ELECTRA_AC
if (strstr(protocol_name, "ELECTRA_AC") != NULL){
if (valueBITS == 0) valueBITS = kElectraAcStateLength;
irsend.sendElectraAC(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_PANASONIC_AC
if (strstr(protocol_name, "PANASONIC_AC") != NULL){
if (valueBITS == 0) valueBITS = kPanasonicAcStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kPanasonicAcDefaultRepeat);
irsend.sendPanasonicAC(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_PIONEER
if (strstr(protocol_name, "PIONEER") != NULL){
if (valueBITS == 0) valueBITS = kPioneerBits;
irsend.sendPioneer(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_LG2
if (strstr(protocol_name, "LG2") != NULL){
if (valueBITS == 0) valueBITS = kLgBits;
irsend.sendLG2(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MWM
if (strstr(protocol_name, "MWM") != NULL){
irsend.sendMWM(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_DAIKIN2
if (strstr(protocol_name, "DAIKIN2") != NULL){
if (valueBITS == 0) valueBITS = kDaikin2StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kDaikin2DefaultRepeat);
irsend.sendDaikin2(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_VESTEL_AC
if (strstr(protocol_name, "VESTEL_AC") != NULL){
if (valueBITS == 0) valueBITS = kVestelAcBits;
irsend.sendVestelAc(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_SAMSUNG36
if (strstr(protocol_name, "SAMSUNG36") != NULL){
if (valueBITS == 0) valueBITS = kSamsung36Bits;
irsend.sendSamsung36(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_TCL112AC
if (strstr(protocol_name, "TCL112AC") != NULL){
if (valueBITS == 0) valueBITS = kTcl112AcStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kTcl112AcDefaultRepeat);
irsend.sendTcl112Ac(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_TECO
if (strstr(protocol_name, "TECO") != NULL){
if (valueBITS == 0) valueBITS = kTecoBits;
irsend.sendTeco(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_LEGOPF
if (strstr(protocol_name, "LEGOPF") != NULL){
if (valueBITS == 0) valueBITS = kLegoPfBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kLegoPfMinRepeat);
irsend.sendLegoPf(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MITSUBISHIHEAVY88
if (strstr(protocol_name, "MITSUBISHIHEAVY88") != NULL){
if (valueBITS == 0) valueBITS = kMitsubishiHeavy88StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kMitsubishiHeavy88MinRepeat);
irsend.sendMitsubishiHeavy88(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MITSUBISHIHEAVY152
if (strstr(protocol_name, "MITSUBISHIHEAVY152") != NULL){
if (valueBITS == 0) valueBITS = kMitsubishiHeavy152StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kMitsubishiHeavy152MinRepeat);
irsend.sendMitsubishiHeavy152(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_DAIKIN216
if (strstr(protocol_name, "DAIKIN216") != NULL){
if (valueBITS == 0) valueBITS = kDaikin216StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kDaikin216DefaultRepeat);
irsend.sendDaikin216(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_SHARP_AC
if (strstr(protocol_name, "SHARP_AC") != NULL){
if (valueBITS == 0) valueBITS = kSharpAcStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kSharpAcDefaultRepeat);
irsend.sendSharpAc(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_GOODWEATHER
if (strstr(protocol_name, "GOODWEATHER_AC") != NULL){
if (valueBITS == 0) valueBITS = kGoodweatherBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kGoodweatherMinRepeat);
irsend.sendGoodweather(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_INAX
if (strstr(protocol_name, "INAX") != NULL){
if (valueBITS == 0) valueBITS = kInaxBits;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kInaxMinRepeat);
irsend.sendInax(data, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_DAIKIN160
if (strstr(protocol_name, "DAIKIN160") != NULL){
if (valueBITS == 0) valueBITS = kDaikin160StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kDaikin160DefaultRepeat);
irsend.sendDaikin160(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_NEOCLIMA
if (strstr(protocol_name, "NEOCLIMA") != NULL){
if (valueBITS == 0) valueBITS = kNeoclimaStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kNeoclimaMinRepeat);
irsend.sendNeoclima(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_DAIKIN176
if (strstr(protocol_name, "DAIKIN176") != NULL){
if (valueBITS == 0) valueBITS = kDaikin176StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kDaikin176DefaultRepeat);
irsend.sendDaikin176(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_DAIKIN128
if (strstr(protocol_name, "DAIKIN128") != NULL){
if (valueBITS == 0) valueBITS = kDaikin128StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kDaikin128DefaultRepeat);
irsend.sendDaikin128(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_AMCOR
if (strstr(protocol_name, "AMCOR") != NULL){
if (valueBITS == 0) valueBITS = kAmcorStateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kAmcorDefaultRepeat);
irsend.sendAmcor(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_DAIKIN152
if (strstr(protocol_name, "DAIKIN152") != NULL){
if (valueBITS == 0) valueBITS = kDaikin152StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kDaikin152DefaultRepeat);
irsend.sendDaikin152(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MITSUBISHI136
if (strstr(protocol_name, "MITSUBISHI136") != NULL){
if (valueBITS == 0) valueBITS = kMitsubishi136StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kMitsubishi136MinRepeat);
irsend.sendMitsubishi136(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_MITSUBISHI112
if (strstr(protocol_name, "MITSUBISHI112") != NULL){
if (valueBITS == 0) valueBITS = kMitsubishi112StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kMitsubishi112MinRepeat);
irsend.sendMitsubishi112(dataarray, valueBITS, valueRPT);
return true;
}
#endif
#ifdef IR_HITACHI_AC424
if (strstr(protocol_name, "HITACHI_AC424") != NULL){
if (valueBITS == 0) valueBITS = kHitachiAc424StateLength;
if (valueRPT == repeatIRwNumber) valueRPT = std::max(valueRPT, kHitachiAcDefaultRepeat);
irsend.sendHitachiAc424(dataarray, valueBITS, valueRPT);
return true;
}
#endif
return false;
#endif
}
#endif
Reference in new issue View Git Blame Copy Permalink