IR-protocol/IR_Output.h

#pragma once
#include "IR_config.h"
class IR_Decoder;

class IDataPack : protected IR_FOX {
    friend IR_Decoder;
public:
    IDataPack(uint16_t id) : id(id) {};

public:
    bool avaliable() { return isAvaliable; };
    uint8_t getMsgInfo() { return msgPtr[0] & IR_MASK_MSG_INFO; };
    uint8_t getMsgType() { return (msgPtr[0] >> 5) & IR_MASK_MSG_TYPE; };
    uint8_t getMsgRAW() { return msgPtr[0]; };
    uint16_t getErrorCount() { return err.all(); };
    uint8_t getErrorLowSignal() { return err.lowSignal; };
    uint8_t getErrorHighSignal() { return err.highSignal; };
    uint8_t getErrorOther() { return err.other; };
    // uint16_t getCrcIN() { return crcPtr[0] << 8 | crcPtr[1]; };
    // uint16_t getCrcCALC() { return crcCalcVal; };
    uint16_t getTunerTime() { return bitPeriod; };
    void resetAvaliable() { isAvaliable = false; };

protected:
    uint16_t id;
    inline static uint8_t data[dataByteSizeMax] { 0 };

    bool isAvaliable = false;

    uint8_t* msgPtr = nullptr;
    uint8_t* addrFromPtr = nullptr;
    uint8_t* addrToPtr = nullptr;
    uint8_t* dataPtr = nullptr;
    uint8_t* crcPtr = nullptr;

    ErrorsStruct err;
    uint8_t packRawSize;
    uint16_t bitPeriod;
    uint16_t crcCalcVal;

    virtual bool checkAddress(PackOutInfo* packInfo) { return true; };

    void set(PackOutInfo packInfo) {

        if (checkAddress(&packInfo)) {
            onPackAddressCorrect(&packInfo);
        } else {
            onPackAddressIncorrect(&packInfo);
        }
    }

    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);

        isAvaliable = true;
    }
    virtual void onPackAddressIncorrect(PackOutInfo* packInfo) {}

};

//////////////////////////////////////////////////////////////////////////

class Data : public IDataPack {
    using IDataPack::IDataPack;
public:
    uint16_t getAddrFrom() { return  addrFromPtr[0] << 8 | addrFromPtr[1]; };
    uint16_t getAddrTo() { return addrToPtr[0] << 8 | addrToPtr[1]; };
    uint8_t getDataSize() { return packRawSize - (msgBytes + addrBytes + addrBytes + crcBytes); };
    uint8_t* getDataPrt() { return dataPtr; };
    uint8_t getDataRawSize() { return packRawSize; };
    uint8_t* getDataRawPtr() { return data; };
    bool isNeedAccept() { return ((msgPtr[0] >> 5) & IR_MASK_MSG_TYPE) == IR_MSG_DATA_ACCEPT; };

private:
    bool checkAddress(PackOutInfo* packInfo) override {
        bool ret;

        uint8_t addrOffset = packInfo->offsets.addrToOffset;
        uint16_t address = (packInfo->ptr[addrOffset] << 8) | (packInfo->ptr[addrOffset + 1]);

        checkaddressRuleApply(address, id, ret);

        return ret;
    }

};

// class RawData : public Data {
// };

class Accept : public IDataPack {
    using IDataPack::IDataPack;
public:
    uint16_t getAddrFrom() { return  addrFromPtr[0] << 8 | addrFromPtr[1]; };
};

class Request : public IDataPack {
    using IDataPack::IDataPack;
public:
    uint16_t getAddrFrom() { return  addrFromPtr[0] << 8 | addrFromPtr[1]; };
    uint16_t getAddrTo() { return addrToPtr[0] << 8 | addrToPtr[1]; };
};

class RawTune {
    friend IR_Decoder;
public:
    bool avaliable() { return isAvaliable; };
    uint16_t getTunerTime() { return bitPeriod; };
    void resetAvaliable() { isAvaliable = false; };
protected:
    bool isAvaliable;
    uint16_t bitPeriod;

    void set(uint16_t time) {
        bitPeriod = time;
        isAvaliable = true;
    }
};