refactor

IR-protocol.ino

@@ -7,14 +7,36 @@
 #define encForward_PIN PA0
 #define encBackward_PIN PA1
 
-#define dec1_PIN PB0
+#define dec0_PIN PB0
-#define dec2_PIN PB1
+#define dec1_PIN PB1
+#define dec2_PIN PA2
+#define dec3_PIN PB3
+#define dec4_PIN PB4
+#define dec5_PIN PB5
+#define dec6_PIN PB6
+#define dec7_PIN PB7
+#define dec8_PIN PB8
+#define dec9_PIN PB9
+#define dec10_PIN PB10
+#define dec11_PIN PB11
+#define dec12_PIN PB12
+#define dec13_PIN PB13
+#define dec14_PIN PB14
+#define dec15_PIN PB15
 
 #define LoopOut PA7
 
-// #define TestOut 13
+#define dec_ISR(n) \
+    void dec_##n##_ISR() { dec##n.isr(); }
+#define dec_Ini(n)                      \
+    IR_Decoder dec##n(dec##n##_PIN, n); \
+    dec_ISR(n)
 
-#define SignalDetectLed PA6
+#define decPinMode(n) pinMode(dec##n##_PIN, INPUT_PULLUP);
+#define decAttach(n) attachInterrupt(dec##n##_PIN, dec_##n##_ISR, CHANGE);
+#define decSetup(n) /* decPinMode(n); */ decAttach(n);
+#define decTick(n) dec##n.tick();
+#define decStat(n) rx_flag |= statusSimple(dec##n);
 
 //////////////// Ini /////////////////
 
@@ -23,43 +45,35 @@
 
 //////////////// Var /////////////////
 
-IR_Decoder decForward(dec1_PIN, 555);
+IR_Encoder encForward(PA5, 42 /* , &decBackward */);
-IR_Decoder decBackward(dec2_PIN, 777);
-
-IR_Encoder encForward(42 /* , &decBackward */);
 // IR_Encoder encBackward(321, encBackward_PIN);
 // IR_Encoder encTree(325, A2);
 
 //////////////////////// Функции прерываний ////////////////////////
 
-void decForwardISR()
-{
-    decForward.isr();
-    // Serial.println("ISR");
-}
-
-void decBackwardISR()
-{
-    decBackward.isr();
-    // Serial.println("ISR");
-}
-
-static uint8_t *portOut;
-
 void EncoderISR()
 {
-    encForward.isr();
+    //  Serial.println("EncoderISR");
-    // encBackward.isr();
+    IR_Encoder::isr();
-    // encTree.isr();
-    // TODO: Сделать выбор порта
-    // *portOut = (*portOut & 0b11001111) |
-    //     (
-    //         encForward.ir_out_virtual << 5U
-    //         // | encBackward.ir_out_virtual << 6U
-    //         // | encTree.ir_out_virtual << 2U
-    //         );
-    digitalWrite(PB5, encForward.ir_out_virtual);
 }
+
+//-------------------------------------------------------------------
+
+dec_Ini(0);
+dec_Ini(1);
+dec_Ini(2);
+dec_Ini(3);
+dec_Ini(4);
+dec_Ini(5);
+dec_Ini(6);
+dec_Ini(7);
+dec_Ini(8);
+dec_Ini(9);
+dec_Ini(10);
+dec_Ini(11);
+dec_Ini(12);
+dec_Ini(13);
+
 /////////////////////////////////////////////////////////////////////
 uint8_t data0[] = {};
 uint8_t data1[] = {42};
@@ -159,39 +173,44 @@ Timer t1(500, millis, []()
 Timer signalDetectTimer;
 /////////////////////////////////////////////////////////////////////
 HardwareTimer IR_Timer(TIM3);
-HardwareTimer MicrosTimer(TIM1);
-
-void MicrosTimerISR(){
-
-}
 
 void setup()
 {
     // MicrosTimer.setOve
 
-    IR_Timer.setOverflow(carrierFrec*2, HERTZ_FORMAT);
+    IR_Timer.setOverflow(carrierFrec * 2, HERTZ_FORMAT);
     IR_Timer.attachInterrupt(1, EncoderISR);
-    
+    IR_Timer.resume();
 
     Serial.begin(SERIAL_SPEED);
     Serial.println(F(INFO));
 
     pinMode(LoopOut, OUTPUT);
-    pinMode(SignalDetectLed, OUTPUT);
+    // pinMode(SignalDetectLed, OUTPUT);
 
     pinMode(dec1_PIN, INPUT_PULLUP);
     // pinMode(dec2_PIN, INPUT_PULLUP);
 
-
     pinMode(encForward_PIN, OUTPUT);
     pinMode(encBackward_PIN, OUTPUT);
-    pinMode(LED_BUILTIN, OUTPUT);
 
     // IR_DecoderRaw* blindFromForward [] { &decForward, &decBackward };
     // encForward.setBlindDecoders(blindFromForward, sizeof(blindFromForward) / sizeof(IR_DecoderRaw*));
 
-    attachInterrupt(dec1_PIN, decForwardISR, CHANGE); // D2
+    decSetup(0);
-    // attachInterrupt(dec2_PIN, decBackwardISR, CHANGE); // D3
+    decSetup(1);
+    decSetup(2);
+    decSetup(3);
+    decSetup(4);
+    decSetup(5);
+    decSetup(6);
+    decSetup(7);
+    decSetup(8);
+    decSetup(9);
+    decSetup(10);
+    decSetup(11);
+    decSetup(12);
+    decSetup(13);
 }
 
 void loop()
@@ -199,10 +218,25 @@ void loop()
     digitalToggle(LoopOut);
     Timer::tick();
 
-    decForward.tick();
+    IR_Decoder::tick();
-    decBackward.tick();
 
-    status(decForward);
+    bool rx_flag;
+    decStat(0);
+    decStat(1);
+    decStat(2);
+    decStat(3);
+    decStat(4);
+    decStat(5);
+    decStat(6);
+    decStat(7);
+    decStat(8);
+    decStat(9);
+    decStat(10);
+    decStat(11);
+    decStat(12);
+    decStat(13);
+
+    // status(decForward);
     // status(decBackward);
 
     // Serial.println(micros() - loopTimer);
@@ -230,12 +264,28 @@ void loop()
         }
     }
 }
+Timer statusSimpleDelay;
+bool statusSimple(IR_Decoder &dec)
+{
+    bool ret;
+    if (ret = dec.gotData.available())
+    {
+        Serial.print("DEC: ");
+        Serial.print(dec.getId());
+        Serial.print("   err:  ");
+        Serial.print(dec.gotData.getErrorCount());
+        Serial.print("\n");
+        statusSimpleDelay.delay(100, millis, []()
+                                { Serial.print("\n\n\n\n"); });
+    }
+    return ret;
+}
 
 void detectSignal()
 {
-    digitalWrite(SignalDetectLed, HIGH);
+    // digitalWrite(SignalDetectLed, HIGH);
-    signalDetectTimer.delay(50, millis, []()
+    // signalDetectTimer.delay(50, millis, []()
-                            { digitalWrite(SignalDetectLed, LOW); });
+    //                         { digitalWrite(SignalDetectLed, LOW); });
 }
 
 // test

IR_Decoder.cpp

@@ -0,0 +1,72 @@
+#include "IR_Decoder.h"
+
+std::list<IR_Decoder*>& IR_Decoder::get_dec_list() // определение функции
+{
+    static std::list<IR_Decoder*> dec_list; // статическая локальная переменная
+    return dec_list; // возвращается ссылка на переменную
+}
+
+IR_Decoder::IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair)
+    : IR_DecoderRaw(isrPin, addr, encPair)
+{
+    get_dec_list().push_back(this);
+};
+
+IR_Decoder::~IR_Decoder()
+{
+    IR_Decoder::get_dec_list().remove(this);
+}
+
+void IR_Decoder::tick()
+{
+    for (const auto &element : IR_Decoder::get_dec_list())
+    {
+        element->_tick();
+    }
+}
+
+void IR_Decoder::_tick()
+{
+    IR_DecoderRaw::tick();
+    if (availableRaw())
+    {
+#ifdef IRDEBUG_INFO
+        Serial.println("PARSING RAW DATA");
+#endif
+        isWaitingAcceptSend = false;
+        switch (packInfo.buffer[0] >> 5 & IR_MASK_MSG_TYPE)
+        {
+        case IR_MSG_DATA_ACCEPT:
+        case IR_MSG_DATA_NOACCEPT:
+            gotData.set(&packInfo, id);
+            break;
+        case IR_MSG_BACK:
+        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;
+        }
+        if (gotData.isAvailable && (gotData.getMsgType() == IR_MSG_DATA_ACCEPT))
+        {
+            acceptSendTimer = millis();
+            addrAcceptSendTo = gotData.getAddrFrom();
+            acceptCustomByte = crc8(gotData.getDataPrt(), 0, gotData.getDataSize(), poly1);
+            if (addrAcceptSendTo && addrAcceptSendTo < IR_Broadcast)
+                isWaitingAcceptSend = true;
+        }
+        gotRaw.set(&packInfo, id);
+    }
+    if (isWaitingAcceptSend && millis() - acceptSendTimer > 75)
+    {
+        encoder->sendAccept(addrAcceptSendTo, acceptCustomByte);
+        isWaitingAcceptSend = false;
+    }
+}

IR_Decoder.h

@@ -5,6 +5,11 @@
 
 class IR_Decoder : public IR_DecoderRaw
 {
+private:
+    // static std::list<IR_Decoder *> dec_list;
+    static std::list<IR_Decoder*>& get_dec_list();
+    void _tick();
+
     uint32_t acceptSendTimer;
     bool isWaitingAcceptSend;
     uint16_t addrAcceptSendTo;
@@ -19,59 +24,16 @@ public:
     PacketTypes::Request gotRequest;
     PacketTypes::BasePack gotRaw;
 
-    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_Decoder();
 
-    void tick()
+    static void tick();
-    {
-        IR_DecoderRaw::tick();
-        if (availableRaw())
-        {
-#ifdef IRDEBUG_INFO
-            Serial.println("PARSING RAW DATA");
-#endif
-            isWaitingAcceptSend = false;
-            switch (packInfo.buffer[0] >> 5 & IR_MASK_MSG_TYPE)
-            {
-            case IR_MSG_DATA_ACCEPT:
-            case IR_MSG_DATA_NOACCEPT:
-                gotData.set(&packInfo, id);
-                break;
-            case IR_MSG_BACK:
-            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:
+    inline void setAcceptDelay(uint16_t acceptDelay)
-                break;
-            }
-            if (gotData.isAvailable && (gotData.getMsgType() == IR_MSG_DATA_ACCEPT))
-            {
-                acceptSendTimer = millis();
-                addrAcceptSendTo = gotData.getAddrFrom();
-                acceptCustomByte = crc8(gotData.getDataPrt(), 0, gotData.getDataSize(), poly1);
-                if (addrAcceptSendTo && addrAcceptSendTo < IR_Broadcast)
-                    isWaitingAcceptSend = true;
-            }
-            gotRaw.set(&packInfo, id);
-        }
-        if (isWaitingAcceptSend && millis() - acceptSendTimer > 75)
-        {
-            encoder->sendAccept(addrAcceptSendTo, acceptCustomByte);
-            isWaitingAcceptSend = false;
-        }
-    }
-
-    void setAcceptDelay(uint16_t acceptDelay)
     {
         this->acceptDelay = acceptDelay;
     }
-    uint16_t getAcceptDelay()
+    inline uint16_t getAcceptDelay()
     {
         return this->acceptDelay;
     }

IR_DecoderRaw.cpp

@@ -20,6 +20,27 @@ IR_DecoderRaw::IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder *en
 #endif
 }
 
+bool IR_DecoderRaw::isSubOverflow()
+{
+    noInterrupts();
+    volatile bool ret = isSubBufferOverflow;
+    interrupts();
+    return ret;
+}
+
+bool IR_DecoderRaw::availableRaw()
+    {
+        if (isAvailable)
+        {
+            isAvailable = false;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    };
+
 //////////////////////////////////// isr ///////////////////////////////////////////
 volatile uint32_t time_;
 
@@ -55,7 +76,6 @@ void IR_DecoderRaw::isr()
 
 ////////////////////////////////////////////////////////////////////////////////////
 
-uint32_t wrCounter;
 void IR_DecoderRaw::firstRX()
 {
 
@@ -77,9 +97,9 @@ void IR_DecoderRaw::firstRX()
 
     isPreamb = true;
     riseSyncTime = bitTime /* 1100 */;
-
+#ifdef IRDEBUG
     wrCounter = 0;
-
+#endif
     memset(dataBuffer, 0x00, dataByteSizeMax);
 }
 
@@ -92,6 +112,7 @@ void IR_DecoderRaw::listenStart()
         firstRX();
     }
 }
+
 void IR_DecoderRaw::tick()
 {
     FrontStorage currentFront;
@@ -539,31 +560,31 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
             isAvailable = crcCheck(packSize - crcBytes, crcValue);
 
 #ifdef BRUTEFORCE_CHECK
-                if (!isAvailable) // Исправление первого бита // Очень большая затычка...
+            if (!isAvailable) // Исправление первого бита // Очень большая затычка...
-                    for (size_t i = 0; i < min(uint16_t(packSize - crcBytes*2U), uint16_t(dataByteSizeMax)); ++i)
+                for (size_t i = 0; i < min(uint16_t(packSize - crcBytes * 2U), uint16_t(dataByteSizeMax)); ++i)
+                {
+                    for (int j = 0; j < 8; ++j)
                     {
-                        for (int j = 0; j < 8; ++j)
+                        // инвертируем бит
+                        dataBuffer[i] ^= 1 << j;
+
+                        isAvailable = crcCheck(min(uint16_t(packSize - crcBytes), uint16_t(dataByteSizeMax - 1U)), crcValue);
+                        // обратно инвертируем бит в исходное состояние
+
+                        if (isAvailable)
+                        {
+#ifdef IRDEBUG_INFO
+                            Serial.println("!!!INV!!!");
+#endif
+                            goto OUT_BRUTEFORCE;
+                        }
+                        else
                         {
-                            // инвертируем бит
                             dataBuffer[i] ^= 1 << j;
-
-                            isAvailable = crcCheck(min(uint16_t(packSize - crcBytes), uint16_t(dataByteSizeMax - 1U)), crcValue);
-                            // обратно инвертируем бит в исходное состояние
-
-                            if (isAvailable)
-                            {
-                                #ifdef IRDEBUG_INFO
-                                Serial.println("!!!INV!!!");
-                                #endif
-                                goto OUT_BRUTEFORCE;
-                            }
-                            else
-                            {
-                                dataBuffer[i] ^= 1 << j;
-                            }
                         }
                     }
-            OUT_BRUTEFORCE:;
+                }
+        OUT_BRUTEFORCE:;
 #endif
         }
     }

IR_DecoderRaw.h

@@ -34,18 +34,7 @@ class IR_DecoderRaw : virtual public IR_FOX
 protected:
     PackInfo packInfo;
     IR_Encoder *encoder; // Указатель на парный передатчик
-    bool availableRaw()
+    bool availableRaw();
-    {
-        if (isAvailable)
-        {
-            isAvailable = false;
-            return true;
-        }
-        else
-        {
-            return false;
-        }
-    };
 
 public:
     const uint8_t isrPin; // Пин прерывания
@@ -59,18 +48,10 @@ public:
 
     void isr();  // Функция прерывания
     void tick(); // Обработка приёмника, необходима для работы
-    void tickOld();
 
-    bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился
+    inline bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился
-    bool isSubOverflow()
+    bool isSubOverflow();
-    {
+    inline bool isReciving() { return isBufferOverflow; }; // Возвращает true, если происходит приём пакета
-
-        // noInterrupts();
-        volatile bool ret = isSubBufferOverflow;
-        // interrupts();
-        return ret;
-    };
-    bool isReciving() { return isBufferOverflow; }; // Возвращает true, если происходит приём пакета
 
     //////////////////////////////////////////////////////////////////////////
 private:
@@ -150,7 +131,8 @@ private:
     /// @return Результат
     uint16_t ceil_div(uint16_t val, uint16_t divider);
 
-#if true //def IRDEBUG
+#ifdef IRDEBUG
+    uint32_t wrCounter;
     inline void errPulse(uint8_t pin, uint8_t count);
     inline void infoPulse(uint8_t pin, uint8_t count);
 #endif

IR_Encoder.cpp

@@ -5,8 +5,15 @@
 #define ISR_Out 10
 #define TestOut 13
 
-IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair)
+std::list<IR_Encoder*>& IR_Encoder::get_enc_list() // определение функции
 {
+    static std::list<IR_Encoder*> dec_list; // статическая локальная переменная
+    return dec_list; // возвращается ссылка на переменную
+}
+
+IR_Encoder::IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair)
+{
+    this->pin = pin;
     id = addr;
     this->decPair = decPair;
     signal = noSignal;
@@ -23,7 +30,10 @@ IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair)
     {
         decPair->encoder = this;
     }
+    pinMode(pin,OUTPUT);
+    get_enc_list().push_back(this);
 };
+
 void IR_Encoder::setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count)
 {
 #if disablePairDec
@@ -38,6 +48,7 @@ IR_Encoder::~IR_Encoder()
 {
     delete[] bitLow;
     delete[] bitHigh;
+    get_enc_list().remove(this);
 };
 
 void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept)
@@ -141,6 +152,7 @@ void IR_Encoder::sendBack(uint8_t data)
 {
     _sendBack(false, 0, &data, 1);
 }
+
 void IR_Encoder::sendBack(uint8_t *data , uint8_t len)
 {
     _sendBack(false, 0, data, len);
@@ -230,12 +242,21 @@ void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
     // interrupts();
 }
 
-void IR_Encoder::isr()
+void IR_Encoder::isr(){
+    //  Serial.println(get_enc_list().size());
+    for(const auto &element : get_enc_list()){
+        element->_isr();
+    }
+}
+
+void IR_Encoder::_isr()
 {
     if (!isSending)
         return;
 
     ir_out_virtual = !ir_out_virtual && state;
+    digitalWrite(pin, ir_out_virtual);
+   
 
     if (toggleCounter)
     {
@@ -369,34 +390,6 @@ void IR_Encoder::addSync(bool *prev, bool *next)
     }
 }
 
-void IR_Encoder::send_HIGH(bool prevBite)
-{
-
-    // if (/* prevBite */1) {
-    //     meanderBlock(bitPauseTakts * 2, halfPeriod, LOW);
-    //     meanderBlock(bitActiveTakts, halfPeriod, HIGH);
-    // } else {                                                    // более короткий HIGH после нуля
-    //     meanderBlock(bitTakts - (bitActiveTakts - bitPauseTakts), halfPeriod, LOW);
-    //     meanderBlock(bitActiveTakts - bitPauseTakts, halfPeriod, HIGH);
-    // }
-}
-
-void IR_Encoder::send_LOW()
-{
-    // meanderBlock(bitPauseTakts, halfPeriod, LOW);
-    // meanderBlock(bitActiveTakts, halfPeriod, LOW);
-    // meanderBlock(bitPauseTakts, halfPeriod, HIGH);
-}
-
-void IR_Encoder::send_EMPTY(uint8_t count)
-{
-    // for (size_t i = 0; i < count * 2; i++) {
-    // meanderBlock((bitPauseTakts * 2 + bitActiveTakts), halfPeriod, prevPreambBit);
-    //     prevPreambBit = !prevPreambBit;
-    // }
-    // meanderBlock(bitPauseTakts * 2 + bitActiveTakts, halfPeriod, 0); //TODO: Отодвинуть преамбулу
-}
-
 uint8_t* IR_Encoder::bitHigh = new uint8_t[2]{
         (bitPauseTakts) * 2 - 1,
         (bitActiveTakts) * 2 - 1};

IR_Encoder.h

@@ -11,40 +11,14 @@ class IR_Encoder : IR_FOX
 public:
 private:
     uint16_t id; /// @brief Адрес передатчика
-
+    uint8_t pin;
 public:
     /// @brief Класс передатчика
     /// @param addr Адрес передатчика
     /// @param pin  Вывод передатчика
-    /// @param tune Подстройка несущей частоты
     /// @param decPair Приёмник, для которого отключается приём в момент передачи передатчиком
-    IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair = nullptr);
+    IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair = nullptr);
-
+    static void isr();
-    // static void timerSetup()
-    // {
-    // //     // TIMER2 Ini
-    // //     uint8_t oldSREG = SREG; // Save global interupts settings
-    // //     cli();
-    // //     // DDRB |= (1 << PORTB3);  //OC2A (17)
-    // //     TCCR2A = 0;
-    // //     TCCR2B = 0;
-
-    // //     // TCCR2A |= (1 << COM2A0);                 //Переключение состояния
-
-    // //     TCCR2A |= (1 << WGM21);  // Clear Timer On Compare (Сброс по совпадению)
-    // //     TCCR2B |= (1 << CS20);   // Предделитель 1
-    // //     TIMSK2 |= (1 << OCIE2A); // Прерывание по совпадению
-
-    // //     OCR2A = /* 465 */ ((F_CPU / (38000 * 2)) - 2); // 38кГц
-
-    // //     SREG = oldSREG; // Return interrupt settings
-
-        
-    // }
-    // static void timerOFFSetup()
-    // {
-    //     TIMSK2 &= ~(1 << OCIE2A); // Прерывание по совпадению выкл
-    // }
 
     void setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count);
     void rawSend(uint8_t *ptr, uint8_t len);
@@ -59,13 +33,14 @@ public:
     void sendBack(uint8_t *data = nullptr, uint8_t len = 0);
     void sendBackTo(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0);
 
-    void isr();
 
     ~IR_Encoder();
     volatile bool ir_out_virtual;
 
 private:
+    static std::list<IR_Encoder*>& get_enc_list();
     void _sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len);
+    void _isr();
 
     void setDecoder_isSending();
     void sendByte(uint8_t byte, bool *prev, bool LOW_FIRST);

IR_config.cpp

@@ -0,0 +1,27 @@
+#include "IR_config.h"
+
+void IR_FOX::checkAddressRuleApply(uint16_t address, uint16_t id, bool &flag)
+{
+    flag = false;
+    flag |= id == 0;
+    flag |= address == id;
+    flag |= address >= IR_Broadcast;
+}
+
+uint8_t IR_FOX::crc8(uint8_t *data, uint8_t start, uint8_t end, uint8_t poly)
+{ // TODO: сделать возможность межбайтовой проверки
+    uint8_t crc = 0xff;
+    size_t i, j;
+    for (i = start; i < end; i++)
+    {
+        crc ^= data[i];
+        for (j = 0; j < 8; j++)
+        {
+            if ((crc & 0x80) != 0)
+                crc = (uint8_t)((crc << 1) ^ poly);
+            else
+                crc <<= 1;
+        }
+    }
+    return crc;
+};

IR_config.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <Arduino.h>
-
+#include <list>
-#define IRDEBUG_INFO
+// #define IRDEBUG_INFO
 /*//////////////////////////////////////////////////////////////////////////////////////
 
 Для работы в паре положить декодер в энкодер
@@ -140,8 +140,12 @@ typedef uint16_t crc_t;
 #define bitTakts (bitActiveTakts+bitPauseTakts)          // Общая длительность бита в тактах
 #define bitTime (bitTakts*carrierPeriod)                    // Общая длительность бита
 #define tolerance 300U
+
+
+
 class IR_FOX {
 public:
+
     struct PackOffsets {
         uint8_t msgOffset;
         uint8_t addrFromOffset;
@@ -172,32 +176,14 @@ public:
         uint16_t rTime = 0;
     };
 
-    static void checkAddressRuleApply(uint16_t address, uint16_t id, bool& flag) {
-        flag = false;
-        flag |= id == 0;
-        flag |= address == id;
-        flag |= address >= IR_Broadcast;
-    }
 
-    uint16_t getId() { return id; }
+    inline uint16_t getId() { return id; }
-    void setId(uint16_t id) { this->id = id; }
+    inline void setId(uint16_t id) { this->id = id; }
+    static void checkAddressRuleApply(uint16_t address, uint16_t id, bool& flag);
 
 protected:
-    ErrorsStruct errors;
     uint16_t id;
-    uint8_t crc8(uint8_t* data, uint8_t start, uint8_t end, uint8_t poly) { //TODO: сделать возможность межбайтовой проверки
+    ErrorsStruct errors;
-        uint8_t crc = 0xff;
+    uint8_t crc8(uint8_t* data, uint8_t start, uint8_t end, uint8_t poly);
-        size_t i, j;
-        for (i = start; i < end; i++) {
-            crc ^= data[i];
-            for (j = 0; j < 8; j++) {
-                if ((crc & 0x80) != 0)
-                    crc = (uint8_t)((crc << 1) ^ poly);
-                else
-                    crc <<= 1;
-            }
-        }
-        return crc;
-    }
 
 };

PacketTypes.cpp

@@ -0,0 +1,107 @@
+#include "PacketTypes.h"
+
+namespace PacketTypes
+{
+    bool BasePack::checkAddress() { return true; };
+    void BasePack::set(IR_FOX::PackInfo *packInfo, uint16_t id)
+    {
+        this->packInfo = packInfo;
+        this->id = id;
+
+        if (checkAddress())
+        {
+            isAvailable = true;
+            isRawAvailable = true;
+#ifdef IRDEBUG_INFO
+            Serial.print("  OK  ");
+#endif
+        }
+        else
+        {
+            isRawAvailable = true;
+#ifdef IRDEBUG_INFO
+            Serial.print("  NOT-OK  ");
+#endif
+        }
+    }
+
+    uint16_t BasePack::_getAddrFrom(BasePack *obj)
+    {
+        return (obj->packInfo->buffer[obj->addressFromOffset] << 8) | obj->packInfo->buffer[obj->addressFromOffset + 1];
+    };
+    uint16_t BasePack::_getAddrTo(BasePack *obj)
+    {
+        return (obj->packInfo->buffer[obj->addressToOffset] << 8) | obj->packInfo->buffer[obj->addressToOffset + 1];
+    };
+
+    uint8_t BasePack::_getDataSize(BasePack *obj)
+    {
+        return obj->packInfo->packSize - crcBytes - obj->DataOffset;
+    };
+    uint8_t *BasePack::_getDataPrt(BasePack *obj)
+    {
+        return obj->packInfo->buffer + obj->DataOffset;
+    };
+    uint8_t BasePack::_getDataRawSize(BasePack *obj)
+    {
+        return obj->packInfo->packSize;
+    };
+
+    bool BasePack::available()
+    {
+        if (isAvailable)
+        {
+            isAvailable = false;
+            isRawAvailable = false;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    };
+    bool BasePack::availableRaw()
+    {
+        if (isRawAvailable)
+        {
+            isRawAvailable = false;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    };
+
+    bool Data::checkAddress()
+    {
+        bool ret;
+        IR_FOX::checkAddressRuleApply(getAddrTo(), this->id, ret);
+        return ret;
+    }
+
+    bool DataBack::checkAddress()
+    {
+        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;
+    }
+
+    bool Accept::checkAddress() { return true; }
+
+    bool Request::checkAddress()
+    {
+        bool ret;
+        IR_FOX::checkAddressRuleApply(getAddrTo(), this->id, ret);
+        return ret;
+    }
+}

PacketTypes.h

@@ -21,86 +21,28 @@ namespace PacketTypes
         IR_FOX::PackInfo *packInfo;
         uint16_t id;
 
-        virtual bool checkAddress() { return true; };
+        virtual bool checkAddress();
-        void set(IR_FOX::PackInfo *packInfo, uint16_t id)
+        void set(IR_FOX::PackInfo *packInfo, uint16_t id);
-        {
-            this->packInfo = packInfo;
-            this->id = id;
 
-            if (checkAddress())
+        static uint16_t _getAddrFrom(BasePack *obj);
-            {
+        static uint16_t _getAddrTo(BasePack *obj);
-                isAvailable = true;
+        static uint8_t _getDataSize(BasePack *obj);
-                isRawAvailable = true;
+        static uint8_t *_getDataPrt(BasePack *obj);
-#ifdef IRDEBUG_INFO
+        static uint8_t _getDataRawSize(BasePack *obj);
-                Serial.print("  OK  ");
-#endif
-            }
-            else
-            {
-                isRawAvailable = true;
-#ifdef IRDEBUG_INFO
-                Serial.print("  NOT-OK  ");
-#endif
-            }
-        }
-
-        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;
-        };
 
     public:
-        bool available()
+        bool available();
-        {
+        bool availableRaw();
-            if (isAvailable)
+
-            {
+        inline uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
-                isAvailable = false;
+        inline uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
-                isRawAvailable = false;
+        inline uint8_t getMsgRAW() { return packInfo->buffer[0]; };
-                return true;
+        inline uint16_t getErrorCount() { return packInfo->err.all(); };
-            }
+        inline uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
-            else
+        inline uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
-            {
+        inline uint8_t getErrorOther() { return packInfo->err.other; };
-                return false;
+        inline uint16_t getTunerTime() { return packInfo->rTime; };
-            }
+        inline uint8_t *getDataRawPtr() { return packInfo->buffer; };
-        };
-        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; };
-        uint8_t *getDataRawPtr() { return packInfo->buffer; };
     };
 
     class Data : public BasePack
@@ -114,20 +56,15 @@ namespace PacketTypes
             DataOffset = 5;
         }
 
-        uint16_t getAddrFrom() { return _getAddrFrom(this); };
+        inline uint16_t getAddrFrom() { return _getAddrFrom(this); };
-        uint16_t getAddrTo() { return _getAddrTo(this); };
+        inline uint16_t getAddrTo() { return _getAddrTo(this); };
 
-        uint8_t getDataSize() { return _getDataSize(this); };
+        inline uint8_t getDataSize() { return _getDataSize(this); };
-        uint8_t *getDataPrt() { return _getDataPrt(this); };
+        inline uint8_t *getDataPrt() { return _getDataPrt(this); };
-        uint8_t getDataRawSize() { return _getDataRawSize(this); };
+        inline uint8_t getDataRawSize() { return _getDataRawSize(this); };
 
     private:
-        bool checkAddress() override
+        bool checkAddress() override;
-        {
-            bool ret;
-            IR_FOX::checkAddressRuleApply(getAddrTo(), this->id, ret);
-            return ret;
-        }
     };
 
     class DataBack : public BasePack
@@ -141,29 +78,15 @@ namespace PacketTypes
             DataOffset = 3;
         }
 
-        uint16_t getAddrFrom() { return _getAddrFrom(this); };
+        inline uint16_t getAddrFrom() { return _getAddrFrom(this); };
-        uint16_t getAddrTo() { return _getAddrTo(this); };
+        inline uint16_t getAddrTo() { return _getAddrTo(this); };
 
-        uint8_t getDataSize() { return _getDataSize(this); };
+        inline uint8_t getDataSize() { return _getDataSize(this); };
-        uint8_t *getDataPrt() { return _getDataPrt(this); };
+        inline uint8_t *getDataPrt() { return _getDataPrt(this); };
-        uint8_t getDataRawSize() { return _getDataRawSize(this); };
+        inline uint8_t getDataRawSize() { return _getDataRawSize(this); };
 
     private:
-        bool checkAddress() override
+        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
@@ -176,11 +99,11 @@ namespace PacketTypes
             DataOffset = 3;
         }
 
-        uint16_t getAddrFrom() { return _getAddrFrom(this); };
+       inline uint16_t getAddrFrom() { return _getAddrFrom(this); };
-        uint8_t getCustomByte() { return packInfo->buffer[DataOffset]; };
+       inline uint8_t getCustomByte() { return packInfo->buffer[DataOffset]; };
 
     private:
-        bool checkAddress() override { return true; }
+        bool checkAddress() override;
     };
 
     class Request : public BasePack
@@ -194,168 +117,11 @@ namespace PacketTypes
             DataOffset = 3;
         }
 
-        uint16_t getAddrFrom() { return _getAddrFrom(this); };
+        inline uint16_t getAddrFrom() { return _getAddrFrom(this); };
-        uint16_t getAddrTo() { return _getAddrTo(this); };
+        inline uint16_t getAddrTo() { return _getAddrTo(this); };
 
     private:
-        bool checkAddress() override
+        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:
-// };