test

.vscode/arduino.json

@@ -1,6 +1,6 @@
 {
-    "configuration": "flash=2097152_0,freq=133,opt=Small,rtti=Disabled,stackprotect=Disabled,exceptions=Disabled,dbgport=Disabled,dbglvl=None,usbstack=picosdk,ipbtstack=ipv4only,uploadmethod=default",
+    "configuration": "pnum=BLUEPILL_F103C8,upload_method=swdMethod,xserial=none,usb=CDCgen,xusb=FS,opt=osstd,dbg=none,rtlib=nano",
-    "board": "rp2040:rp2040:rpipico",
+    "board": "STMicroelectronics:stm32:GenF1",
     "port": "COM17",
     "output": "bin",
     "prebuild": "if exist bin rd /s /q bin",

IR-protocol.ino

@@ -1,44 +1,31 @@
 #include "IR_Decoder.h"
 #include "IR_Encoder.h"
 #include "TimerStatic.h"
-// #include "MemoryCheck.h"
+#include "MemoryCheck.h"
 /////////////// Pinout ///////////////
 
-#define dec0_PIN 0
+#define encForward_PIN PA0
-#define dec1_PIN 1
+#define encBackward_PIN PA1
-#define dec2_PIN 2
-#define dec3_PIN 3
-#define dec4_PIN 4
-#define dec5_PIN 5
-#define dec6_PIN 6
-#define dec7_PIN 7
-#define dec8_PIN 8
-#define dec9_PIN 9
-#define dec10_PIN 10
-#define dec11_PIN 11
-#define dec12_PIN 12
-#define dec13_PIN 13
-#define dec14_PIN 14
-#define dec15_PIN 15
 
-#define LoopOut 16
+#define dec0_PIN PB0
-#define LoopOut1 17
+#define dec1_PIN PB1
+#define dec2_PIN PB2
+#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 dec_ISR(n) \
+#define LoopOut PC13
-    void dec_##n##_ISR() { dec##n.isr(); }
-#define dec_Ini(n)                      \
-    IR_Decoder dec##n(dec##n##_PIN, n); \
-    dec_ISR(n)
 
-#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);
-
-void digitalToggle(uint8_t pin){
-    digitalWrite(pin, !digitalRead(pin));
-}
 
 //////////////// Ini /////////////////
 
@@ -46,44 +33,32 @@ void digitalToggle(uint8_t pin){
 #define SERIAL_SPEED 115200
 
 //////////////// Var /////////////////
-// IR_Encoder encForward(PA5, 42 /* , &decBackward */);
 
-IR_Encoder enc0(18, 42 /* , &decBackward */);
+IR_Decoder dec0(dec1_PIN, 0);
-IR_Encoder enc1(19, 127 /* , &decBackward */);
+IR_Decoder dec1(dec2_PIN, 1);
-IR_Encoder enc2(20, 137 /* , &decBackward */);
-IR_Encoder enc3(21, 777 /* , &decBackward */);
-// IR_Encoder enc10(PC15, 555 /* , &decBackward */);
-// IR_Encoder enc11(PC14, 127 /* , &decBackward */);
-// IR_Encoder enc12(PC13, 137 /* , &decBackward */);
-// IR_Encoder enc13(PA12, 777 /* , &decBackward */);
 
+IR_Encoder encForward(42 /* , &decBackward */);
+// IR_Encoder encBackward(321, encBackward_PIN);
 // IR_Encoder encTree(325, A2);
 
 //////////////////////// Функции прерываний ////////////////////////
 
 void EncoderISR()
 {
-    IR_Encoder::isr();
+    encForward.isr();
-    // digitalToggle(LoopOut);
+    // encBackward.isr();
+    // encTree.isr();
 
+    digitalWrite(PB5, encForward.ir_out_virtual);
 }
 
-//-------------------------------------------------------------------
+//------------------------------------------------------------------
+#define dec_ISR(n) \
+void dec_##n##_ISR() { dec##n.isr(); }
+
+dec_ISR(0);
+dec_ISR(1);
 
-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[] = {};
@@ -97,94 +72,84 @@ uint8_t sig = 0;
 uint16_t targetAddr = IR_Broadcast;
 Timer t1(500, millis, []()
          {
-             // Serial.println( digitalPinToBitMask(enc0.getPin()), BIN);
-             enc0.sendData(IR_Broadcast, data4, sizeof(data4));
-             enc1.sendData(IR_Broadcast, data3, sizeof(data3));
-             enc2.sendData(IR_Broadcast, data2, sizeof(data2));
-             enc3.sendData(IR_Broadcast, data1, sizeof(data1));
-            //  enc10.sendData(IR_Broadcast, data4, sizeof(data4));
-             //  enc11.sendData(IR_Broadcast, data3, sizeof(data3));
-             //  enc12.sendData(IR_Broadcast, data2, sizeof(data2));
-             //  enc13.sendData(IR_Broadcast, data1, sizeof(data1));
-
              // Serial.println(sig);
 
-             //  switch (sig)
+             switch (sig)
-             //  {
+             {
-             //  case 0:
+             case 0:
-             //      encForward.sendData(targetAddr);
+                 encForward.sendData(targetAddr);
-             //      break;
+                 break;
-             //  case 1:
+             case 1:
-             //      encForward.sendData(targetAddr, data1, sizeof(data1));
+                 encForward.sendData(targetAddr, data1, sizeof(data1));
-             //      break;
+                 break;
-             //  case 2:
+             case 2:
-             //      encForward.sendData(targetAddr, data2, sizeof(data2));
+                 encForward.sendData(targetAddr, data2, sizeof(data2));
-             //      break;
+                 break;
-             //  case 3:
+             case 3:
-             //      encForward.sendData(targetAddr, data3, sizeof(data3));
+                 encForward.sendData(targetAddr, data3, sizeof(data3));
-             //      break;
+                 break;
-             //  case 4:
+             case 4:
-             //      encForward.sendData(targetAddr, data4, sizeof(data4));
+                 encForward.sendData(targetAddr, data4, sizeof(data4));
-             //      break;
+                 break;
 
-             //  case 10:
+             case 10:
-             //      encForward.sendData(targetAddr, data0, sizeof(data0), true);
+                 encForward.sendData(targetAddr, data0, sizeof(data0), true);
-             //      break;
+                 break;
-             //  case 11:
+             case 11:
-             //      encForward.sendData(targetAddr, data1, sizeof(data1), true);
+                 encForward.sendData(targetAddr, data1, sizeof(data1), true);
-             //      break;
+                 break;
-             //  case 12:
+             case 12:
-             //      encForward.sendData(targetAddr, data2, sizeof(data2), true);
+                 encForward.sendData(targetAddr, data2, sizeof(data2), true);
-             //      break;
+                 break;
-             //  case 13:
+             case 13:
-             //      encForward.sendData(targetAddr, data3, sizeof(data3), true);
+                 encForward.sendData(targetAddr, data3, sizeof(data3), true);
-             //      break;
+                 break;
-             //  case 14:
+             case 14:
-             //      encForward.sendData(targetAddr, data4, sizeof(data4), true);
+                 encForward.sendData(targetAddr, data4, sizeof(data4), true);
-             //      break;
+                 break;
 
-             //  case 20:
+             case 20:
-             //      encForward.sendBack();
+                 encForward.sendBack();
-             //      break;
+                 break;
-             //  case 21:
+             case 21:
-             //      encForward.sendBack(data1, sizeof(data1));
+                 encForward.sendBack(data1, sizeof(data1));
-             //      break;
+                 break;
-             //  case 22:
+             case 22:
-             //      encForward.sendBack(data2, sizeof(data2));
+                 encForward.sendBack(data2, sizeof(data2));
-             //      break;
+                 break;
-             //  case 23:
+             case 23:
-             //      encForward.sendBack(data3, sizeof(data3));
+                 encForward.sendBack(data3, sizeof(data3));
-             //      break;
+                 break;
-             //  case 24:
+             case 24:
-             //      encForward.sendBack(data4, sizeof(data4));
+                 encForward.sendBack(data4, sizeof(data4));
-             //      break;
+                 break;
 
-             //  case 30:
+             case 30:
-             //      encForward.sendBackTo(targetAddr);
+                 encForward.sendBackTo(targetAddr);
-             //      break;
+                 break;
-             //  case 31:
+             case 31:
-             //      encForward.sendBackTo(targetAddr, data1, sizeof(data1));
+                 encForward.sendBackTo(targetAddr, data1, sizeof(data1));
-             //      break;
+                 break;
-             //  case 32:
+             case 32:
-             //      encForward.sendBackTo(targetAddr, data2, sizeof(data2));
+                 encForward.sendBackTo(targetAddr, data2, sizeof(data2));
-             //      break;
+                 break;
-             //  case 33:
+             case 33:
-             //      encForward.sendBackTo(targetAddr, data3, sizeof(data3));
+                 encForward.sendBackTo(targetAddr, data3, sizeof(data3));
-             //      break;
+                 break;
-             //  case 34:
+             case 34:
-             //      encForward.sendBackTo(targetAddr, data4, sizeof(data4));
+                 encForward.sendBackTo(targetAddr, data4, sizeof(data4));
-             //      break;
+                 break;
 
-             //  case 41:
+             case 41:
-             //      encForward.sendRequest(targetAddr);
+                 encForward.sendRequest(targetAddr);
-             //      break;
+                 break;
-             //  case 42:
+             case 42:
-             //      encForward.sendAccept(targetAddr);
+                 encForward.sendAccept(targetAddr);
-             //      break;
+                 break;
 
-             //  default:
+             default:
-             //      break;
+                 break;
-             //  }
+             }
              // encBackward.sendData(IR_Broadcast, data2);
              // encTree.sendData(IR_Broadcast, rawData3);
          });
@@ -193,109 +158,58 @@ Timer t1(500, millis, []()
 
 Timer signalDetectTimer;
 /////////////////////////////////////////////////////////////////////
-// HardwareTimer IR_Timer(TIM3);
+HardwareTimer IR_Timer(TIM3);
-// RPI_PICO_Timer  IR_Timer(0);
+HardwareTimer MicrosTimer(TIM1);
-struct repeating_timer timer;
+
+void MicrosTimerISR(){
 
-bool TimerISRHandler(struct repeating_timer *t){
-    (void) t;
-    EncoderISR();
-    return true;
 }
 
 void setup()
 {
-    pinMode(LoopOut1, OUTPUT);
-    add_repeating_timer_us(6, TimerISRHandler, NULL, &timer);
-
-    // IR_Timer.setOverflow(carrierFrec * 2, HERTZ_FORMAT);
-    // IR_Timer.attachInterrupt(1, EncoderISR);
-    // NVIC_SetPriority(IRQn_Type::TIM3_IRQn, 0);
-    // IR_Timer.resume();
-
     Serial.begin(SERIAL_SPEED);
     Serial.println(F(INFO));
 
+    IR_Timer.setOverflow(carrierFrec*2, HERTZ_FORMAT);
+    IR_Timer.attachInterrupt(1, EncoderISR);
+    
     pinMode(LoopOut, OUTPUT);
-    // pinMode(SignalDetectLed, OUTPUT);
 
-    pinMode(dec1_PIN, INPUT_PULLUP);
+    // IR_DecoderRaw* blindFromForward [] { &decForward, &decBackward };
-    // pinMode(dec2_PIN, INPUT_PULLUP);
+    // encForward.setBlindDecoders(blindFromForward, sizeof(blindFromForward) / sizeof(IR_DecoderRaw*));
 
-    static IR_DecoderRaw *blind[]{
-        &dec0,
-        &dec1,
-        &dec2,
-        &dec3,
-        &dec4,
-        &dec5,
-        &dec6,
-        &dec7,
-        &dec8,
-        &dec9,
-        &dec10,
-        &dec11,
-        &dec12,
-        &dec13,
-    };
 
-    // enc0.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
+    pinMode(encForward_PIN, OUTPUT);
-    // enc1.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
+    pinMode(encBackward_PIN, OUTPUT);
-    // enc2.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
+    pinMode(LED_BUILTIN, OUTPUT);
-    // enc3.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
+
-    // enc10.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
+#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);
+
+decSetup(0);
 
-    decSetup(0);
-    // 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()
 {
     digitalToggle(LoopOut);
-
-}
-
-
-
-void loop1()
-{
     Timer::tick();
-    IR_Decoder::tick();
 
-    bool rx_flag;
+
+
+    decTick(0);
+    decTick(1);
+
+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);
+    if(rx_flag){
-    // status(decBackward);
+        Serial.print("\n\n\n\n");
-
+    }
-    // Serial.println(micros() - loopTimer);
-    // loopTimer = micros();
-    // delayMicroseconds(120*5);
 
     if (Serial.available())
     {
@@ -316,35 +230,7 @@ void loop1()
             sig = in;
             break;
         }
-        Serial.println(in);
     }
-    digitalToggle(LoopOut1);
-}
-
-
-
-
-
-
-
-
-
-
-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()
@@ -355,6 +241,14 @@ void detectSignal()
 }
 
 // test
+
+bool statusSimple(IR_Decoder &dec){
+    if (dec.gotData.available())
+    {   
+        Serial.print("DEC "); Serial.println(dec.id); 
+    }
+}
+
 void status(IR_Decoder &dec)
 {
     if (dec.gotData.available())
@@ -365,7 +259,7 @@ void status(IR_Decoder &dec)
         if (/* dec.gotData.getDataPrt()[1] */ 1)
         {
             str += ("Data on pin ");
-            str += (dec.getPin());
+            str += (dec.isrPin);
             str += "\n";
 
             uint8_t msg = dec.gotData.getMsgRAW();
@@ -439,7 +333,7 @@ void status(IR_Decoder &dec)
         if (/* dec.gotData.getDataPrt()[1] */ 1)
         {
             str += ("BackData on pin ");
-            str += (dec.getPin());
+            str += (dec.isrPin);
             str += "\n";
 
             uint8_t msg = dec.gotBackData.getMsgRAW();
@@ -511,7 +405,7 @@ void status(IR_Decoder &dec)
         if (/* dec.gotData.getDataPrt()[1] */ 1)
         {
             str += ("Accept on pin ");
-            str += (dec.getPin());
+            str += (dec.isrPin);
             str += "\n";
 
             uint8_t msg = dec.gotAccept.getMsgRAW();
@@ -563,7 +457,7 @@ void status(IR_Decoder &dec)
         if (/* dec.gotData.getDataPrt()[1] */ 1)
         {
             str += ("Request on pin ");
-            str += (dec.getPin());
+            str += (dec.isrPin);
             str += "\n";
 
             uint8_t msg = dec.gotRequest.getMsgRAW();

IR_Decoder.cpp

@@ -1,72 +0,0 @@
-#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 pin, uint16_t addr, IR_Encoder *encPair)
-    : IR_DecoderRaw(pin, 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,11 +5,6 @@
 
 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;
@@ -24,16 +19,59 @@ public:
     PacketTypes::Request gotRequest;
     PacketTypes::BasePack gotRaw;
 
-    IR_Decoder(const uint8_t pin, uint16_t addr, IR_Encoder *encPair = nullptr);
+    IR_Decoder(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair = nullptr) : IR_DecoderRaw(isrPin, addr, encPair) {}
-    ~IR_Decoder();
 
-    static void tick();
+    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;
 
-    inline void setAcceptDelay(uint16_t acceptDelay)
+            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;
+        }
+    }
+
+    void setAcceptDelay(uint16_t acceptDelay)
     {
         this->acceptDelay = acceptDelay;
     }
-    inline uint16_t getAcceptDelay()
+    uint16_t getAcceptDelay()
     {
         return this->acceptDelay;
     }

IR_DecoderRaw.cpp

@@ -1,10 +1,8 @@
 #include "IR_DecoderRaw.h"
 #include "IR_Encoder.h"
 
-IR_DecoderRaw::IR_DecoderRaw(const uint8_t pin, uint16_t addr, IR_Encoder *encPair) : encoder(encPair)
+IR_DecoderRaw::IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair) : isrPin(isrPin), encoder(encPair)
 {
-    setPin(pin);
-    pinMode(pin, INPUT_PULLUP);
     id = addr;
     prevRise = prevFall = prevPrevFall = prevPrevRise = 0;
     if (encPair != nullptr)
@@ -22,37 +20,11 @@ IR_DecoderRaw::IR_DecoderRaw(const uint8_t pin, uint16_t addr, IR_Encoder *encPa
 #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_;
 
 void IR_DecoderRaw::isr()
 {
-
-    if(isPairSending){
-        return;
-    }
-
     noInterrupts();
     // time_ = HAL_GetTick() * 1000 + ((SysTick->LOAD + 1 - SysTick->VAL) * 1000) / SysTick->LOAD + 1;
     time_ = micros();
@@ -75,8 +47,7 @@ void IR_DecoderRaw::isr()
     oldTime = time_;
 
     FrontStorage edge;
-    // edge.dir = port->IDR & mask;
+    edge.dir = digitalRead(isrPin);
-    edge.dir = digitalRead(pin);
     edge.time = time_;
 
     subBuffer.push(edge);
@@ -84,6 +55,7 @@ void IR_DecoderRaw::isr()
 
 ////////////////////////////////////////////////////////////////////////////////////
 
+uint32_t wrCounter;
 void IR_DecoderRaw::firstRX()
 {
 
@@ -105,9 +77,9 @@ void IR_DecoderRaw::firstRX()
 
     isPreamb = true;
     riseSyncTime = bitTime /* 1100 */;
-#ifdef IRDEBUG
+
     wrCounter = 0;
-#endif
+
     memset(dataBuffer, 0x00, dataByteSizeMax);
 }
 
@@ -120,7 +92,6 @@ void IR_DecoderRaw::listenStart()
         firstRX();
     }
 }
-
 void IR_DecoderRaw::tick()
 {
     FrontStorage currentFront;
@@ -568,31 +539,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

@@ -14,6 +14,8 @@
 #define up PA3
 #define down PA2
 #endif
+#define up PA3
+#define down PA2
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -32,22 +34,43 @@ 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; // Пин прерывания
+
     //////////////////////////////////////////////////////////////////////////
     /// @brief Конструктор
-    /// @param pin Номер вывода прерывания/данных от приёмника (2 или 3 для atmega 328p)
+    /// @param isrPin Номер вывода прерывания/данных от приёмника (2 или 3 для atmega 328p)
     /// @param addr Адрес приёмника
     /// @param encPair Указатель на передатчик, работающий в паре
-    IR_DecoderRaw(const uint8_t pin, uint16_t addr, IR_Encoder *encPair = nullptr);
+    IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair = nullptr);
 
     void isr();  // Функция прерывания
     void tick(); // Обработка приёмника, необходима для работы
+    void tickOld();
 
-    inline bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился
+    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:
@@ -127,8 +150,7 @@ private:
     /// @return Результат
     uint16_t ceil_div(uint16_t val, uint16_t divider);
 
-#ifdef IRDEBUG
+#if true //def 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,16 +5,8 @@
 #define ISR_Out 10
 #define TestOut 13
 
-std::list<IR_Encoder*>& IR_Encoder::get_enc_list() // определение функции
+IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair)
 {
-    static std::list<IR_Encoder*> dec_list; // статическая локальная переменная
-    return dec_list; // возвращается ссылка на переменную
-}
-
-IR_Encoder::IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair)
-{
-    setPin(pin);
-    pinMode(pin,OUTPUT);
     id = addr;
     this->decPair = decPair;
     signal = noSignal;
@@ -31,9 +23,7 @@ IR_Encoder::IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair)
     {
         decPair->encoder = this;
     }
-    get_enc_list().push_back(this);
 };
-
 void IR_Encoder::setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count)
 {
 #if disablePairDec
@@ -48,7 +38,6 @@ 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)
@@ -152,7 +141,6 @@ 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);
@@ -242,25 +230,13 @@ 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;
 
-    // port->ODR &= ~(mask);
-    // port->ODR |= mask & (ir_out_virtual ? (uint16_t)0xFFFF : (uint16_t)0x0000);
-    digitalWrite(pin, ir_out_virtual);
-   
-
     if (toggleCounter)
     {
         toggleCounter--;
@@ -393,6 +369,34 @@ 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,14 +11,40 @@ class IR_Encoder : IR_FOX
 public:
 private:
     uint16_t id; /// @brief Адрес передатчика
+
 public:
-    
     /// @brief Класс передатчика
     /// @param addr Адрес передатчика
     /// @param pin  Вывод передатчика
+    /// @param tune Подстройка несущей частоты
     /// @param decPair Приёмник, для которого отключается приём в момент передачи передатчиком
-    IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair = nullptr);
+    IR_Encoder(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);
@@ -33,14 +59,13 @@ 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

@@ -1,34 +0,0 @@
-#include "IR_config.h"
-
-void IR_FOX::setPin(uint8_t pin){
-    this->pin = pin;
-    // port = digitalPinToPort(pin);
-    // mask = digitalPinToBitMask(pin);
-    // pinMode(pin, INPUT_PULLUP);
-}
-
-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,14 +1,13 @@
 #pragma once
 #include <Arduino.h>
-#include <list>
+
-// #define IRDEBUG_INFO
+#define IRDEBUG_INFO
 /*//////////////////////////////////////////////////////////////////////////////////////
 
 Для работы в паре положить декодер в энкодер
 
-*/
+*/// Адресация с 1 до 65 499
-// Адресация с 1 до 65 499
+#define IR_Broadcast 65000 // 65 500 ~ 65 535 - широковещательные пакеты (всем), возможно разделить на 35 типов 
-#define IR_Broadcast 65000 // 65 500 ~ 65 535 - широковещательные пакеты (всем), возможно разделить на 35 типов
 /*
 Адрес 0 запрещен и зарезервирован под NULL, либо тесты
 IR_MSG_ACCEPT с адреса 0 воспринимается всеми устройствами
@@ -41,59 +40,59 @@ msg type:
                                         //  | xxx..... | = тип сообщения
                                         //  | ...xxxxx | = длина (максимум 31 бита)
                                         //   ---------- */
-#define IR_MSG_BACK 0U          //  | 000...... | = Задний сигнал машинки
+#define IR_MSG_BACK                  0U //  | 000...... | = Задний сигнал машинки
-#define IR_MSG_ACCEPT 1U        //  | 001..... | = подтверждение
+#define IR_MSG_ACCEPT                1U //  | 001..... | = подтверждение 
-#define IR_MSG_REQUEST 2U       //  | 010..... | = запрос
+#define IR_MSG_REQUEST               2U //  | 010..... | = запрос
-// #define IR_MSG_ 3U           //  | 011..... | = ??
+#define IR_MSG_                      3U //  | 011..... | = ??
-#define IR_MSG_BACK_TO 4U       //  | 100..... | = Задний сигнал машинки c адресацией
+#define IR_MSG_BACK_TO               4U //  | 100..... | = Задний сигнал машинки c адресацией
-// #define IR_MSG_ 5U           //  | 101..... | = ??
+#define IR_MSG_                      5U //  | 101..... | = ??
-#define IR_MSG_DATA_NOACCEPT 6U //  | 110..... | = данные, не требующие подтверждения
+#define IR_MSG_DATA_NOACCEPT         6U //  | 110..... | = данные, не требующие подтверждения
-#define IR_MSG_DATA_ACCEPT 7U   //  | 111..... | = данные требующие подтверждения
+#define IR_MSG_DATA_ACCEPT           7U //  | 111..... | = данные требующие подтверждения
-;                               /*                                     //   ----------
+;/*                                     //   ----------
-                              
+
-                               /``````````````````````````````` подтверждение `````````````````````````````\      /``````````````````````````````````````` запрос ``````````````````````````````````\
+/``````````````````````````````` подтверждение `````````````````````````````\      /``````````````````````````````````````` запрос ``````````````````````````````````\
-                                                                                                                                                     
+                                                                                                                      
-                               {``````````} [````````````````````````] [``````````````````] [``````````````]      {``````````} [````````````````````````] [````````````````````````] [``````````````]
+{``````````} [````````````````````````] [``````````````````] [``````````````]      {``````````} [````````````````````````] [````````````````````````] [``````````````]
-                               { msg type } [   addr_from uint16_t   ] [=== customByte ===] [   CRC Bytes  ]      { msg type } [   addr_from uint16_t   ] [    addr_to uint16_t    ] [   CRC Bytes  ]
+{ msg type } [   addr_from uint16_t   ] [=== customByte ===] [   CRC Bytes  ]      { msg type } [   addr_from uint16_t   ] [    addr_to uint16_t    ] [   CRC Bytes  ]
-                               {..........} [........................] [..................] [..............]      {..........} [........................] [........................] [..............]
+{..........} [........................] [..................] [..............]      {..........} [........................] [........................] [..............]
-                                                                                                                                                                                           
+                                                                                                                                                            
-                               { 001..... } [addr_from_H][addr_from_L] [=== customByte ===] [ crc1 ][ crc2 ]      { 010..... } [addr_from_H][addr_from_L] [addr_from_H][addr_from_L] [ crc1 ][ crc2 ]
+{ 001..... } [addr_from_H][addr_from_L] [=== customByte ===] [ crc1 ][ crc2 ]      { 010..... } [addr_from_H][addr_from_L] [addr_from_H][addr_from_L] [ crc1 ][ crc2 ]
-                               |     0            1           2                  3              4       5          |     0            1           2              3           4           5       6    
+|     0            1           2                  3              4       5          |     0            1           2              3           4           5       6    
-                               \________________________________________________________________/       |          \_____________________________________________________________________/       |    
+\________________________________________________________________/       |          \_____________________________________________________________________/       |    
-                               |                                                                        |          |                                                                             |    
+|                                                                        |          |                                                                             |    
-                               \________________________________________________________________________/          \_____________________________________________________________________________/    
+\________________________________________________________________________/          \_____________________________________________________________________________/    
-                              
+
-                               customByte - контрольная сумма принятых данных по poly1
+customByte - контрольная сумма принятых данных по poly1
-                              
+
-                              
+
-                              
+
-                               /`````````````````````` Задний сигнал машинки без адресации ``````````````````````\        
+/`````````````````````` Задний сигнал машинки без адресации ``````````````````````\        
-                                                                                                                          
+                                                                                           
-                               {``````````} [````````````````````````] [````````````````````````] [``````````````]        
+{``````````} [````````````````````````] [````````````````````````] [``````````````]        
-                               { msg type } [   addr_from uint16_t   ] [====== data bytes ======] [   CRC Bytes  ]        
+{ msg type } [   addr_from uint16_t   ] [====== data bytes ======] [   CRC Bytes  ]        
-                               {..........} [........................] [........................] [..............]        
+{..........} [........................] [........................] [..............]        
-                                                                                                                          
+                                                                                           
-                               { 0000xxxx } [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ]        
+{ 0000xxxx } [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ]        
-                               |     0           1            2            3                         |       |            
+|     0           1            2            3                         |       |            
-                               \_____________________________________________________________________/       |            
+\_____________________________________________________________________/       |            
-                               |                                                                             |            
+|                                                                             |            
-                               \_____________________________________________________________________________/            
+\_____________________________________________________________________________/            
-                              
+
-                              
+
-                              
+
-                               /```````````````````````````````````` Задний сигнал машинки с адресацией ````````````````````````````````````\ 
+/```````````````````````````````````` Задний сигнал машинки с адресацией ````````````````````````````````````\ 
-                                                                                                                   
+                                                                                    
-                               {``````````} [````````````````````````] [````````````````````````] [````````````````````````] [``````````````] 
+{``````````} [````````````````````````] [````````````````````````] [````````````````````````] [``````````````] 
-                               { msg type } [   addr_from uint16_t   ] [    addr_to uint16_t    ] [====== data bytes ======] [   CRC Bytes  ] 
+{ msg type } [   addr_from uint16_t   ] [    addr_to uint16_t    ] [====== data bytes ======] [   CRC Bytes  ] 
-                               {..........} [........................] [........................] [........................] [..............] 
+{..........} [........................] [........................] [........................] [..............] 
-                                                                                                                                              
+                                                                                                               
-                               { 0001xxxx } [addr_from_H][addr_from_L] [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ] 
+{ 0001xxxx } [addr_from_H][addr_from_L] [addr_from_H][addr_from_L] [data_H][data_n..][data_L] [ crc1 ][ crc2 ] 
-                               |     0           1            2              3           4            5                         |       |     
+|     0           1            2              3           4            5                         |       |     
-                               \________________________________________________________________________________________________/       |     
+\________________________________________________________________________________________________/       |     
-                               |                                                                                                        |     
+|                                                                                                        |     
-                               \________________________________________________________________________________________________________/     
+\________________________________________________________________________________________________________/     
-                              
+
-                               */
+*/
 
 #define IR_MASK_MSG_TYPE 0b00000111
 #define IR_MASK_MSG_INFO 0b00011111
@@ -102,14 +101,14 @@ msg type:
 /////////////////////////////////////////////////////////////////////////////////////*/
 typedef uint16_t crc_t;
 
-// #define BRUTEFORCE_CHECK                            // Перепроверяет пакет на 1 битные ошибки //TODO: зависает
+#define BRUTEFORCE_CHECK                            // Перепроверяет пакет на 1 битные ошибки //TODO: зависает
-#define bytePerPack 16 // колличество байтов в пакете
+#define bytePerPack 16                              // колличество байтов в пакете
 #ifndef freeFrec
 #define freeFrec false
 #endif
 
 #ifndef subBufferSize
-#define subBufferSize 50 // Буфер для складирования фронтов, пока их не обработают (передатчик)
+#define subBufferSize 5 //Буфер для складирования фронтов, пока их не обработают (передатчик)
 #endif
 
 #define preambPulse 3
@@ -118,35 +117,32 @@ typedef uint16_t crc_t;
 
 /////////////////////////////////////////////////////////////////////////////////////
 
-#define bitPerByte 8U // Колличество бит в байте
+#define bitPerByte 8U                                       // Колличество бит в байте
 #define addrBytes 2
 #define msgBytes 1
 #define crcBytes 2
 #define poly1 0x31
 #define poly2 0x8C
-#define syncBits 3U // количество битов синхронизации
+#define syncBits 3U                                         // количество битов синхронизации
 
 #define dataByteSizeMax (msgBytes + addrBytes + addrBytes + bytePerPack + crcBytes)
 
-#define preambFronts (preambPulse * 2)                              // количество фронтов преамбулы (Приём)
+#define preambFronts (preambPulse*2)                        // количество фронтов преамбулы (Приём)
 #define preambToggle ((bitPauseTakts * 2 + bitActiveTakts) * 2 - 1) // колличество переключений преамбулы (Передача)
 
-#define carrierFrec 38000U                     // частота несущей (Приём/Передача)
+#define carrierFrec 38000U                                  // частота несущей (Приём/Передача)
-#define carrierPeriod (1000000U / carrierFrec) // период несущей в us (Приём)
+#define carrierPeriod (1000000U/carrierFrec)                // период несущей в us (Приём)
 
 // В процессе работы значения будут отклонятся в соответствии с предыдущим битом
-#define bitActiveTakts 25U // длительность высокого уровня в тактах
+#define bitActiveTakts 25U                                  // длительность высокого уровня в тактах 
-#define bitPauseTakts 12U  // длительность низкого уровня в тактах
+#define bitPauseTakts 12U                                    // длительность низкого уровня в тактах
 
-#define bitTakts (bitActiveTakts + bitPauseTakts) // Общая длительность бита в тактах
+#define bitTakts (bitActiveTakts+bitPauseTakts)          // Общая длительность бита в тактах
-#define bitTime (bitTakts * carrierPeriod)        // Общая длительность бита
+#define bitTime (bitTakts*carrierPeriod)                    // Общая длительность бита
 #define tolerance 300U
-
+class IR_FOX {
-class IR_FOX
-{
 public:
-    struct PackOffsets
+    struct PackOffsets {
-    {
         uint8_t msgOffset;
         uint8_t addrFromOffset;
         uint8_t addrToOffset;
@@ -154,41 +150,54 @@ public:
         uint8_t crcOffset;
     };
 
-    struct ErrorsStruct
+    struct ErrorsStruct {
-    {
         uint8_t lowSignal = 0;
         uint8_t highSignal = 0;
         uint8_t other = 0;
 
-        void reset()
+        void reset() {
-        {
             lowSignal = 0;
             highSignal = 0;
             other = 0;
         }
         uint16_t all() { return lowSignal + highSignal + other; }
+
     };
 
-    struct PackInfo
+    struct PackInfo {
-    {
+        uint8_t* buffer = nullptr;
-        uint8_t *buffer = nullptr;
         uint8_t packSize = 0;
         uint16_t crc = 0;
         ErrorsStruct err;
         uint16_t rTime = 0;
     };
 
-    inline uint16_t getId() { return id; }
+    static void checkAddressRuleApply(uint16_t address, uint16_t id, bool& flag) {
-    inline void setId(uint16_t id) { this->id = id; }
+        flag = false;
-    static void checkAddressRuleApply(uint16_t address, uint16_t id, bool &flag);
+        flag |= id == 0;
-    void setPin(uint8_t pin);
+        flag |= address == id;
-    inline uint8_t getPin(){return pin;};
+        flag |= address >= IR_Broadcast;
+    }
+
+    uint16_t getId() { return id; }
+    void setId(uint16_t id) { this->id = id; }
 
-protected:
     uint16_t id;
-    uint8_t pin;
+protected:
-    // GPIO_TypeDef *port;
-    uint16_t mask;
     ErrorsStruct errors;
-    uint8_t crc8(uint8_t *data, uint8_t start, uint8_t end, uint8_t poly);
+    uint8_t 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;
+    }
+
 };

PacketTypes.cpp

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