IR-protocol/IR_Output.h

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

class IDataPack : protected IR_FOX {
    friend IR_Decoder;
protected:
    inline static uint8_t data[dataByteSizeMax]{0};

    bool isAvaliable = false;

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



    uint8_t msgByte = 0;
    uint8_t packRawSize = 0; // полная длина пакета

    ErrorsStruct err;
    uint16_t bitPeriod = 0;
    uint16_t crcPackVal = 0;
    uint16_t crcCalcVal = 0;

    ///////////// смещения ////////////////
    uint8_t crcOffset;
    //переопределяемые дочерними классами//
    uint8_t msgOffset;
    uint8_t addrFromOffset;
    uint8_t addrToOffset;
    uint8_t dataOffset;
    //////////////////////////////////////

    void set(uint8_t* ptr, uint8_t len, uint16_t crc, ErrorsStruct err, uint16_t rTime) {
        memset(IDataPack::data, 0, dataByteSizeMax);
        memcpy(data, ptr, min(len, dataByteSizeMax));
        packRawSize = len;

        bitPeriod = rTime;
        err = err;
        crcCalcVal = crc;
        crcOffset = packRawSize - crcBytes;

        msgByte = *(uint8_t*)msgPtr;
        isAvaliable = true;

        msgPtr = (data + msgOffset);
        addrFromPtr = (data + addrFromOffset);
        addrToPtr = (data + addrToOffset);
        dataPtr = (data + dataOffset);
        crcPtr = (data + crcOffset);

    }

public:
    bool avaliable() { return isAvaliable; };
    uint8_t getMsgInfo() { return msgByte & IR_MASK_MSG_INFO; };
    uint8_t getMsgType() { return (msgByte >> 5) & IR_MASK_MSG_TYPE; };
    uint8_t getMsgRAW() { return msgByte; };
    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 getTunerTime() { return bitPeriod; };
    void resetAvaliable() { isAvaliable = false; };
};

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

class Data : public IDataPack {
public:
    Data() {
        msgOffset = 0;
        addrFromOffset = 1;
        addrToOffset = 3;
        dataOffset = 5;

    }


public:
    uint16_t getAddrFrom() { return *(uint16_t*)addrFromPtr; };
    uint16_t getAddrTo() { return *(uint16_t*)addrToPtr; };
    uint8_t getDataSize() { return packRawSize - (msgBytes + addrBytes + addrBytes + crcBytes); };
    uint8_t* getDataPrt() { return (uint8_t*)dataPtr; };
    uint8_t getDataRawSize() { return packRawSize; };
    uint8_t* getDataRawPtr() { return data; };
    uint16_t getCrcIN() { return *(uint16_t*)crcPtr; };
    uint16_t getCrcCALC() { return crcCalcVal; };
    bool isNeedAccept() { return ((msgByte >> 5) & IR_MASK_MSG_TYPE) == IR_MSG_DATA_ACCEPT; };
    ~Data() {};
};

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

class Accept : public IDataPack {
public:
    Accept() {
        msgOffset = 0;
        addrFromOffset = 1;
    }

    uint16_t getAddrFrom() { return *(uint16_t*)addrFromPtr; };
    uint16_t getCrcIN() { return *(uint16_t*)crcPtr; };
    uint16_t getCrcCALC() { return crcCalcVal; };

};

class Request : public IDataPack {
public:
    Request() {
        msgOffset = 0;
        addrFromOffset = 1;
        addrToOffset = 3;
    }

    uint16_t getAddrFrom() { return *(uint16_t*)addrFromPtr; };
    uint16_t getAddrTo() { return *(uint16_t*)addrToPtr; };
    uint16_t getCrcIN() { return *(uint16_t*)crcPtr; };
    uint16_t getCrcCALC() { return crcCalcVal; };
};

class RawTune : public IDataPack {
public:
    RawTune() {
        msgOffset = 0;
    }

};