DashyFox/IR-protocol
1
0
Fork 0
mirror of https://github.com/Show-maket/IR-protocol.git synced 2025-06-28 05:09:40 +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
Download Patch File Download Diff File Expand all files Collapse all files

208
IR_Decoder.h
View File

@ -4,219 +4,43 @@
class IR_Decoder : public IR_DecoderRaw {
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) {
}
Data gotData;
void tick() {
IR_DecoderRaw::tick();
if (available()) {
#ifdef IRDEBUG_INFO
Serial.println("PARSING RAW DATA");
#endif
bool isNeenAccept = false;
switch (packInfo.buffer[0] >> 5 & IR_MASK_MSG_TYPE) {
case IR_MSG_DATA_NOACCEPT:
gotData.set(&packInfo);
break;
case IR_MSG_DATA_ACCEPT:
isNeenAccept = true;
case IR_MSG_DATA_NOACCEPT:
gotData.set(&packInfo, id);
break;
case IR_MSG_BACK:
break;
case IR_MSG_BACK_TO:
gotBackData.set(&packInfo, id);
break;
case IR_MSG_REQUEST:
gotRequest.set(&packInfo, id);
break;
case IR_MSG_ACCEPT:
gotAccept.set(&packInfo, id);
break;
default:
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;
// }
// };
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////