add DataBack and refactor out classes

IR_Decoder.cpp

@@ -2,12 +2,6 @@
 #include "IR_Encoder.h"
 
 
-
-#define checkAddr(h, l) (\
-    ((uint16_t)((dataBuffer[h] << 8) | dataBuffer[l]) == id) || \
-    ((uint16_t)((dataBuffer[h] << 8) | dataBuffer[l]) >= IR_Broadcast)\
-    )
-
 IR_Decoder::IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder* encPair = nullptr) : isrPin(isrPin), id(addr), encoder(encPair) {
     dataBuffer = new uint8_t[dataByteSizeMax] { 0 };
     prevRise = prevFall = prevPrevFall = prevPrevRise = 0;
@@ -52,7 +46,7 @@ void IR_Decoder::isr() {
 
 ////////////////////////////////////////////////////////////////////////////////////
 
-void IR_Decoder::start_RX() {
+void IR_Decoder::firstRX() {
 
     #ifdef IRDEBUG_INFO
     Serial.print("\n>");
@@ -78,7 +72,7 @@ void IR_Decoder::start_RX() {
 void IR_Decoder::listen() {
     if (isRecive && ((micros() - prevRise) > IR_timeout * 2)) {
         isRecive = false;
-        start_RX();
+        firstRX();
     }
 }
 
@@ -331,9 +325,6 @@ void IR_Decoder::writeToBuffer(bool bit) {
         }
         ////////////////////// Проверка наличия битов синхранизации //////////////////////
         if (isWrongPack = (err_syncBit >= syncBits)) {
-            // start_RX();
-            // firstUnHandledFront = firstUnHandledFront->next;
-            // firstUnHandledFront = nullptr;
             #ifdef IRDEBUG_INFO
             Serial.print("****************");
             #endif
@@ -370,7 +361,7 @@ void IR_Decoder::writeToBuffer(bool bit) {
                 if ((dataBuffer[0] & 0b00010000)) {                 // С адресацией
                     packToOutClass(
                         packSize,             // packSize
-                        gotData,              // obj
+                        gotBackData,          // obj
                         PackOffsets {
                             0,                // msgOffset
                             1,                // addrFromOffset
@@ -383,7 +374,7 @@ void IR_Decoder::writeToBuffer(bool bit) {
                 } else {                                            // Без адресации
                     packToOutClass(
                         packSize,             // packSize
-                        gotData,              // obj
+                        gotBackData,          // obj
                         PackOffsets {
                             0,                // msgOffset
                             1,                // addrFromOffset
@@ -438,7 +429,7 @@ void IR_Decoder::writeToBuffer(bool bit) {
 
                 packToOutClass(
                     packSize,              // packSize
-                    gotData,                                                        // obj
+                    gotData,               // obj
                     PackOffsets {
                         0,                // msgOffset
                         1,                // addrFromOffset

IR_Decoder.h

@@ -36,62 +36,42 @@ class IR_Decoder : private IR_FOX {
         IDataPack(IR_Decoder* dec) : dec(dec) {};
 
     public:
-        bool avaliable() { return isAvaliable; };
+        bool avaliable() { if (isAvaliable) { isAvaliable = false; return true; } else { return isAvaliable; }; };
-        uint8_t getMsgInfo() { return msgPtr[0] & IR_MASK_MSG_INFO; };
+        virtual uint8_t getMsgInfo() { return msgPtr[0] & IR_MASK_MSG_INFO; };
-        uint8_t getMsgType() { return (msgPtr[0] >> 5) & IR_MASK_MSG_TYPE; };
+        virtual uint8_t getMsgType() { return (msgPtr[0] >> 5) & IR_MASK_MSG_TYPE; };
-        uint8_t getMsgRAW() { return msgPtr[0]; };
+        virtual uint8_t getMsgRAW() { return msgPtr[0]; };
-        uint16_t getErrorCount() { return err.all(); };
+        virtual uint16_t getErrorCount() { return err.all(); };
-        uint8_t getErrorLowSignal() { return err.lowSignal; };
+        virtual uint8_t getErrorLowSignal() { return err.lowSignal; };
-        uint8_t getErrorHighSignal() { return err.highSignal; };
+        virtual uint8_t getErrorHighSignal() { return err.highSignal; };
-        uint8_t getErrorOther() { return err.other; };
+        virtual 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; };
+        virtual uint16_t getTunerTime() { return bitPeriod; };
         void resetAvaliable() { isAvaliable = false; };
 
     protected:
-        IR_Decoder* dec;
         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 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) {
             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;
         };
-
-        void set(PackOutInfo packInfo, bool isNeedAddressCheck) {
-
-            if (!isNeedAddressCheck || checkAddress(&packInfo)) {
-                onPackAddressCorrect(&packInfo);
-                #ifdef IRDEBUG_INFO
-                Serial.println(" OK ");
-                #endif
-            } else {
-                onPackAddressIncorrect(&packInfo);
-                #ifdef IRDEBUG_INFO
-                Serial.println(" NOT MY ");
-                #endif
-            }
-        }
-
         virtual void onPackAddressCorrect(PackOutInfo* packInfo) {
             memset(IDataPack::data, 0, dataByteSizeMax);
             memcpy(data, packInfo->ptr, min(packInfo->packSize, dataByteSizeMax));
@@ -105,52 +85,113 @@ class IR_Decoder : private IR_FOX {
             addrToPtr = (data + packInfo->offsets.addrToOffset);
             dataPtr = (data + packInfo->offsets.dataOffset);
             crcPtr = (data + packInfo->offsets.crcOffset);
-
-            isAvaliable = true;
         }
+
         virtual void onPackAddressIncorrect(PackOutInfo* packInfo) {}
+        virtual void afterSet() {}
 
+        void set(PackOutInfo packInfo, bool isNeedAddressCheck) {
+            isAvaliable = false;
+            if (!isNeedAddressCheck || checkAddress(&packInfo)) {
+                onPackAddressCorrect(&packInfo);
+                #ifdef IRDEBUG_INFO
+                Serial.println(" OK ");
+                #endif
+                isAvaliable = true;
+            } else {
+                onPackAddressIncorrect(&packInfo);
+                #ifdef IRDEBUG_INFO
+                Serial.println(" NOT MY ");
+                #endif
+            }
+            afterSet();
+        }
     };
 
-    //////////////////////////////////////////////////////////////////////////
+public:
-
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-    class Data : public IDataPack {
+    class HasAddrFrom {
-        using IDataPack::IDataPack;
     public:
-        uint16_t getAddrFrom() { return  addrFromPtr[0] << 8 | addrFromPtr[1]; };
+        virtual uint16_t getAddrFrom() { return  IDataPack::addrFromPtr[0] << 8 | IDataPack::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; };
     };
 
-    // class RawData : public Data {
+    class HasAddrTo {
-    // };
+    public:
+        virtual uint16_t getAddrTo() { return  IDataPack::addrToPtr[0] << 8 | IDataPack::addrToPtr[1]; };
+    };
 
-    class Accept : public IDataPack {
+    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::isAvaliable && isNeedAccept()) {
+                dec->isWaitingAcceptSend = true;
+                dec->addrWaitingSendgTo = getAddrFrom();
+                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:
-        uint16_t getAddrFrom() { return  addrFromPtr[0] << 8 | addrFromPtr[1]; };
+
     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 {
+    class Request : public IDataPack, public HasAddrFrom, public HasAddrTo {
         using IDataPack::IDataPack;
     public:
-        uint16_t getAddrFrom() { return  addrFromPtr[0] << 8 | addrFromPtr[1]; };
+
-        uint16_t getAddrTo() { return addrToPtr[0] << 8 | addrToPtr[1]; };
+    private:
+        // void afterSet() override {
+        //     if (isAvaliable) {
+        //         dec->isWaitingAcceptSend = true;
+        //         dec->addrWaitingSendgTo = getAddrFrom();
+        //         Serial.print("\n Need to accept to ");
+        //         Serial.println(dec->addrWaitingSendgTo);
+        //     }
+        // }
     };
 
     class RawTune {
@@ -177,7 +218,7 @@ public:
     uint16_t id;
 
     Data gotData = Data(this);           /// @brief Контейнер с данными
-    Data gotRawData = Data(this);
+    BackData gotBackData = BackData(this);
     Accept gotAccept = Accept(this);       /// @brief Контейнер с подтверждением
     Request gotRequest = Request(this);     /// @brief Контейнер с запросом
     RawTune gotTune;        /// @brief Контейнер с информацией подстройки
@@ -201,24 +242,26 @@ public:
 
     /// @brief Флаг приёма
     /// @return Возвращает true, если происходит приём пакета
-    bool isReciving() { return isRecive; };
+    // bool isReciving() { return isRecive; }; //TODO: Некорректно работает
 
     // @brief Слушатель для работы isReciving()
     void listen();
 
     //////////////////////////////////////////////////////////////////////////
 
+    bool isWaitingAccept = false;           // Флаг ожидания подтверждения
+    bool isWaitingAcceptSend = false;       // Флаг ожидания отправки подтверждения
+    uint16_t addrWaitingFrom = 0;           // Адрес, от кого ожидается подтверждение
+    uint16_t addrWaitingSendgTo = 0;        // Адрес, кому нужно отправить подтверждение
 private:
     IR_Encoder* encoder;                    // Указатель на парный передатчик
     volatile uint16_t isPairSending = 0;    // Флаг передачи парного передатчика
     volatile bool isRecive = false;         // Флаг приёма
     volatile bool isPreamb = false;         // флаг начальной последовости
-    bool isWaitingAccept = false;           // Флаг ожидания подтверждения
     bool isCrcCorrect = false;              // Флаг корректности crc
     bool isBufferOverflow = false;          // Флаг переполнения буффера данных
     bool isWrongPack = false;               // Флаг битого пакета
 
-    uint16_t addrWaitingFrom = 0;           // Адрес, от кого ожидается подтверждение
     uint16_t riseSyncTime = bitTime;        // Подстраиваемое время бита в мкс
 
     ////////////////////////////////////////////////////////////////////////
@@ -260,7 +303,7 @@ private:
     ////////////////////////////////////////////////////////////////////////
 
     /// @brief Установка и сброс начальных значений и флагов в готовность к приёму данных
-    void start_RX();
+    void firstRX();
 
     /// @brief Целочисленное деление с округлением вверх
     /// @param val Значение