DashyFox/IR-protocol
1
0
Fork 0
mirror of https://github.com/Show-maket/IR-protocol.git synced 2025-05-04 07:10:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

non virtual

Browse Source
This commit is contained in:
DashyFox 2024-02-27 10:28:20 +03:00
parent 1f62eb8c0a
commit 4d92acf15b
6 changed files with 411 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
IR-Protocol.ino
View File

@ -116,7 +116,7 @@ Timer t1(730, millis, []() {
break; break;
case 30: case 30:
encForward.sendBackTo(targetAddr, data0, sizeof(data0)); encForward.sendBackTo(targetAddr);
break; break;
case 31: case 31:
encForward.sendBackTo(targetAddr, data1, sizeof(data1)); encForward.sendBackTo(targetAddr, data1, sizeof(data1));
@ -227,9 +227,6 @@ void loop() {
//test //test
void status(IR_Decoder& dec) { void status(IR_Decoder& dec) {
if (dec.gotData.available()) { if (dec.gotData.available()) {
String str; String str;
if (/* dec.gotData.getDataPrt()[1] */1) { if (/* dec.gotData.getDataPrt()[1] */1) {
@ -280,6 +277,56 @@ void status(IR_Decoder& dec) {
Serial.write(str.c_str()); Serial.write(str.c_str());
} }
if (dec.gotBackData.available()) {
String str;
if (/* dec.gotData.getDataPrt()[1] */1) {
str += ("BackData on pin "); str += (dec.isrPin); str += "\n";
uint8_t msg = dec.gotBackData.getMsgRAW();
str += (" MSG: ");
for (size_t i = 0; i < 8; i++) {
if (i == 3) str += " ";
str += (msg >> (7 - i)) & 1U;
}
str += "\n";
str += (" DATA SIZE: "); str += (dec.gotBackData.getDataSize()); str += "\n";
str += (" ADDRESS FROM: "); str += (dec.gotBackData.getAddrFrom()); str += "\n";
// str += (" ADDRESS TO: "); str += (dec.gotBackData.getAddrTo()); str += "\n";
// str += (" CRC PACK: "); str += (dec.gotBackData.getCrcIN()); str += "\n";
// str += (" CRC CALC: "); str += (dec.gotBackData.getCrcCALC()); str += "\n";
str += "\n";
for (size_t i = 0; i < min(10, dec.gotBackData.getDataSize()); i++) {
switch (i) {
// case 0:
// str += (" ADDR: ");
// break;
// case 1:
// str += (" CMD: ");
// break;
default:
str += (" Data["); str += (i); str += ("]: ");
break;
}
str += (dec.gotBackData.getDataPrt()[i]); str += "\n";
}
str += ("\n*******ErrAll: "); str += (dec.gotBackData.getErrorCount()); str += "\n";
str += ("**ErrDistance: "); str += ((int)(dec.gotBackData.getErrorHighSignal() - dec.gotBackData.getErrorLowSignal())); str += "\n";
str += "\n";
} else {
str += ("SELF"); str += "\n";
str += "\n";
}
// obj->resetAvailable();
Serial.write(str.c_str());
}
} }

208
IR_Decoder.h
View File

@ -4,219 +4,43 @@
class IR_Decoder : public IR_DecoderRaw { class IR_Decoder : public IR_DecoderRaw {
public: public:
PacketTypes::Data gotData;
PacketTypes::DataBack gotBackData;
PacketTypes::Accept gotAccept;
PacketTypes::Request gotRequest;
IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder* encPair = nullptr) : IR_DecoderRaw(isrPin, addr, encPair) { IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder* encPair = nullptr) : IR_DecoderRaw(isrPin, addr, encPair) {
} }
Data gotData;
void tick() { void tick() {
IR_DecoderRaw::tick(); IR_DecoderRaw::tick();
if (available()) { if (available()) {
#ifdef IRDEBUG_INFO
Serial.println("PARSING RAW DATA"); Serial.println("PARSING RAW DATA");
#endif
bool isNeenAccept = false;
switch (packInfo.buffer[0] >> 5 & IR_MASK_MSG_TYPE) { switch (packInfo.buffer[0] >> 5 & IR_MASK_MSG_TYPE) {
case IR_MSG_DATA_NOACCEPT:
gotData.set(&packInfo);
break;
case IR_MSG_DATA_ACCEPT: case IR_MSG_DATA_ACCEPT:
isNeenAccept = true;
case IR_MSG_DATA_NOACCEPT:
gotData.set(&packInfo, id);
break; break;
case IR_MSG_BACK: case IR_MSG_BACK:
break;
case IR_MSG_BACK_TO: case IR_MSG_BACK_TO:
gotBackData.set(&packInfo, id);
break; break;
case IR_MSG_REQUEST: case IR_MSG_REQUEST:
gotRequest.set(&packInfo, id);
break; break;
case IR_MSG_ACCEPT: case IR_MSG_ACCEPT:
gotAccept.set(&packInfo, id);
break; break;
default: default:
break; break;
} }
} }
} }
}; };
// class IDataPack : protected IR_FOX {
// friend IR_Decoder;
// public:
// IDataPack(IR_Decoder* dec) : dec(dec) {};
// public:
// bool available() { if (isAvailable) { isAvailable = false; return true; } else { return isAvailable; }; };
// virtual uint8_t getMsgInfo() { return msgPtr[0] & IR_MASK_MSG_INFO; };
// virtual uint8_t getMsgType() { return (msgPtr[0] >> 5) & IR_MASK_MSG_TYPE; };
// virtual uint8_t getMsgRAW() { return msgPtr[0]; };
// virtual uint16_t getErrorCount() { return err.all(); };
// virtual uint8_t getErrorLowSignal() { return err.lowSignal; };
// virtual uint8_t getErrorHighSignal() { return err.highSignal; };
// virtual uint8_t getErrorOther() { return err.other; };
// // uint16_t getCrcIN() { return crcPtr[0] << 8 | crcPtr[1]; };
// // uint16_t getCrcCALC() { return crcCalcVal; };
// virtual uint16_t getTunerTime() { return bitPeriod; };
// void resetAvailable() { isAvailable = false; };
// protected:
// inline static uint8_t data[dataByteSizeMax] { 0 };
// inline static uint8_t* msgPtr;
// inline static uint8_t* addrFromPtr;
// inline static uint8_t* addrToPtr;
// inline static uint8_t* dataPtr;
// inline static uint8_t* crcPtr;
// inline static ErrorsStruct err;
// inline static uint8_t packRawSize;
// inline static uint16_t bitPeriod;
// inline static uint16_t crcCalcVal;
// IR_Decoder* dec;
// bool isAvailable = false;
// virtual bool checkAddress(PackOutInfo* packInfo) {
// bool ret;
// uint8_t targetAddrOffset = packInfo->offsets.addrToOffset;
// uint16_t address = (packInfo->ptr[targetAddrOffset] << 8) | (packInfo->ptr[targetAddrOffset + 1]);
// checkaddressRuleApply(address, dec->id, ret);
// return ret;
// };
// virtual void onPackAddressCorrect(PackOutInfo* packInfo) {
// memset(IDataPack::data, 0, dataByteSizeMax);
// memcpy(data, packInfo->ptr, min(packInfo->packSize, dataByteSizeMax));
// err = packInfo->err;
// bitPeriod = packInfo->rTime;
// crcCalcVal = packInfo->crc;
// packRawSize = packInfo->packSize;
// msgPtr = (data + packInfo->offsets.msgOffset);
// addrFromPtr = (data + packInfo->offsets.addrFromOffset);
// addrToPtr = (data + packInfo->offsets.addrToOffset);
// dataPtr = (data + packInfo->offsets.dataOffset);
// crcPtr = (data + packInfo->offsets.crcOffset);
// }
// virtual void onPackAddressIncorrect(PackOutInfo* packInfo) {}
// virtual void afterSet() {}
// void set(PackOutInfo packInfo, bool isNeedAddressCheck) {
// isAvailable = false;
// if (!isNeedAddressCheck || checkAddress(&packInfo)) {
// onPackAddressCorrect(&packInfo);
// #ifdef IRDEBUG_INFO
// Serial.println(" OK ");
// #endif
// isAvailable = true;
// } else {
// onPackAddressIncorrect(&packInfo);
// #ifdef IRDEBUG_INFO
// Serial.println(" NOT MY ");
// #endif
// }
// afterSet();
// }
// };
// public:
// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
// class HasAddrFrom {
// public:
// virtual uint16_t getAddrFrom() { return IDataPack::addrFromPtr[0] << 8 | IDataPack::addrFromPtr[1]; };
// };
// class HasAddrTo {
// public:
// virtual uint16_t getAddrTo() { return IDataPack::addrToPtr[0] << 8 | IDataPack::addrToPtr[1]; };
// };
// class HasData {
// public:
// virtual uint8_t getDataSize() { return (uint8_t)(IDataPack::crcPtr - IDataPack::dataPtr); };
// virtual uint8_t* getDataPrt() { return IDataPack::dataPtr; };
// virtual uint8_t getDataRawSize() { return IDataPack::packRawSize; };
// virtual uint8_t* getDataRawPtr() { return IDataPack::data; };
// };
// class IAcceptable {
// public:
// virtual bool isNeedAccept();
// };
// class AnyData : public IDataPack, public HasAddrFrom, public HasAddrTo, public HasData {
// using IDataPack::IDataPack;
// };
// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
// class Data : public AnyData, public IAcceptable {
// using AnyData::AnyData;
// public:
// bool isNeedAccept() override { return ((IDataPack::msgPtr[0] >> 5) & IR_MASK_MSG_TYPE) == IR_MSG_DATA_ACCEPT; };
// private:
// void afterSet() override {
// if (Data::IDataPack::isAvailable && isNeedAccept()) {
// dec->addrWaitingSendgTo = getAddrFrom();
// dec->startWaitingSendToTime = millis();
// dec->isWaitingAcceptSend = true;
// Serial.print("\n Need to accept to ");
// Serial.println(dec->addrWaitingSendgTo);
// }
// }
// };
// class BackData : public AnyData {
// using AnyData::AnyData;
// public:
// bool isAddressed() { return IDataPack::msgPtr[0] & 0b00010000; };
// uint8_t getMsgInfo() { return IDataPack::msgPtr[0] & (IR_MASK_MSG_INFO >> 1); };
// uint16_t getAddrTo() override {
// if (isAddressed()) {
// return IDataPack::addrToPtr[0] << 8 | IDataPack::addrToPtr[1];
// } else {
// return IR_Broadcast;
// }
// };
// };
// class Accept : public IDataPack, public HasAddrFrom {
// using IDataPack::IDataPack;
// public:
// private:
// bool checkAddress(PackOutInfo* packInfo) override {
// bool ret;
// uint8_t targetAddrOffset = packInfo->offsets.addrFromOffset;
// uint16_t address = (packInfo->ptr[targetAddrOffset] << 8) | (packInfo->ptr[targetAddrOffset + 1]);
// ret = address == dec->addrWaitingFrom;
// return ret;
// }
// };
// class Request : public IDataPack, public HasAddrFrom, public HasAddrTo {
// using IDataPack::IDataPack;
// public:
// private:
// // void afterSet() override {
// // if (isAvailable) {
// // dec->isWaitingAcceptSend = true;
// // dec->addrWaitingSendgTo = getAddrFrom();
// // Serial.print("\n Need to accept to ");
// // Serial.println(dec->addrWaitingSendgTo);
// // }
// // }
// };
// class RawTune {
// friend IR_Decoder;
// public:
// bool available() { return isAvailable; };
// uint16_t getTunerTime() { return bitPeriod; };
// void resetAvailable() { isAvailable = false; };
// protected:
// bool isAvailable;
// uint16_t bitPeriod;
// void set(uint16_t time) {
// bitPeriod = time;
// isAvailable = true;
// }
// };
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

6
IR_DecoderRaw.cpp
View File

@ -69,7 +69,7 @@ void IR_DecoderRaw::firstRX() {
void IR_DecoderRaw::listenStart() { void IR_DecoderRaw::listenStart() {
if (isRecive && ((micros() - prevRise) > IR_timeout * 2)) { if (isRecive && ((micros() - prevRise) > IR_timeout * 2)) {
Serial.print("\nlis>"); // Serial.print("\nlis>");
isRecive = false; isRecive = false;
firstRX(); firstRX();
} }
@ -357,11 +357,15 @@ void IR_DecoderRaw::writeToBuffer(bool bit) {
if (!isAvailable && isData && !isWrongPack) { if (!isAvailable && isData && !isWrongPack) {
if (i_dataBuffer == 8 * msgBytes) {// Ппервый байт if (i_dataBuffer == 8 * msgBytes) {// Ппервый байт
packSize = dataBuffer[0] & IR_MASK_MSG_INFO; packSize = dataBuffer[0] & IR_MASK_MSG_INFO;
#ifdef IRDEBUG_INFO
Serial.print(" ["); Serial.print(packSize); Serial.print("] "); Serial.print(" ["); Serial.print(packSize); Serial.print("] ");
#endif
} }
if (packSize && (i_dataBuffer == packSize * bitPerByte)) { // Конец if (packSize && (i_dataBuffer == packSize * bitPerByte)) { // Конец
#ifdef IRDEBUG_INFO
Serial.print(" END DATA "); Serial.print(" END DATA ");
#endif
packInfo.buffer = dataBuffer; packInfo.buffer = dataBuffer;
packInfo.crc = crcValue; packInfo.crc = crcValue;

2
IR_Encoder.cpp
View File

@ -127,7 +127,7 @@ void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t* data, uint
uint8_t packSize = msgBytes + addrBytes + (isAdressed ? addrBytes : 0) + min(1, len) + crcBytes; uint8_t packSize = msgBytes + addrBytes + (isAdressed ? addrBytes : 0) + min(1, len) + crcBytes;
uint8_t msgType = uint8_t msgType =
(IR_MSG_BACK << 5) | (isAdressed << 4U) | ((packSize) & (IR_MASK_MSG_INFO >> 1)); ((isAdressed ? IR_MSG_BACK_TO : IR_MSG_BACK)<<5) | ((packSize) & (IR_MASK_MSG_INFO >> 1));
// формирование массива // формирование массива
// msg_type // msg_type

81
IR_config.h
View File

@ -48,55 +48,55 @@ msg type:
#define IR_MSG_ 5U // | 101..... | = ?? #define IR_MSG_ 5U // | 101..... | = ??
#define IR_MSG_DATA_NOACCEPT 6U // | 110..... | = данные, не требующие подтверждения #define IR_MSG_DATA_NOACCEPT 6U // | 110..... | = данные, не требующие подтверждения
#define IR_MSG_DATA_ACCEPT 7U // | 111..... | = данные требующие подтверждения #define IR_MSG_DATA_ACCEPT 7U // | 111..... | = данные требующие подтверждения
/*   // ---------- ;/*   // ----------
/```````````````````` подтверждение ```````````````````\      /``````````````````````````````````````` запрос ``````````````````````````````````\ /```````````````````` подтверждение ```````````````````\      /``````````````````````````````````````` запрос ``````````````````````````````````\
                                                                                                                                                                                                                                             
{``````````} [````````````````````````] [``````````````]      {``````````} [````````````````````````] [````````````````````````] [``````````````] {``````````} [````````````````````````] [``````````````]      {``````````} [````````````````````````] [````````````````````````] [``````````````]
{ msg type } [ addr_from uint16_t ] [ CRC Bytes ]      { msg type } [ addr_from uint16_t ] [ addr_to uint16_t ] [ CRC Bytes ] { msg type } [ addr_from uint16_t ] [ CRC Bytes ]      { msg type } [ addr_from uint16_t ] [ addr_to uint16_t ] [ CRC Bytes ]
{..........} [........................] [..............]      {..........} [........................] [........................] [..............] {..........} [........................] [..............]      {..........} [........................] [........................] [..............]
                                                                                                                                                                                                                                                                                                   
{ 001..... } [addr_from_H][addr_from_L] [ crc1 ][ crc2 ]      { 010..... } [addr_from_H][addr_from_L] [addr_from_H][addr_from_L] [ crc1 ][ crc2 ] { 001..... } [addr_from_H][addr_from_L] [ crc1 ][ crc2 ]      { 010..... } [addr_from_H][addr_from_L] [addr_from_H][addr_from_L] [ crc1 ][ crc2 ]
|     0            1           2           3       4          |     0            1           2              3           4           5       6     |     0            1           2           3       4          |     0            1           2              3           4           5       6    
\__________________________________________/       |          \_____________________________________________________________________/       |     \__________________________________________/       |          \_____________________________________________________________________/       |    
|                                                  |          |                                                                             |     |                                                  |          |                                                                             |    
\__________________________________________________/          \_____________________________________________________________________________/     \__________________________________________________/          \_____________________________________________________________________________/    
/`````````````````````` Задний сигнал машинки без адресации ``````````````````````\        В (IR_MASK_MSG_INFO & 15U) содержится количество байт /`````````````````````` Задний сигнал машинки без адресации ``````````````````````\        В (IR_MASK_MSG_INFO & 15U) содержится количество байт
                                                                                           сквозных команд, максимум 15                                                                                            сквозных команд, максимум 15
{``````````} [````````````````````````] [````````````````````````] [``````````````]        Если полезных байт информации нет, отправляется один {``````````} [````````````````````````] [````````````````````````] [``````````````]        Если полезных байт информации нет, отправляется один
{ msg type } [ addr_from uint16_t ] [====== data bytes ======] [ CRC Bytes ]        байт нулей { msg type } [ addr_from uint16_t ] [====== data bytes ======] [ CRC Bytes ]        байт нулей
{..........} [........................] [........................] [..............]         {..........} [........................] [........................] [..............]        
                                                                                                                                                                                       
{ 0000xxxx } [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ]         { 0000xxxx } [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ]        
|     0           1            2            3                         |       |             |     0           1            2            3                         |       |            
\_____________________________________________________________________/       |             \_____________________________________________________________________/       |            
|                                                                             |             |                                                                             |            
\_____________________________________________________________________________/             \_____________________________________________________________________________/            
/```````````````````````````````````` Задний сигнал машинки с адресацией ````````````````````````````````````\  /```````````````````````````````````` Задний сигнал машинки с адресацией ````````````````````````````````````\ 
                                                                                                                                                                         
{``````````} [````````````````````````] [````````````````````````] [````````````````````````] [``````````````]  {``````````} [````````````````````````] [````````````````````````] [````````````````````````] [``````````````] 
{ msg type } [ addr_from uint16_t ] [ addr_to uint16_t ] [====== data bytes ======] [ CRC Bytes ]  { msg type } [ addr_from uint16_t ] [ addr_to uint16_t ] [====== data bytes ======] [ CRC Bytes ] 
{..........} [........................] [........................] [........................] [..............]  {..........} [........................] [........................] [........................] [..............] 
                                                                                                                                                                                                                               
{ 0001xxxx } [addr_from_H][addr_from_L] [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ]  { 0001xxxx } [addr_from_H][addr_from_L] [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ] 
|     0           1            2              3           4            5                         |       |      |     0           1            2              3           4            5                         |       |     
\________________________________________________________________________________________________/       |      \________________________________________________________________________________________________/       |     
|                                                                                                        |      |                                                                                                        |     
\________________________________________________________________________________________________________/      \________________________________________________________________________________________________________/     
*/ */
#define IR_MASK_MSG_TYPE 0b00000111 #define IR_MASK_MSG_TYPE 0b00000111
#define IR_MASK_MSG_INFO 0b00011111 #define IR_MASK_MSG_INFO 0b00011111
/* /*
/////////////////////////////////////////////////////////////////////////////////////*/ /////////////////////////////////////////////////////////////////////////////////////*/
typedef uint16_t crc_t; typedef uint16_t crc_t;
#define bytePerPack 16 // колличество байтов в пакете #define bytePerPack 16 // колличество байтов в пакете
@ -167,16 +167,15 @@ public:
uint16_t rTime = 0; uint16_t rTime = 0;
}; };
protected: static void checkaddressRuleApply(uint16_t address, uint16_t id, bool& flag) {
ErrorsStruct errors;
void checkaddressRuleApply(uint16_t address, uint16_t id, bool& flag) {
flag = false; flag = false;
flag |= id == 0; flag |= id == 0;
flag |= address == id; flag |= address == id;
flag |= address >= IR_Broadcast; flag |= address >= IR_Broadcast;
} }
protected:
ErrorsStruct errors;
uint8_t crc8(uint8_t* data, uint8_t start, uint8_t end, uint8_t poly) { //TODO: сделать возможность межбайтовой проверки uint8_t crc8(uint8_t* data, uint8_t start, uint8_t end, uint8_t poly) { //TODO: сделать возможность межбайтовой проверки
uint8_t crc = 0xff; uint8_t crc = 0xff;
size_t i, j; size_t i, j;

368
PacketTypes.h
View File

@ -1,86 +1,312 @@
#pragma once #pragma once
#include "IR_config.h" #include "IR_config.h"
class IOffsets {
protected:
uint8_t msgOffset;
uint8_t addressFromOffset;
uint8_t addressToOffset;
uint8_t DataOffset;
};
class IPackInfo {
public:
IR_FOX::PackInfo* packInfo;
};
class IBaseEmptyPack : virtual public IOffsets, virtual public IPackInfo {
};
class IR_Decoder; class IR_Decoder;
class IEmptyPack : virtual protected IBaseEmptyPack { namespace PacketTypes {
friend IR_Decoder; class BasePack {
bool isAvailable; friend IR_Decoder;
protected:
bool isAvailable;
bool isRawAvailable;
bool isNeedAccept;
protected: uint8_t msgOffset;
virtual void set(IR_FOX::PackInfo *packInfo) { uint8_t addressFromOffset;
IBaseEmptyPack::IPackInfo::packInfo = packInfo; uint8_t addressToOffset;
Serial.print(" SET "); uint8_t DataOffset;
Serial.print("\n*******ErrAll: "); Serial.println(packInfo->err.all()); IR_FOX::PackInfo* packInfo;
Serial.print("**ErrDistance: "); Serial.println((int)(packInfo->err.highSignal - packInfo->err.lowSignal)); uint16_t id;
isAvailable = true; virtual bool checkAddress();
} void set(IR_FOX::PackInfo* packInfo, uint16_t id) {
this->packInfo = packInfo;
this->id = id;
public: if (isAvailable = checkAddress()) {
virtual bool available() { isAvailable = true;
if (isAvailable) { isRawAvailable = true;
isAvailable = false; Serial.print(" OK ");
return true; } else {
} else { isRawAvailable = true;
return false; Serial.print(" NOT-OK ");
}
}
static uint16_t _getAddrFrom(BasePack* obj) {
return (obj->packInfo->buffer[obj->addressFromOffset] << 8) | obj->packInfo->buffer[obj->addressFromOffset + 1];
};
static uint16_t _getAddrTo(BasePack* obj) {
return (obj->packInfo->buffer[obj->addressToOffset] << 8) | obj->packInfo->buffer[obj->addressToOffset + 1];
};
static uint8_t _getDataSize(BasePack* obj) {
return obj->packInfo->packSize - crcBytes - obj->DataOffset;
};
static uint8_t* _getDataPrt(BasePack* obj) {
return obj->packInfo->buffer + obj->DataOffset;
};
static uint8_t _getDataRawSize(BasePack* obj) {
return obj->packInfo->packSize;
};
static uint8_t* _getDataRawPtr(BasePack* obj) {
return obj->packInfo->buffer;
};
public:
bool available() { if (isAvailable) { isAvailable = false; isRawAvailable = false; return true; } else { return false; } };
bool availableRaw() { if (isRawAvailable) { isRawAvailable = false; return true; } else { return false; } };
uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
uint8_t getMsgRAW() { return packInfo->buffer[0]; };
uint16_t getErrorCount() { return packInfo->err.all(); };
uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
uint8_t getErrorOther() { return packInfo->err.other; };
uint16_t getTunerTime() { return packInfo->rTime; };
};
class Data : public BasePack {
public:
Data() {
msgOffset = 0;
addressFromOffset = 1;
addressToOffset = 3;
DataOffset = 5;
}
uint16_t getAddrFrom() { return _getAddrFrom(this); };
uint16_t getAddrTo() { return _getAddrTo(this); };
uint8_t getDataSize() { return _getDataSize(this); };
uint8_t* getDataPrt() { return _getDataPrt(this); };
uint8_t getDataRawSize() { return _getDataRawSize(this); };
uint8_t* getDataRawPtr() { return _getDataRawPtr(this); };
private:
bool checkAddress() override {
bool ret;
IR_FOX::checkaddressRuleApply(getAddrTo(), this->id, ret);
return ret;
} }
}; };
virtual uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
virtual uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
virtual uint8_t getMsgRAW() { return packInfo->buffer[0]; };
virtual uint16_t getErrorCount() { return packInfo->err.all(); };
virtual uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
virtual uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
virtual uint8_t getErrorOther() { return packInfo->err.other; };
virtual uint16_t getTunerTime() { return packInfo->rTime; };
};
class IHasAddresFrom : virtual protected IBaseEmptyPack { class DataBack : public BasePack {
public: public:
virtual uint16_t getAddrFrom() { return (packInfo->buffer[addressFromOffset]<<8) | packInfo->buffer[addressFromOffset + 1]; }; DataBack() {
}; msgOffset = 0;
addressFromOffset = 1;
addressToOffset = 3;
DataOffset = 3;
}
class IHasAddresTo : virtual protected IBaseEmptyPack { uint16_t getAddrFrom() { return _getAddrFrom(this); };
public: uint16_t getAddrTo() { return _getAddrTo(this); };
virtual uint16_t getAddrTo() { return (packInfo->buffer[addressToOffset]<<8) | packInfo->buffer[addressToOffset + 1]; };
};
class IHasAddresData : virtual protected IBaseEmptyPack { uint8_t getDataSize() { return _getDataSize(this); };
public: uint8_t* getDataPrt() { return _getDataPrt(this); };
virtual uint8_t getDataSize() { return &(packInfo->buffer[packInfo->packSize - 2]) - &(packInfo->buffer[DataOffset]); }; // TODO: uint8_t getDataRawSize() { return _getDataRawSize(this); };
virtual uint8_t* getDataPrt() { return packInfo->buffer + DataOffset; }; uint8_t* getDataRawPtr() { return _getDataRawPtr(this); };
virtual uint8_t getDataRawSize() { return packInfo->packSize; }; private:
virtual uint8_t* getDataRawPtr() { return packInfo->buffer; }; bool checkAddress() override {
}; bool ret;
if (getMsgType() == IR_MSG_BACK_TO) {
DataOffset = 5;
IR_FOX::checkaddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
} else {
DataOffset = 3;
ret = true;
}
return ret;
}
};
class Accept : public BasePack {
public:
Accept() {
msgOffset = 0;
addressFromOffset = 1;
DataOffset = 1;
}
class Data : uint16_t getAddrFrom() { return _getAddrFrom(this); };
virtual public IEmptyPack, private:
virtual public IHasAddresFrom, bool checkAddress() override { return true; }
virtual public IHasAddresTo, };
virtual public IHasAddresData {
public: class Request : public BasePack {
Data() { public:
msgOffset = 0; Request() {
addressFromOffset = 1; msgOffset = 0;
addressToOffset = 3; addressFromOffset = 1;
DataOffset = 5; addressToOffset = 3;
} DataOffset = 3;
}; }
uint16_t getAddrFrom() { return _getAddrFrom(this); };
uint16_t getAddrTo() { return _getAddrTo(this); };
private:
bool checkAddress() override {
bool ret;
IR_FOX::checkaddressRuleApply(getAddrTo(), this->id, ret);
return ret;
}
};
}
// class IOffsets {
// protected:
// uint8_t msgOffset;
// uint8_t addressFromOffset;
// uint8_t addressToOffset;
// uint8_t DataOffset;
// };
// class IPackInfo {
// public:
// IR_FOX::PackInfo* packInfo;
// };
// class IBaseEmptyPack : virtual public IOffsets, virtual public IPackInfo {
// };
// class IR_Decoder;
// class IEmptyPack : virtual protected IBaseEmptyPack, virtual public IR_FOX {
// friend IR_Decoder;
// bool isAvailable;
// bool isRawAvailable;
// bool isNeedAccept;
// protected:
// uint16_t id;
// virtual bool checkAddress() {};
// virtual void set(IR_FOX::PackInfo* packInfo, uint16_t id, bool isNeedAccept = false) {
// IBaseEmptyPack::IPackInfo::packInfo = packInfo;
// this->id = id;
// this->isNeedAccept = isNeedAccept;
// if (isAvailable = checkAddress()) {
// isAvailable = true;
// isRawAvailable = true;
// Serial.print(" OK ");
// } else {
// isRawAvailable = true;
// Serial.print(" NOT-OK ");
// }
// }
// public:
// virtual bool available() { if (isAvailable) { isAvailable = false; isRawAvailable = false; return true; } else { return false; } };
// virtual bool availableRaw() { if (isRawAvailable) { isRawAvailable = false; return true; } else { return false; } };
// virtual uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
// virtual uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
// virtual uint8_t getMsgRAW() { return packInfo->buffer[0]; };
// virtual uint16_t getErrorCount() { return packInfo->err.all(); };
// virtual uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
// virtual uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
// virtual uint8_t getErrorOther() { return packInfo->err.other; };
// virtual uint16_t getTunerTime() { return packInfo->rTime; };
// };
// class IHasAddresFrom : virtual protected IBaseEmptyPack {
// public:
// virtual uint16_t getAddrFrom() { return (packInfo->buffer[addressFromOffset] << 8) | packInfo->buffer[addressFromOffset + 1]; };
// };
// class IHasAddresTo : virtual protected IBaseEmptyPack {
// public:
// virtual uint16_t getAddrTo() { return (packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1]; };
// };
// class IHasAddresData : virtual protected IBaseEmptyPack {
// public:
// virtual uint8_t getDataSize() { return packInfo->packSize - crcBytes - DataOffset; };
// virtual uint8_t* getDataPrt() { return packInfo->buffer + DataOffset; };
// virtual uint8_t getDataRawSize() { return packInfo->packSize; };
// virtual uint8_t* getDataRawPtr() { return packInfo->buffer; };
// };
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// class Data :
// virtual public IEmptyPack,
// virtual public IHasAddresFrom,
// virtual public IHasAddresTo,
// virtual public IHasAddresData {
// public:
// Data() {
// msgOffset = 0;
// addressFromOffset = 1;
// addressToOffset = 3;
// DataOffset = 5;
// }
// protected:
// bool checkAddress() override {
// bool ret;
// checkaddressRuleApply(getAddrTo(), this->id, ret);
// return ret;
// }
// };
// class DataBack :
// virtual public IEmptyPack,
// virtual public IHasAddresFrom,
// virtual public IHasAddresData {
// public:
// DataBack() {
// msgOffset = 0;
// addressFromOffset = 1;
// addressToOffset = 3;
// DataOffset = 3;
// }
// protected:
// bool checkAddress() override {
// bool ret;
// if (getMsgType() == IR_MSG_BACK_TO) {
// DataOffset = 5;
// checkaddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
// } else {
// DataOffset = 3;
// ret = true;
// }
// return ret;
// }
// };
// class Request :
// virtual public IEmptyPack,
// virtual public IHasAddresFrom,
// virtual public IHasAddresTo {
// public:
// Request() {
// msgOffset = 0;
// addressFromOffset = 1;
// addressToOffset = 3;
// DataOffset = 3;
// }
// protected:
// bool checkAddress() override {
// bool ret;
// checkaddressRuleApply(getAddrTo(), this->id, ret);
// return ret;
// }
// };
// class Accept :
// virtual public IEmptyPack,
// virtual public IHasAddresFrom {
// public:
// Accept() {
// msgOffset = 0;
// addressFromOffset = 1;
// DataOffset = 1;
// }
// protected:
// };