test

public id
Merge pull request #4 from Show-maket:STM32_BRUTEFORCE_FIXHACK
2025-06-27 20:59:37 +00:00 · 2024-04-22 14:55:16 +03:00 · 2024-04-22 14:55:07 +03:00 · 2024-04-22 13:34:02 +03:00 · 2024-04-22 13:33:23 +03:00 · 2024-04-22 12:52:41 +03:00
12 changed files with 1349 additions and 837 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1 +1,5 @@
 .vscode/*
+bin/*
+!.vscode/arduino.json
+!.vscode/launch.json
+log/*
--- a/.vscode/arduino.json
+++ b/.vscode/arduino.json
@ -0,0 +1,8 @@
+{
+    "configuration": "pnum=BLUEPILL_F103C8,upload_method=swdMethod,xserial=none,usb=CDCgen,xusb=FS,opt=osstd,dbg=none,rtlib=nano",
+    "board": "STMicroelectronics:stm32:GenF1",
+    "port": "COM17",
+    "output": "bin",
+    "prebuild": "if exist bin rd /s /q bin",
+    "sketch": "IR-protocol.ino"
+}
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -0,0 +1,20 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+      
+      {
+        "cwd": "${workspaceFolder}",
+        "executable": "${workspaceFolder}/bin/${workspaceFolderBasename}.ino.elf",
+        "name": "Debug with ST-Link",
+        "request": "launch",
+        "type": "cortex-debug",
+        "runToEntryPoint": "main",
+        "showDevDebugOutput": "raw",
+        "servertype": "stlink",
+        "armToolchainPath": "C://Program Files (x86)//Arm GNU Toolchain arm-none-eabi//13.2 Rel1//bin"
+      }
+    ]
+  }
--- a/IR-protocol.ino
+++ b/IR-protocol.ino
@ -4,13 +4,28 @@
 #include "MemoryCheck.h"
 /////////////// Pinout ///////////////

-#define encForward_PIN    5
-#define encBackward_PIN   6
+#define encForward_PIN PA0
+#define encBackward_PIN PA1

-#define LoopOut 12
-#define ISR_Out 10
+#define dec0_PIN PB0
+#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 LoopOut PC13

-#define TestOut 13

 //////////////// Ini /////////////////

@ -19,54 +34,50 @@

 //////////////// Var /////////////////

-IR_Decoder decForward(2, 555);
-IR_Decoder decBackward(3, 777);
+IR_Decoder dec0(dec1_PIN, 0);
+IR_Decoder dec1(dec2_PIN, 1);

-IR_Encoder encForward(42, encForward_PIN, &decBackward);
+IR_Encoder encForward(42 /* , &decBackward */);
 // IR_Encoder encBackward(321, encBackward_PIN);
 // IR_Encoder encTree(325, A2);

 //////////////////////// Функции прерываний ////////////////////////

-void decForwardISR() {
-    decForward.isr();
-}
-
-void decBackwardISR() {
-    decBackward.isr();
-}
-
-static uint8_t* portOut;
-ISR(TIMER2_COMPA_vect) {
+void EncoderISR()
+{
    encForward.isr();
    // encBackward.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);
 }
+
+//------------------------------------------------------------------
+#define dec_ISR(n) \
+void dec_##n##_ISR() { dec##n.isr(); }
+
+dec_ISR(0);
+dec_ISR(1);
+
+
 /////////////////////////////////////////////////////////////////////
-uint8_t data0 [] = { };
-uint8_t data1 [] = { 42 };
-uint8_t data2 [] = { 42 , 127 };
-uint8_t data3 [] = { 42 , 127, 137 };
-uint8_t data4 [] = { 42 , 127, 137, 255 };
+uint8_t data0[] = {};
+uint8_t data1[] = {42};
+uint8_t data2[] = {42, 127};
+uint8_t data3[] = {42, 127, 137};
+uint8_t data4[] = {42, 127, 137, 255};

 uint32_t loopTimer;
-uint8_t sig = 255;
-
+uint8_t sig = 0;
 uint16_t targetAddr = IR_Broadcast;
-Timer t1(500, millis, []() {
-
+Timer t1(500, millis, []()
+         {
             // Serial.println(sig);

-    switch (sig) {
+             switch (sig)
+             {
             case 0:
-            encForward.sendData(targetAddr, data0, sizeof(data0));
+                 encForward.sendData(targetAddr);
                 break;
             case 1:
                 encForward.sendData(targetAddr, data1, sizeof(data1));
@ -97,8 +108,6 @@ Timer t1(500, millis, []() {
                 encForward.sendData(targetAddr, data4, sizeof(data4), true);
                 break;

-
-
             case 20:
                 encForward.sendBack();
                 break;
@ -138,71 +147,75 @@ Timer t1(500, millis, []() {
                 encForward.sendAccept(targetAddr);
                 break;

-
             default:
                 break;
             }
             // encBackward.sendData(IR_Broadcast, data2);
             // encTree.sendData(IR_Broadcast, rawData3);
-});
-Timer t2(500, millis, []() {
-    digitalToggle(13);
-});
-/////////////////////////////////////////////////////////////////////
-void setup() {
-    IR_Encoder::timerSetup();
-    portOut = &PORTD;
+         });
+// Timer t2(50, millis, []()
+//          { digitalToggle(LED_BUILTIN); });

+Timer signalDetectTimer;
+/////////////////////////////////////////////////////////////////////
+HardwareTimer IR_Timer(TIM3);
+HardwareTimer MicrosTimer(TIM1);
+
+void MicrosTimerISR(){
+
+}
+
+void setup()
+{
    Serial.begin(SERIAL_SPEED);
    Serial.println(F(INFO));

-    pinMode(A0, INPUT_PULLUP);
-    pinMode(A1, INPUT_PULLUP);
-    pinMode(A2, INPUT_PULLUP);
-    pinMode(A3, INPUT_PULLUP);
+    IR_Timer.setOverflow(carrierFrec*2, HERTZ_FORMAT);
+    IR_Timer.attachInterrupt(1, EncoderISR);
    
    pinMode(LoopOut, OUTPUT);
-    pinMode(ISR_Out, OUTPUT);

-    pinMode(2, INPUT_PULLUP);
-    pinMode(3, INPUT_PULLUP);
+    // IR_DecoderRaw* blindFromForward [] { &decForward, &decBackward };
+    // encForward.setBlindDecoders(blindFromForward, sizeof(blindFromForward) / sizeof(IR_DecoderRaw*));
+

-    pinMode(8, OUTPUT);
-    pinMode(9, OUTPUT);
-    pinMode(11, OUTPUT);
-    pinMode(13, OUTPUT);
    pinMode(encForward_PIN, OUTPUT);
    pinMode(encBackward_PIN, OUTPUT);
-    pinMode(13, OUTPUT);
+    pinMode(LED_BUILTIN, OUTPUT);

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

-    IR_DecoderRaw* blindFromForward [] { &decForward, &decBackward };
-    encForward.setBlindDecoders(blindFromForward, sizeof(blindFromForward) / sizeof(IR_DecoderRaw*));
-
-
-    attachInterrupt(0, decForwardISR, CHANGE);  // D2 
-    attachInterrupt(1, decBackwardISR, CHANGE); // D3
 }

-void loop() {
+void loop()
+{
    digitalToggle(LoopOut);
    Timer::tick();

-    decForward.tick();
-    decBackward.tick();
-
-    status(decForward);
-    status(decBackward);


-    // Serial.println(micros() - loopTimer);
-    // loopTimer = micros();
-    // delayMicroseconds(120*5);
+    decTick(0);
+    decTick(1);

-    if (Serial.available()) {
+bool rx_flag;
+    decStat(0);
+    decStat(1);
+
+    if(rx_flag){
+        Serial.print("\n\n\n\n");
+    }
+
+    if (Serial.available())
+    {
        uint8_t in = Serial.parseInt();
-        switch (in) {
+        switch (in)
+        {
        case 100:
            targetAddr = IR_Broadcast;
            break;
@ -220,36 +233,63 @@ void loop() {
    }
 }

+void detectSignal()
+{
+    // digitalWrite(SignalDetectLed, HIGH);
+    // signalDetectTimer.delay(50, millis, []()
+    //                         { digitalWrite(SignalDetectLed, LOW); });
+}

+// test

+bool statusSimple(IR_Decoder &dec){
+    if (dec.gotData.available())
+    {   
+        Serial.print("DEC "); Serial.println(dec.id); 
+    }
+}

-
-
-//test
-void status(IR_Decoder& dec) {
-    if (dec.gotData.available()) {
+void status(IR_Decoder &dec)
+{
+    if (dec.gotData.available())
+    {
+        detectSignal();
+        Serial.println(micros());
        String str;
-        if (/* dec.gotData.getDataPrt()[1] */1) {
-            str += ("Data on pin ");        str += (dec.isrPin); str += "\n";
+        if (/* dec.gotData.getDataPrt()[1] */ 1)
+        {
+            str += ("Data on pin ");
+            str += (dec.isrPin);
+            str += "\n";

            uint8_t msg = dec.gotData.getMsgRAW();
            str += ("  MSG: ");
-            for (size_t i = 0; i < 8; i++) {
-                if (i == 3) str += " ";
+            for (size_t i = 0; i < 8; i++)
+            {
+                if (i == 3)
+                    str += " ";
                str += (msg >> (7 - i)) & 1U;
            }

            str += "\n";

-            str += ("  DATA SIZE: "); str += (dec.gotData.getDataSize()); str += "\n";
-            str += ("  ADDRESS FROM: "); str += (dec.gotData.getAddrFrom()); str += "\n";
-            str += ("  ADDRESS TO: "); str += (dec.gotData.getAddrTo()); str += "\n";
+            str += ("  DATA SIZE: ");
+            str += (dec.gotData.getDataSize());
+            str += "\n";
+            str += ("  ADDRESS FROM: ");
+            str += (dec.gotData.getAddrFrom());
+            str += "\n";
+            str += ("  ADDRESS TO: ");
+            str += (dec.gotData.getAddrTo());
+            str += "\n";
            // str += ("  CRC PACK: "); str += (dec.gotData.getCrcIN()); str += "\n";
            // str += ("  CRC CALC: "); str += (dec.gotData.getCrcCALC()); str += "\n";
            str += "\n";

-            for (size_t i = 0; i < min(10, dec.gotData.getDataSize()); i++) {
-                switch (i) {
+            for (size_t i = 0; i < min(uint8_t(10), dec.gotData.getDataSize()); i++)
+            {
+                switch (i)
+                {
                    // case 0:
                    //     str += ("  ADDR: ");
                    //     break;
@ -258,48 +298,70 @@ void status(IR_Decoder& dec) {
                    //     break;

                default:
-                        str += ("  Data["); str += (i); str += ("]: ");
+                    str += ("  Data[");
+                    str += (i);
+                    str += ("]: ");
                    break;
                }
-                str += (dec.gotData.getDataPrt()[i]); str += "\n";
+                str += (dec.gotData.getDataPrt()[i]);
+                str += "\n";
            }

-
-            str += ("\n*******ErrAll: ");     str += (dec.gotData.getErrorCount()); str += "\n";
-            str += ("**ErrDistance: ");     str += ((int)(dec.gotData.getErrorHighSignal() - dec.gotData.getErrorLowSignal())); str += "\n";
+            str += ("\n*******ErrAll: ");
+            str += (dec.gotData.getErrorCount());
+            str += "\n";
+            str += ("**ErrDistance: ");
+            str += ((int)(dec.gotData.getErrorHighSignal() - dec.gotData.getErrorLowSignal()));
+            str += "\n";

            str += "\n";
-        } else {
-            str += ("SELF"); str += "\n";
+        }
+        else
+        {
+            str += ("SELF");
+            str += "\n";
            str += "\n";
        }
        // obj->resetAvailable();
        Serial.write(str.c_str());
    }

-    if (dec.gotBackData.available()) {
+    if (dec.gotBackData.available())
+    {
+        detectSignal();
        String str;
-        if (/* dec.gotData.getDataPrt()[1] */1) {
-            str += ("BackData on pin ");        str += (dec.isrPin); str += "\n";
+        if (/* dec.gotData.getDataPrt()[1] */ 1)
+        {
+            str += ("BackData on pin ");
+            str += (dec.isrPin);
+            str += "\n";

            uint8_t msg = dec.gotBackData.getMsgRAW();
            str += ("  MSG: ");
-            for (size_t i = 0; i < 8; i++) {
-                if (i == 3) str += " ";
+            for (size_t i = 0; i < 8; i++)
+            {
+                if (i == 3)
+                    str += " ";
                str += (msg >> (7 - i)) & 1U;
            }

            str += "\n";

-            str += ("  DATA SIZE: "); str += (dec.gotBackData.getDataSize()); str += "\n";
-            str += ("  ADDRESS FROM: "); str += (dec.gotBackData.getAddrFrom()); str += "\n";
+            str += ("  DATA SIZE: ");
+            str += (dec.gotBackData.getDataSize());
+            str += "\n";
+            str += ("  ADDRESS FROM: ");
+            str += (dec.gotBackData.getAddrFrom());
+            str += "\n";
            // str += ("  ADDRESS TO: "); str += (dec.gotBackData.getAddrTo()); str += "\n";
            // str += ("  CRC PACK: "); str += (dec.gotBackData.getCrcIN()); str += "\n";
            // str += ("  CRC CALC: "); str += (dec.gotBackData.getCrcCALC()); str += "\n";
            str += "\n";

-            for (size_t i = 0; i < min(10, dec.gotBackData.getDataSize()); i++) {
-                switch (i) {
+            for (size_t i = 0; i < min(uint8_t(10), dec.gotBackData.getDataSize()); i++)
+            {
+                switch (i)
+                {
                    // case 0:
                    //     str += ("  ADDR: ");
                    //     break;
@ -308,97 +370,134 @@ void status(IR_Decoder& dec) {
                    //     break;

                default:
-                        str += ("  Data["); str += (i); str += ("]: ");
+                    str += ("  Data[");
+                    str += (i);
+                    str += ("]: ");
                    break;
                }
-                str += (dec.gotBackData.getDataPrt()[i]); str += "\n";
+                str += (dec.gotBackData.getDataPrt()[i]);
+                str += "\n";
            }

-
-            str += ("\n*******ErrAll: ");     str += (dec.gotBackData.getErrorCount()); str += "\n";
-            str += ("**ErrDistance: ");     str += ((int)(dec.gotBackData.getErrorHighSignal() - dec.gotBackData.getErrorLowSignal())); str += "\n";
+            str += ("\n*******ErrAll: ");
+            str += (dec.gotBackData.getErrorCount());
+            str += "\n";
+            str += ("**ErrDistance: ");
+            str += ((int)(dec.gotBackData.getErrorHighSignal() - dec.gotBackData.getErrorLowSignal()));
+            str += "\n";

            str += "\n";
-        } else {
-            str += ("SELF"); str += "\n";
+        }
+        else
+        {
+            str += ("SELF");
+            str += "\n";
            str += "\n";
        }
        // obj->resetAvailable();
        Serial.write(str.c_str());
    }

-    if (dec.gotAccept.available()) {
+    if (dec.gotAccept.available())
+    {
+        detectSignal();
        String str;
-        if (/* dec.gotData.getDataPrt()[1] */1) {
-            str += ("Accept on pin ");        str += (dec.isrPin); str += "\n";
+        if (/* dec.gotData.getDataPrt()[1] */ 1)
+        {
+            str += ("Accept on pin ");
+            str += (dec.isrPin);
+            str += "\n";

            uint8_t msg = dec.gotAccept.getMsgRAW();
            str += ("  MSG: ");
-            for (size_t i = 0; i < 8; i++) {
-                if (i == 3) str += " ";
+            for (size_t i = 0; i < 8; i++)
+            {
+                if (i == 3)
+                    str += " ";
                str += (msg >> (7 - i)) & 1U;
            }

            str += "\n";

            // str += ("  DATA SIZE: "); str += (dec.gotAccept.getDataSize()); str += "\n";
-            str += ("  ADDRESS FROM: "); str += (dec.gotAccept.getAddrFrom()); str += "\n";
+            str += ("  ADDRESS FROM: ");
+            str += (dec.gotAccept.getAddrFrom());
+            str += "\n";
            // str += ("  ADDRESS TO: "); str += (dec.gotAccept.getAddrTo()); str += "\n";
            // str += ("  CRC PACK: "); str += (dec.gotAccept.getCrcIN()); str += "\n";
            // str += ("  CRC CALC: "); str += (dec.gotAccept.getCrcCALC()); str += "\n";
            str += "\n";

-            str += ("  Data: "); str += (dec.gotAccept.getCustomByte());
+            str += ("  Data: ");
+            str += (dec.gotAccept.getCustomByte());

-
-
-            str += ("\n\n*******ErrAll: ");     str += (dec.gotAccept.getErrorCount()); str += "\n";
-            str += ("**ErrDistance: ");     str += ((int)(dec.gotAccept.getErrorHighSignal() - dec.gotAccept.getErrorLowSignal())); str += "\n";
+            str += ("\n\n*******ErrAll: ");
+            str += (dec.gotAccept.getErrorCount());
+            str += "\n";
+            str += ("**ErrDistance: ");
+            str += ((int)(dec.gotAccept.getErrorHighSignal() - dec.gotAccept.getErrorLowSignal()));
+            str += "\n";

            str += "\n";
-        } else {
-            str += ("SELF"); str += "\n";
+        }
+        else
+        {
+            str += ("SELF");
+            str += "\n";
            str += "\n";
        }
        // obj->resetAvailable();
        Serial.write(str.c_str());
    }

-    if (dec.gotRequest.available()) {
+    if (dec.gotRequest.available())
+    {
+        detectSignal();
        String str;
-        if (/* dec.gotData.getDataPrt()[1] */1) {
-            str += ("Request on pin ");        str += (dec.isrPin); str += "\n";
+        if (/* dec.gotData.getDataPrt()[1] */ 1)
+        {
+            str += ("Request on pin ");
+            str += (dec.isrPin);
+            str += "\n";

            uint8_t msg = dec.gotRequest.getMsgRAW();
            str += ("  MSG: ");
-            for (size_t i = 0; i < 8; i++) {
-                if (i == 3) str += " ";
+            for (size_t i = 0; i < 8; i++)
+            {
+                if (i == 3)
+                    str += " ";
                str += (msg >> (7 - i)) & 1U;
            }

            str += "\n";

            // str += ("  DATA SIZE: "); str += (dec.gotRequest.getDataSize()); str += "\n";
-            str += ("  ADDRESS FROM: "); str += (dec.gotRequest.getAddrFrom()); str += "\n";
-            str += ("  ADDRESS TO: "); str += (dec.gotRequest.getAddrTo()); str += "\n";
+            str += ("  ADDRESS FROM: ");
+            str += (dec.gotRequest.getAddrFrom());
+            str += "\n";
+            str += ("  ADDRESS TO: ");
+            str += (dec.gotRequest.getAddrTo());
+            str += "\n";
            // str += ("  CRC PACK: "); str += (dec.gotRequest.getCrcIN()); str += "\n";
            // str += ("  CRC CALC: "); str += (dec.gotRequest.getCrcCALC()); str += "\n";
            str += "\n";

-
-            str += ("\n*******ErrAll: ");     str += (dec.gotRequest.getErrorCount()); str += "\n";
-            str += ("**ErrDistance: ");     str += ((int)(dec.gotRequest.getErrorHighSignal() - dec.gotRequest.getErrorLowSignal())); str += "\n";
+            str += ("\n*******ErrAll: ");
+            str += (dec.gotRequest.getErrorCount());
+            str += "\n";
+            str += ("**ErrDistance: ");
+            str += ((int)(dec.gotRequest.getErrorHighSignal() - dec.gotRequest.getErrorLowSignal()));
+            str += "\n";

            str += "\n";
-        } else {
-            str += ("SELF"); str += "\n";
+        }
+        else
+        {
+            str += ("SELF");
+            str += "\n";
            str += "\n";
        }
        // obj->resetAvailable();
        Serial.write(str.c_str());
    }
-
-
 }
-
-
--- a/IR_Decoder.h
+++ b/IR_Decoder.h
@ -3,7 +3,8 @@
 #include "PacketTypes.h"
 #include "IR_Encoder.h"

-class IR_Decoder : public IR_DecoderRaw {
+class IR_Decoder : public IR_DecoderRaw
+{
    uint32_t acceptSendTimer;
    bool isWaitingAcceptSend;
    uint16_t addrAcceptSendTo;
@ -12,22 +13,25 @@ class IR_Decoder : public IR_DecoderRaw {
    uint8_t acceptCustomByte;

 public:
-
    PacketTypes::Data gotData;
    PacketTypes::DataBack gotBackData;
    PacketTypes::Accept gotAccept;
    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_DecoderRaw(isrPin, addr, encPair) {}

-    void tick() {
+    void tick()
+    {
        IR_DecoderRaw::tick();
-        if (available()) {
-            #ifdef IRDEBUG_INFO
+        if (availableRaw())
+        {
+#ifdef IRDEBUG_INFO
            Serial.println("PARSING RAW DATA");
-            #endif
+#endif
            isWaitingAcceptSend = false;
-            switch (packInfo.buffer[0] >> 5 & IR_MASK_MSG_TYPE) {
+            switch (packInfo.buffer[0] >> 5 & IR_MASK_MSG_TYPE)
+            {
            case IR_MSG_DATA_ACCEPT:
            case IR_MSG_DATA_NOACCEPT:
                gotData.set(&packInfo, id);
@ -46,23 +50,29 @@ public:
            default:
                break;
            }
-            if (gotData.isAvailable && (gotData.getMsgType() == IR_MSG_DATA_ACCEPT)) {
+            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;
+                if (addrAcceptSendTo && addrAcceptSendTo < IR_Broadcast)
+                    isWaitingAcceptSend = true;
            }
+            gotRaw.set(&packInfo, id);
        }
-        if (isWaitingAcceptSend && millis() - acceptSendTimer > 75) {
+        if (isWaitingAcceptSend && millis() - acceptSendTimer > 75)
+        {
            encoder->sendAccept(addrAcceptSendTo, acceptCustomByte);
            isWaitingAcceptSend = false;
        }
    }

-    void setAcceptDelay(uint16_t acceptDelay) {
+    void setAcceptDelay(uint16_t acceptDelay)
+    {
        this->acceptDelay = acceptDelay;
    }
-    uint16_t getAcceptDelay() {
+    uint16_t getAcceptDelay()
+    {
        return this->acceptDelay;
    }
 };
--- a/IR_DecoderRaw.cpp
+++ b/IR_DecoderRaw.cpp
@ -1,53 +1,67 @@
 #include "IR_DecoderRaw.h"
 #include "IR_Encoder.h"

-
-IR_DecoderRaw::IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder* encPair = nullptr) : isrPin(isrPin), id(addr), encoder(encPair) {
+IR_DecoderRaw::IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair) : isrPin(isrPin), encoder(encPair)
+{
+    id = addr;
    prevRise = prevFall = prevPrevFall = prevPrevRise = 0;
-    if (encPair != nullptr) {
+    if (encPair != nullptr)
+    {
        encPair->decPair = this;
    }
+
+#ifdef IRDEBUG
+    pinMode(wrHigh, OUTPUT);
+    pinMode(wrLow, OUTPUT);
+    pinMode(writeOp, OUTPUT);
+    pinMode(errOut, OUTPUT);
+    pinMode(up, OUTPUT);
+    pinMode(down, OUTPUT);
+#endif
 }

 //////////////////////////////////// isr ///////////////////////////////////////////
+volatile uint32_t time_;

-void IR_DecoderRaw::isr() {
-    if (isPairSending) return;
-
-    subBuffer[currentSubBufferIndex].next = nullptr;
-    subBuffer[currentSubBufferIndex].dir = (PIND >> isrPin) & 1;
-    subBuffer[currentSubBufferIndex].time = micros();
-
-    if (firstUnHandledFront == nullptr) {
-        firstUnHandledFront = &subBuffer[currentSubBufferIndex]; // Если нет необработанных данных - добавляем их
-    } else {
-        if (firstUnHandledFront == &subBuffer[currentSubBufferIndex]) { // Если контроллер не успел обработать новый сигнал, принудительно пропускаем его
-            firstUnHandledFront = firstUnHandledFront->next;
-            #ifdef IRDEBUG_INFO
-            // Serial.println();
-            Serial.println(" ISR BUFFER OVERFLOW ");
-            // Serial.println();
-            #endif
-        }
+void IR_DecoderRaw::isr()
+{
+    noInterrupts();
+    // time_ = HAL_GetTick() * 1000 + ((SysTick->LOAD + 1 - SysTick->VAL) * 1000) / SysTick->LOAD + 1;
+    time_ = micros();
+    interrupts();
+    if (time_ < oldTime)
+    {
+#ifdef IRDEBUG
+        Serial.print("\n");
+        Serial.print("count:         ");
+        Serial.println(wrongCounter++);
+        Serial.print("time:                 ");
+        Serial.println(time_);
+        Serial.print("oldTime:              ");
+        Serial.println(oldTime);
+        Serial.print("sub:                        ");
+        Serial.println(max((uint32_t)time_, oldTime) - min((uint32_t)time_, oldTime));
+#endif
+        time_ += 1000;
    }
+    oldTime = time_;

-    if (lastFront == nullptr) {
-        lastFront = &subBuffer[currentSubBufferIndex];
-    } else {
-        lastFront->next = &subBuffer[currentSubBufferIndex];
-        lastFront = &subBuffer[currentSubBufferIndex];
-    }
+    FrontStorage edge;
+    edge.dir = digitalRead(isrPin);
+    edge.time = time_;

-    currentSubBufferIndex == (subBufferSize - 1) ? currentSubBufferIndex = 0 : currentSubBufferIndex++; // Закольцовка буффера
+    subBuffer.push(edge);
 }

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

-void IR_DecoderRaw::firstRX() {
+uint32_t wrCounter;
+void IR_DecoderRaw::firstRX()
+{

-    #ifdef IRDEBUG_INFO
+#ifdef IRDEBUG_INFO
    Serial.print("\nRX>");
-    #endif
+#endif

    errors.reset();
    packSize = 0;
@ -64,240 +78,361 @@ void IR_DecoderRaw::firstRX() {
    isPreamb = true;
    riseSyncTime = bitTime /* 1100 */;

+    wrCounter = 0;
+
    memset(dataBuffer, 0x00, dataByteSizeMax);
 }

-void IR_DecoderRaw::listenStart() {
-    if (isRecive && ((micros() - prevRise) > IR_timeout * 2)) {
+void IR_DecoderRaw::listenStart()
+{
+    if (isRecive && ((micros() - prevRise) > IR_timeout * 2))
+    {
        // Serial.print("\nlis>");
        isRecive = false;
        firstRX();
    }
 }
-
-void IR_DecoderRaw::tick() {
+void IR_DecoderRaw::tick()
+{
    FrontStorage currentFront;
    noInterrupts();
    listenStart();
-    if (firstUnHandledFront == nullptr) { interrupts(); return; } //Если данных нет - ничего не делаем
-    currentFront = *((FrontStorage*)firstUnHandledFront); //найти следующий необработанный фронт/спад
+    FrontStorage *currentFrontPtr;
+    currentFrontPtr = subBuffer.pop();
+    if (currentFrontPtr == nullptr)
+    {
+        isSubBufferOverflow = false;
        interrupts();
-    if (currentFront.next == nullptr) { isRecive = false; return; }
+        return;
+    } // Если данных нет - ничего не делаем
+    currentFront = *currentFrontPtr;
+    interrupts();
+
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////

-    if (currentFront.time > prevRise && currentFront.time - prevRise > IR_timeout * 2 && !isRecive) {  // первый 
+    if (currentFront.dir)
+    { // Если __/``` ↑
+        if (currentFront.time - prevRise > riseTimeMax / 4 || highCount || lowCount)
+        { // комплексный фикс рваной единицы
+            risePeriod = currentFront.time - prevRise;
+            highTime = currentFront.time - prevFall;
+            lowTime = prevFall - prevRise;
+            prevRise = currentFront.time;
+
+            if (
+                risePeriod > UINT32_MAX - IR_timeout * 10 ||
+                highTime > UINT32_MAX - IR_timeout * 10 ||
+                lowTime > UINT32_MAX - IR_timeout * 10 ||
+                prevRise > UINT32_MAX - IR_timeout * 10)
+            {
+#ifdef IRDEBUG
+                errPulse(down, 50);
+
+                // Serial.print("\n");
+
+                // Serial.print("risePeriod:    ");
+                // Serial.println(risePeriod);
+
+                // Serial.print("highTime:           ");
+                // Serial.println(highTime);
+
+                // Serial.print("lowTime:            ");
+                // Serial.println(lowTime);
+
+                // Serial.print("prevRise:                  ");
+                // Serial.println(prevRise);
+#endif
+            }
+        }
+        else
+        {
+            errors.other++;
+        }
+    }
+    else
+    { // Если ```\__ ↓
+
+        if (currentFront.time - prevFall > riseTimeMin / 4)
+        {
+            prevFall = currentFront.time;
+        }
+        else
+        {
+            errors.other++;
+        }
+    }
+#ifdef IRDEBUG
+    // goto END; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#endif
+    //----------------------------------------------------------------------------------
+#ifdef IRDEBUG
+    digitalWrite(errOut, currentFront.dir);
+#endif
+
+    if (currentFront.time > prevRise && currentFront.time - prevRise > IR_timeout * 2 && !isRecive)
+    { // первый
+#ifdef IRDEBUG
+        errPulse(up, 50);
+        errPulse(down, 50);
+        errPulse(up, 150);
+        errPulse(down, 150);
+#endif
        preambFrontCounter = preambFronts - 1U;
+        isPreamb = true;

-
-        if (!currentFront.dir) {
-            #ifdef IRDEBUG_INFO
-            // Serial.print(" currentFront.time: "); Serial.print(currentFront.time);
-            // Serial.print(" currentFront.dir: "); Serial.print(currentFront.dir ? "UP" : "DOWN");
-            // Serial.print(" next: "); Serial.print(currentFront.next == nullptr);
-            // Serial.print("   prevRise: "); Serial.print(prevRise);
-            // Serial.print("   SUB: "); Serial.println(currentFront.time - prevRise);
-            #endif
        isRecive = true;
        isWrongPack = false;
    }
-    }

-    if (preambFrontCounter > 0) {     // в преамбуле
-        risePeriod = currentFront.time - prevRise;
-        if (currentFront.dir && risePeriod < IR_timeout) { //  __/``` ↑ и мы в внутри пакета
+    //-------------------------------------------------------------------------------------------------------

-            if (risePeriod < riseTimeMin << 1) { // fix рваной единицы
+    if (preambFrontCounter)
+    { // в преамбуле
+#ifdef IRDEBUG
+        Serial.print("risePeriod:           ");
+        Serial.println(risePeriod);
+#endif
+        if (currentFront.dir && risePeriod < IR_timeout)
+        { //  __/``` ↑ и мы в внутри пакета
+
+            if (risePeriod < riseTimeMin / 2)
+            { // fix рваной единицы
                preambFrontCounter += 2;
                errors.other++;
-            } else {
-                if (freeFrec) { riseSyncTime = (riseSyncTime + risePeriod / 2) / 2; } // tuner
+#ifdef IRDEBUG
+                errPulse(down, 350);
+#endif
            }
-        } else { /* riseSyncTime = bitTime; */ } // сброс тюнера
+            else
+            {
+                if (freeFrec)
+                {
+                    riseSyncTime = (riseSyncTime + risePeriod / 2) / 2;
+                } // tuner
+            }
+        }
+        else
+        { /* riseSyncTime = bitTime; */
+        } // сброс тюнера
        preambFrontCounter--;
        // Serial.print("preambFrontCounter: "); Serial.println(preambFrontCounter);
-    } else {
-        if (isPreamb) {// первый фронт после
+    }
+    else
+    {
+        if (isPreamb)
+        { // первый фронт после
          // gotTune.set(riseSyncTime);
-        }
            isPreamb = false;
+#ifdef IRDEBUG
+            errPulse(up, 50);
+            errPulse(down, 50);
+#endif
+            prevRise += risePeriod / 2;
+            // prevRise = currentFront.time + riseTime;
+            goto END;
        }
+    }
+
+    if (isPreamb)
+    {
+        goto END;
+    }
+    if (risePeriod > IR_timeout || isBufferOverflow || risePeriod < riseTimeMin || isWrongPack)
+    // ~Мы в пределах таймаута и буффер не переполнен и fix дроблёных единиц
+    {
+        goto END;
+    }
+
    // определить направление фронта
-    if (currentFront.dir) {                  // Если __/``` ↑
-
-        uint16_t risePeriod = currentFront.time - prevRise;
-        uint16_t highTime = currentFront.time - prevFall;
-        uint16_t lowTime = prevFall - prevRise;
-
-        int8_t highCount = 0;
-        int8_t lowCount = 0;
-        int8_t allCount = 0;
+    if (currentFront.dir)
+    { // Если __/``` ↑
+        highCount = 0;
+        lowCount = 0;
+        allCount = 0;
        bool invertErr = false;
+#ifdef IRDEBUG
+        Serial.print("\n");

-        if (!isPreamb) {
-            if (risePeriod < IR_timeout && !isBufferOverflow && risePeriod > riseTimeMin && !isWrongPack) {
-                // Мы в пределах таймаута и буффер не переполнен и fix дроблёных единиц
+        Serial.print("wrCounter:    ");
+        Serial.println(wrCounter++);

-                if (aroundRise(risePeriod)) { // тактирование есть, сигнал хороший - без ошибок(?)
+        Serial.print("risePeriod:           ");
+        Serial.println(risePeriod);

-                    if (highTime > riseTimeMin >> 1) {           // 1
-                        #ifdef IRDEBUG
-                        digitalWrite(wrHigh, 1);
-                        #endif
+        Serial.print("highTime:        ");
+        Serial.println(highTime);
+
+        Serial.print("lowTime:         ");
+        Serial.println(lowTime);
+#endif
+
+        if (aroundRise(risePeriod))
+        { // тактирование есть, сигнал хороший - без ошибок(?)
+
+            if (highTime > lowTime)
+            { // 1
+#ifdef IRDEBUG
+                errPulse(wrHigh, 1);
+#endif
                writeToBuffer(HIGH);
-                    } else {                            // 0
-                        #ifdef IRDEBUG
-                        digitalWrite(wrLow, 1);
-                        #endif
+            }
+            else
+            { // 0
+#ifdef IRDEBUG
+                errPulse(wrLow, 1);
+#endif
                writeToBuffer(LOW);
            }
-
-                } else { // пропущены такты! сигнал средний // ошибка пропуска
+        }
+        else
+        {                                              // пропущены такты! сигнал средний // ошибка пропуска
            highCount = ceil_div(highTime, riseTime);  // предполагаемое колличество HIGH битов
            lowCount = ceil_div(lowTime, riseTime);    // предполагаемое колличество LOW битов
            allCount = ceil_div(risePeriod, riseTime); // предполагаемое колличество всего битов

-                    if (highCount == 0 && highTime > riseTime / 3) { // fix короткой единицы (?)после пропуска нулей(?)
+            if (highCount == 0 && highTime > riseTime / 3)
+            { // fix короткой единицы (?)после пропуска нулей(?)
                highCount++;
                errors.other++;
-                        #ifdef IRDEBUG
-                        errPulse(errOut, 2);
-                        #endif
+#ifdef IRDEBUG
+                errPulse(up, 50);
+#endif
            }

-                    if (lowCount + highCount > allCount) {  // fix ошибочных сдвигов
-                        if (lowCount > highCount) {         // Лишние нули
+            if (lowCount + highCount > allCount)
+            { // fix ошибочных сдвигов
+                if (lowCount > highCount)
+                { // Лишние нули
                    lowCount = allCount - highCount;
                    errors.lowSignal += lowCount;
-                            #ifdef IRDEBUG
-                            errPulse(errOut, 3);
-                            #endif
-                        } else if (lowCount < highCount) {  // Лишние единицы
+#ifdef IRDEBUG
+                    // errPulse(errOut, 3);
+                    errPulse(down, 40);
+                    errPulse(up, 10);
+                    errPulse(down, 40);
+#endif
+                }
+                else if (lowCount < highCount)
+                { // Лишние единицы
                    highCount = allCount - lowCount;
                    errors.highSignal += highCount;
-                            #ifdef IRDEBUG
-                            errPulse(errOut, 4);
-                            #endif
+#ifdef IRDEBUG
+                    errPulse(down, 10);
+                    errPulse(up, 40);
+                    errPulse(down, 10);
+// errPulse(errOut, 4);
+#endif
                    // неизвестный случай Инверсит след бит или соседние
                    // Очень редко
                    // TODO: Отловить проверить
-                        } else if (lowCount == highCount) {
+                }
+                else if (lowCount == highCount)
+                {
+#ifdef IRDEBUG
+                    errPulse(down, 40);
+                    errPulse(up, 40);
+                    errPulse(down, 40);
+#endif
                    invertErr = true;
                    // Serial.print("...");
                    errors.other += allCount;
                }
                // errorCounter += allCount;
-
            }

            // errorCounter += allCount;
            // errors.other+=allCount;
-                    if (lowCount < highCount) {
+            if (lowCount < highCount)
+            {
                errors.highSignal += highCount;
-                    } else {
+            }
+            else
+            {
                errors.lowSignal += lowCount;
            }

-                    #ifdef IRDEBUG
-                    errPulse(errOut, 1);
-                    #endif
+            // errPulse(errOut, 1);

-                    for (int8_t i = 0; i < lowCount && 8 - i; i++) { // отправка LOW битов, если есть 
-                        if (i == lowCount - 1 && invertErr) {
+            for (int8_t i = 0; i < lowCount && 8 - i; i++)
+            { // отправка LOW битов, если есть
+                if (i == lowCount - 1 && invertErr)
+                {
                    invertErr = false;
-                            writeToBuffer(!LOW);
-                            #ifdef IRDEBUG
-                            digitalWrite(wrLow, 1);
-                            #endif
-                        } else {
-                            writeToBuffer(LOW);
-                            #ifdef IRDEBUG
-                            digitalWrite(wrLow, 1);
-                            #endif
-                        }
-                    }
-
-                    for (int8_t i = 0; i < highCount && 8 - i; i++) { // отправка HIGH битов, если есть 
-                        if (i == highCount - 1 && invertErr) {
-                            invertErr = false;
-                            writeToBuffer(!HIGH);
-                            #ifdef IRDEBUG
-                            digitalWrite(wrLow, 1);
-                            #endif
-                        } else {
                    writeToBuffer(HIGH);
-                            #ifdef IRDEBUG
-                            digitalWrite(wrHigh, 1);
-                            #endif
+#ifdef IRDEBUG
+                    errPulse(wrHigh, 1);
+#endif
                }
-                    }
-                }
-                #ifdef IRDEBUG
-                digitalWrite(wrHigh, 0);
-                digitalWrite(wrLow, 0);
-                #endif
-            }
-        }
-        if (risePeriod > riseTimeMax / 2 || highCount || lowCount) { // комплексный фикс рваной единицы
-            prevPrevRise = prevRise;
-            prevRise = currentFront.time;
-        } else {
-            errors.other++;
-            #ifdef IRDEBUG
-            errPulse(errOut, 5);
-            #endif
-        }
-
-    } else {                                // Если ```\__ ↓
-
-        if (currentFront.time - prevFall > riseTimeMin) {
-            prevPrevFall = prevFall;
-            prevFall = currentFront.time;
-        } else {
-            #ifdef IRDEBUG
-            //errPulse(errOut, 5);
-            #endif 
+                else
+                {
+                    writeToBuffer(LOW);
+#ifdef IRDEBUG
+                    errPulse(wrLow, 1);
+#endif
                }
            }

-    if (isPreamb && preambFrontCounter <= 0) {
-        prevRise = currentFront.time + riseTime;
+            for (int8_t i = 0; i < highCount && 8 - i; i++)
+            { // отправка HIGH битов, если есть
+                if (i == highCount - 1 && invertErr)
+                {
+                    invertErr = false;
+                    writeToBuffer(LOW);
+#ifdef IRDEBUG
+                    errPulse(wrLow, 1);
+#endif
+                }
+                else
+                {
+                    writeToBuffer(HIGH);
+#ifdef IRDEBUG
+                    errPulse(wrHigh, 1);
+#endif
+                }
+            }
+        }
+    }
+    else
+    { // Если ```\__ ↓
    }

-    #ifdef IRDEBUG
-    digitalWrite(writeOp, isPreamb);
-    #endif
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    firstUnHandledFront = firstUnHandledFront->next;  //переместить флаг на следующий элемент для обработки (next or nullptr)
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+END:;
 }

-void IR_DecoderRaw::writeToBuffer(bool bit) {
-    if (i_dataBuffer > dataByteSizeMax * 8) {// проверка переполнения
-        //TODO: Буффер переполнен!
-        #ifdef IRDEBUG_INFO
+void IR_DecoderRaw::writeToBuffer(bool bit)
+{
+    if (i_dataBuffer > dataByteSizeMax * 8)
+    { // проверка переполнения
+// TODO: Буффер переполнен!
+#ifdef IRDEBUG_INFO
        Serial.println("OverBuf");
-        #endif
+#endif
        isBufferOverflow = true;
    }
-    if (isBufferOverflow || isPreamb || isWrongPack) {
+    if (isBufferOverflow || isPreamb || isWrongPack)
+    {
        isRecive = false;
        return;
    }

    // Переключение флага, data или syncBit
-    if (bufBitPos == nextControlBit) {
+    if (bufBitPos == nextControlBit)
+    {
        nextControlBit += (isData ? syncBits : bitPerByte); // маркер следующего переключения
        isData = !isData;
        i_syncBit = 0;   // сброс счетчика битов синхронизации
        err_syncBit = 0; // сброс счетчика ошибок синхронизации
-        #ifdef IRDEBUG_INFO
+#ifdef IRDEBUG_INFO
        Serial.print(" ");
-        #endif
+#endif
    }

-    if (isData) { // Запись битов в dataBuffer
-        #ifdef IRDEBUG_INFO
+    if (isData)
+    { // Запись битов в dataBuffer
+#ifdef IRDEBUG_INFO
        Serial.print(bit);
-        #endif
+#endif

        // if (i_dataBuffer % 8 == 7) {
        //     // Serial.print("+");
@ -306,15 +441,21 @@ void IR_DecoderRaw::writeToBuffer(bool bit) {
        dataBuffer[(i_dataBuffer / 8)] |= bit << (7 - i_dataBuffer % 8); // Запись в буффер
        i_dataBuffer++;
        bufBitPos++;
-    } else {
+    }
+    else
+    {
        //********************************* Проверка контрольных sync битов*******************************//
        ////////////////////// Исправление лишнего нуля ///////////////////////
-        if (i_syncBit == 0) {    // Первый бит синхронизации
+        if (i_syncBit == 0)
+        { // Первый бит синхронизации
            // Serial.print("~");
-            if (bit != (dataBuffer[((i_dataBuffer - 1) / 8)] >> (7 - (i_dataBuffer - 1) % 8) & 1)) {
+            if (bit != (dataBuffer[((i_dataBuffer - 1) / 8)] >> (7 - (i_dataBuffer - 1) % 8) & 1))
+            {
                bufBitPos++;
                i_syncBit++;
-            } else {
+            }
+            else
+            {
                i_syncBit = 0;
                errors.other++;
                // Serial.print("E");
@ -322,50 +463,71 @@ void IR_DecoderRaw::writeToBuffer(bool bit) {
                // Serial.print("bit: "); Serial.println(bit);
                // Serial.print("dataBuffer: "); Serial.println(dataBuffer[((i_dataBuffer - 1) / 8)] & 1 << (7 - ((i_dataBuffer - 1) & ~(~0 << 3))));
            }
-        } else {                // Последующие биты синхронизации
+        }
+        else
+        { // Последующие биты синхронизации
            // Serial.print("`");
            bufBitPos++;
            i_syncBit++;
        }
        ////////////////////// Проверка наличия битов синхранизации //////////////////////
-        if (isWrongPack = (err_syncBit >= syncBits)) {
-            #ifdef IRDEBUG_INFO
+        if (isWrongPack = (err_syncBit >= syncBits))
+        {
+#ifdef IRDEBUG_INFO
            Serial.print("****************");
-            #endif
-
+#endif
        };

-    }//**************************************************************************************************//
+    } //**************************************************************************************************//

-    // Serial.print(bit);
-    #ifdef IRDEBUG
+// Serial.print(bit);
+#ifdef IRDEBUG
    bit ? infoPulse(writeOp, 2) : infoPulse(writeOp, 1);
-    #endif
-
+#endif

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

-    #ifdef IRDEBUG_INFO
-    if (isData) {
-        if (i_dataBuffer == ((msgBytes)*bitPerByte)) { Serial.print(" -> "); Serial.print(dataBuffer[0] & IR_MASK_MSG_INFO); Serial.print(" ->"); }
-        if (i_dataBuffer == ((msgBytes + addrBytes) * bitPerByte)) { Serial.print("  |"); }
-        if (i_dataBuffer == ((msgBytes + addrBytes + addrBytes) * bitPerByte)) { Serial.print("  ->"); }
-        if (i_dataBuffer == (((dataBuffer[0] & IR_MASK_MSG_INFO) - 2) * bitPerByte)) { Serial.print("  <-"); }
+#ifdef IRDEBUG_INFO
+    if (isData)
+    {
+        if (i_dataBuffer == ((msgBytes)*bitPerByte))
+        {
+            Serial.print(" -> ");
+            Serial.print(dataBuffer[0] & IR_MASK_MSG_INFO);
+            Serial.print(" ->");
        }
-    #endif
+        if (i_dataBuffer == ((msgBytes + addrBytes) * bitPerByte))
+        {
+            Serial.print("  |");
+        }
+        if (i_dataBuffer == ((msgBytes + addrBytes + addrBytes) * bitPerByte))
+        {
+            Serial.print("  ->");
+        }
+        if (i_dataBuffer == (((dataBuffer[0] & IR_MASK_MSG_INFO) - 2) * bitPerByte))
+        {
+            Serial.print("  <-");
+        }
+    }
+#endif

-    if (!isAvailable && isData && !isWrongPack) {
-        if (i_dataBuffer == 8 * msgBytes) {// Ппервый байт
+    if (!isAvailable && isData && !isWrongPack)
+    {
+        if (i_dataBuffer == 8 * msgBytes)
+        { // Ппервый байт
            packSize = dataBuffer[0] & IR_MASK_MSG_INFO;
-            #ifdef IRDEBUG_INFO
-            Serial.print(" ["); Serial.print(packSize); Serial.print("] ");
-            #endif
+#ifdef IRDEBUG_INFO
+            Serial.print(" [");
+            Serial.print(packSize);
+            Serial.print("] ");
+#endif
        }

-        if (packSize && (i_dataBuffer == packSize * bitPerByte)) { // Конец
-            #ifdef IRDEBUG_INFO
-            Serial.print("   END DATA   ");
-            #endif
+        if (packSize && (i_dataBuffer == packSize * bitPerByte))
+        { // Конец
+#ifdef IRDEBUG_INFO
+            Serial.print("   END DATA   " + crcCheck(packSize - crcBytes, crcValue) ? "OK   " : "ERR  ");
+#endif

            packInfo.buffer = dataBuffer;
            packInfo.crc = crcValue;
@ -375,13 +537,42 @@ void IR_DecoderRaw::writeToBuffer(bool bit) {

            isRecive = false;
            isAvailable = crcCheck(packSize - crcBytes, crcValue);
+
+#ifdef BRUTEFORCE_CHECK
+                if (!isAvailable) // Исправление первого бита // Очень большая затычка...
+                    for (size_t i = 0; i < min(uint16_t(packSize - crcBytes*2U), uint16_t(dataByteSizeMax)); ++i)
+                    {
+                        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;
+                            }
+                        }
+                    }
+            OUT_BRUTEFORCE:;
+#endif
        }
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 }

-bool IR_DecoderRaw::crcCheck(uint8_t len, crc_t& crc) {
+bool IR_DecoderRaw::crcCheck(uint8_t len, crc_t &crc)
+{
    bool crcOK = false;

    crc = 0;
@ -391,42 +582,44 @@ bool IR_DecoderRaw::crcCheck(uint8_t len, crc_t& crc) {
    if (
        crc &&
        dataBuffer[len] == (crc >> 8) & 0xFF &&
-        dataBuffer[len + 1] == (crc & 0xFF)
-        ) {
+        dataBuffer[len + 1] == (crc & 0xFF))
+    {
        crcOK = true;
-    } else {
+    }
+    else
+    {
        crcOK = false;
    }

-
    return crcOK;
 }

-uint16_t IR_DecoderRaw::ceil_div(uint16_t val, uint16_t divider) {
+uint16_t IR_DecoderRaw::ceil_div(uint16_t val, uint16_t divider)
+{
    int ret = val / divider;
    if ((val << 4) / divider - (ret << 4) >= 8)
        ret++;
    return ret;
 }

-
-
 // IRDEBUG FUNC
 #ifdef IRDEBUG
-inline void IR_DecoderRaw::errPulse(uint8_t pin, uint8_t count) {
-    for (size_t i = 0; i < count; i++) {
+inline void IR_DecoderRaw::errPulse(uint8_t pin, uint8_t count)
+{
+    for (size_t i = 0; i < count; i++)
+    {
        digitalWrite(pin, 1);
        digitalWrite(pin, 0);
    }
    digitalWrite(pin, 0);
 }

-inline void IR_DecoderRaw::infoPulse(uint8_t pin, uint8_t count) {
-    for (size_t i = 0; i < count; i++) {
+inline void IR_DecoderRaw::infoPulse(uint8_t pin, uint8_t count)
+{
+    for (size_t i = 0; i < count; i++)
+    {
        digitalWrite(pin, 1);
        digitalWrite(pin, 0);
    }
 }
 #endif
-
-
--- a/IR_DecoderRaw.h
+++ b/IR_DecoderRaw.h
@ -1,16 +1,21 @@
 #pragma once
 #include "IR_config.h"
+#include "RingBuffer.h"

-//#define IRDEBUG
+// #define IRDEBUG

 #ifdef IRDEBUG
-#define wrHigh A3    // Запись HIGH инициирована                     // green
-#define wrLow A3    // Запись LOW инициирована                      // blue
-#define writeOp 13  // Операция записи, 1 пульс для 0 и 2 для 1     // orange
+#define wrHigh PA1  // Запись HIGH инициирована                     // green
+#define wrLow PA0   // Запись LOW инициирована                      // blue
+#define writeOp PA5 // Операция записи, 1 пульс для 0 и 2 для 1     // orange
 // Исправленные ошибки                                              // purle
 // 1 пульс: fix
-#define errOut A3          
+#define errOut PA4
+#define up PA3
+#define down PA2
 #endif
+#define up PA3
+#define down PA2

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

@ -19,12 +24,29 @@
 #define riseTimeMax (riseTime + riseTolerance)
 #define riseTimeMin (riseTime - riseTolerance)
 #define aroundRise(t) (riseTimeMin < t && t < riseTimeMax)
-#define IR_timeout (riseTimeMax * (8 + syncBits +1))    // us // таймаут в 8 data + 3 sync + 1
-
+#define IR_timeout (riseTimeMax * (8 + syncBits + 1)) // us // таймаут в 8 data + 3 sync + 1

 class IR_Encoder;
-class IR_DecoderRaw : virtual public IR_FOX {
+class IR_DecoderRaw : virtual public IR_FOX
+{
    friend IR_Encoder;
+
+protected:
+    PackInfo packInfo;
+    IR_Encoder *encoder; // Указатель на парный передатчик
+    bool availableRaw()
+    {
+        if (isAvailable)
+        {
+            isAvailable = false;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    };
+
 public:
    const uint8_t isrPin; // Пин прерывания

@ -33,19 +55,24 @@ public:
    /// @param isrPin Номер вывода прерывания/данных от приёмника (2 или 3 для atmega 328p)
    /// @param addr Адрес приёмника
    /// @param encPair Указатель на передатчик, работающий в паре
-    IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder* encPair = nullptr);
+    IR_DecoderRaw(const uint8_t isrPin, uint16_t addr, IR_Encoder *encPair = nullptr);

    void isr();  // Функция прерывания
    void tick(); // Обработка приёмника, необходима для работы
-    bool available() { if (isAvailable) { isAvailable = false; return true; } else { return false; } };
+    void tickOld();
+
    bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился
+    bool isSubOverflow()
+    {
+
+        // noInterrupts();
+        volatile bool ret = isSubBufferOverflow;
+        // interrupts();
+        return ret;
+    };
    bool isReciving() { return isBufferOverflow; }; // Возвращает true, если происходит приём пакета

    //////////////////////////////////////////////////////////////////////////
-protected:
-    PackInfo packInfo;
-    uint16_t id;
-    IR_Encoder* encoder;                    // Указатель на парный передатчик
 private:
    ErrorsStruct errors;
    bool isAvailable = false;
@ -54,26 +81,42 @@ private:
    volatile uint16_t isPairSending = 0; // Флаг передачи парного передатчика
    volatile bool isRecive = false;      // Флаг приёма
    volatile bool isPreamb = false;      // флаг начальной последовости
+    volatile bool isSubBufferOverflow = false;
    bool isBufferOverflow = false; // Флаг переполнения буффера данных
    bool isWrongPack = false;      // Флаг битого пакета

    uint16_t riseSyncTime = bitTime; // Подстраиваемое время бита в мкс

    ////////////////////////////////////////////////////////////////////////
-    volatile uint8_t currentSubBufferIndex;     // Счетчик текущей позиции во вспомогательном буфере фронтов/спадов
+    volatile uint32_t currentSubBufferIndex; // Счетчик текущей позиции во вспомогательном буфере фронтов/спадов

-    struct FrontStorage {                       // Структура для хранения времени и направления фронта/спада
+    struct FrontStorage
+    {                               // Структура для хранения времени и направления фронта/спада
        volatile uint32_t time = 0; // Время
        volatile bool dir = false;  // Направление (true = ↑; false = ↓)
-        volatile FrontStorage* next = nullptr;            // Указатель на следующий связанный фронт/спад, или nullptr если конец
+        // volatile FrontStorage *next = nullptr; // Указатель на следующий связанный фронт/спад, или nullptr если конец
    };
-    volatile FrontStorage* lastFront = nullptr;             // Указатель последнего фронта/спада
-    volatile FrontStorage* firstUnHandledFront = nullptr;   // Указатель первого необработанного фронта/спада
-    volatile FrontStorage subBuffer[subBufferSize];         // вспомогательный буфер для хранения необработанных фронтов/спадов
+    volatile FrontStorage *lastFront = nullptr;           // Указатель последнего фронта/спада
+    volatile FrontStorage *firstUnHandledFront = nullptr; // Указатель первого необработанного фронта/спада
+    // volatile FrontStorage subBuffer[subBufferSize];       // вспомогательный буфер для хранения необработанных фронтов/спадов
+
+    RingBuffer<FrontStorage, subBufferSize> subBuffer;
+
    ////////////////////////////////////////////////////////////////////////
-    uint8_t dataBuffer[dataByteSizeMax] { 0 };                             // Буффер данных
-    uint32_t prevRise, prevPrevRise, prevFall, prevPrevFall;            // Время предыдущих фронтов/спадов
-    uint32_t risePeriod;
+    uint8_t dataBuffer[dataByteSizeMax]{0};                           // Буффер данных
+    volatile uint32_t prevRise, prevPrevRise, prevFall, prevPrevFall; // Время предыдущих фронтов/спадов
+
+    volatile uint32_t risePeriod;
+    volatile uint32_t highTime;
+    volatile uint32_t lowTime;
+
+    uint32_t oldTime;
+    uint16_t wrongCounter;
+
+    int8_t highCount;
+    int8_t lowCount;
+    int8_t allCount;
+
    uint16_t errorCounter = 0;     // Счётчик ошибок
    int8_t preambFrontCounter = 0; // Счётчик __/``` ↑ преамбулы
    int16_t bufBitPos = 0;         // Позиция для записи бита в буффер
@ -85,7 +128,7 @@ private:
    /// @param len Длина в байтах проверяемых данных
    /// @param crc Результат рассчёта crc (Выходной параметр)
    /// @return true если crc верно
-    bool crcCheck(uint8_t len, uint16_t& crc);
+    bool crcCheck(uint8_t len, uint16_t &crc);

    ////////////////////////////////////////////////////////////////////////
    bool isData = true;                  // Флаг относится ли бит к данным, или битам синхронизации
@ -99,7 +142,6 @@ private:
    void writeToBuffer(bool);
    ////////////////////////////////////////////////////////////////////////

-
    void firstRX(); /// @brief Установка и сброс начальных значений и флагов в готовность к приёму данных

    /// @brief Целочисленное деление с округлением вверх
@ -108,10 +150,8 @@ private:
    /// @return Результат
    uint16_t ceil_div(uint16_t val, uint16_t divider);

-    #ifdef IRDEBUG
+#if true //def IRDEBUG
    inline void errPulse(uint8_t pin, uint8_t count);
    inline void infoPulse(uint8_t pin, uint8_t count);
-    #endif
-
-
+#endif
 };
--- a/IR_Encoder.cpp
+++ b/IR_Encoder.cpp
@ -5,36 +5,55 @@
 #define ISR_Out 10
 #define TestOut 13

-IR_Encoder::IR_Encoder(uint16_t addr, uint8_t pin, IR_DecoderRaw* decPair = nullptr) {
+IR_Encoder::IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair)
+{
    id = addr;
    this->decPair = decPair;
    signal = noSignal;
    isSending = false;
-    #if disablePairDec
-    if (decPair != nullptr) {
-        blindDecoders = new IR_DecoderRaw * [1] {decPair};
+#if disablePairDec
+    if (decPair != nullptr)
+    {
+        blindDecoders = new IR_DecoderRaw *[1]
+        { decPair };
        decodersCount = 1;
    }
-    #endif
-    if (decPair != nullptr) {
+#endif
+    if (decPair != nullptr)
+    {
        decPair->encoder = this;
    }
 };
-void IR_Encoder::setBlindDecoders(IR_DecoderRaw* decoders [], uint8_t count) {
-    #if disablePairDec
-    if (blindDecoders != nullptr) delete [] blindDecoders;
-    #endif
+void IR_Encoder::setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count)
+{
+#if disablePairDec
+    if (blindDecoders != nullptr)
+        delete[] blindDecoders;
+#endif
    decodersCount = count;
    blindDecoders = decoders;
 }

-IR_Encoder::~IR_Encoder() {
-    delete [] bitLow;
-    delete [] bitHigh;
+IR_Encoder::~IR_Encoder()
+{
+    delete[] bitLow;
+    delete[] bitHigh;
 };

-void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data, uint8_t len, bool needAccept = false) {
-    if (len > bytePerPack) { return; }
+void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept)
+{
+    uint8_t *dataPtr = new uint8_t[1];
+    dataPtr[0] = dataByte;
+    sendData(addrTo, dataPtr, 1, needAccept);
+    delete[] dataPtr;
+}
+
+void IR_Encoder::sendData(uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept)
+{
+    if (len > bytePerPack)
+    {
+        return;
+    }
    constexpr uint8_t dataStart = msgBytes + addrBytes + addrBytes;
    memset(sendBuffer, 0x00, dataByteSizeMax);
    uint8_t packSize = msgBytes + addrBytes + addrBytes + len + crcBytes;
@ -53,8 +72,9 @@ void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data, uint8_t len, bool need
    sendBuffer[3] = addrTo >> 8 & 0xFF;
    sendBuffer[4] = addrTo & 0xFF;

-    for (uint16_t i = dataStart; i < dataStart + len; i++) {
-        sendBuffer[i] = ((uint8_t*)data)[i - dataStart];
+    for (uint16_t i = dataStart; (i < dataStart + len) && (data != nullptr); i++)
+    {
+        sendBuffer[i] = ((uint8_t *)data)[i - dataStart];
    }

    // data crc
@ -72,7 +92,8 @@ void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data, uint8_t len, bool need
    rawSend(sendBuffer, packSize);
 }

-void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte = 0) {
+void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte)
+{
    constexpr uint8_t packsize = msgBytes + addrBytes + 1U + crcBytes;
    memset(sendBuffer, 0x00, dataByteSizeMax);
    sendBuffer[0] = IR_MSG_ACCEPT << 5;
@ -94,7 +115,8 @@ void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte = 0) {
    rawSend(sendBuffer, packsize);
 }

-void IR_Encoder::sendRequest(uint16_t addrTo) {
+void IR_Encoder::sendRequest(uint16_t addrTo)
+{
    constexpr uint8_t packsize = msgBytes + addrBytes + addrBytes + crcBytes;
    memset(sendBuffer, 0x00, dataByteSizeMax);
    sendBuffer[0] = IR_MSG_REQUEST << 5;
@ -104,7 +126,7 @@ void IR_Encoder::sendRequest(uint16_t addrTo) {
    sendBuffer[1] = id >> 8 & 0xFF;
    sendBuffer[2] = id & 0xFF;

-    //addr_to
+    // addr_to
    sendBuffer[3] = addrTo >> 8 & 0xFF;
    sendBuffer[4] = addrTo & 0xFF;

@ -115,20 +137,30 @@ void IR_Encoder::sendRequest(uint16_t addrTo) {
    rawSend(sendBuffer, packsize);
 }

-void IR_Encoder::sendBack(uint8_t* data = nullptr, uint8_t len = 0) {
+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);
 }

-void IR_Encoder::sendBackTo(uint16_t addrTo, uint8_t* data = nullptr, uint8_t len = 0) {
+void IR_Encoder::sendBackTo(uint16_t addrTo, uint8_t *data, uint8_t len)
+{
    _sendBack(true, addrTo, data, len);
 }

-void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t* data, uint8_t len) {
-    if (len > bytePerPack) { return; }
+void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len)
+{
+    if (len > bytePerPack)
+    {
+        return;
+    }
    memset(sendBuffer, 0x00, dataByteSizeMax);
    uint8_t dataStart = msgBytes + addrBytes + (isAdressed ? addrBytes : 0);

-    uint8_t packSize = msgBytes + addrBytes + (isAdressed ? addrBytes : 0) + min(1, len) + crcBytes;
+    uint8_t packSize = msgBytes + addrBytes + (isAdressed ? addrBytes : 0) + min(uint8_t(1), len) + crcBytes;
    uint8_t msgType =
        ((isAdressed ? IR_MSG_BACK_TO : IR_MSG_BACK) << 5) | ((packSize) & (IR_MASK_MSG_INFO >> 1));

@ -144,8 +176,9 @@ void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t* data, uint
    sendBuffer[3] = addrTo >> 8 & 0xFF;
    sendBuffer[4] = addrTo & 0xFF;

-    for (uint16_t i = dataStart; i < dataStart + len; i++) {
-        sendBuffer[i] = ((uint8_t*)data)[i - dataStart];
+    for (uint16_t i = dataStart; i < dataStart + len; i++)
+    {
+        sendBuffer[i] = ((uint8_t *)data)[i - dataStart];
    }

    // data crc
@ -156,24 +189,28 @@ void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t* data, uint
    rawSend(sendBuffer, packSize);
 }

-void IR_Encoder::setDecoder_isSending() {
-    if (decodersCount) {
-        for (uint8_t i = 0; i < decodersCount; i++) {
+void IR_Encoder::setDecoder_isSending()
+{
+    if (decodersCount)
+    {
+        for (uint8_t i = 0; i < decodersCount; i++)
+        {
            blindDecoders[i]->isPairSending ^= id;
        }
-
    }
 }

-void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
-    if (isSending) {
-        //TODO: Обработка повторной отправки
+void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
+{
+    if (isSending)
+    {
+        // TODO: Обработка повторной отправки
        return;
    }

    setDecoder_isSending();

-    cli();
+    // noInterrupts();
    sendLen = len;
    toggleCounter = preambToggle; // Первая генерация для первого signal

@ -190,21 +227,25 @@ void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {

    currentBitSequence = bitHigh;
    isSending = true;
-    sei();
+    // interrupts();
 }

-
-
-void IR_Encoder::isr() {
-    if (!isSending) return;
+void IR_Encoder::isr()
+{
+    if (!isSending)
+        return;

    ir_out_virtual = !ir_out_virtual && state;

-    if (toggleCounter) {
+    if (toggleCounter)
+    {
        toggleCounter--;
-    } else {
+    }
+    else
+    {
    IsrStart:
-        switch (signal) {
+        switch (signal)
+        {
        case noSignal:
            signal = preamb;
            // сброс счетчиков
@ -215,10 +256,13 @@ void IR_Encoder::isr() {
            break;

        case preamb:
-                if (preambFrontCounter) {
+            if (preambFrontCounter)
+            {
                preambFrontCounter--;
                toggleCounter = preambToggle; // Вторая и последующие генерации для этого signal
-                } else {// Конец преамбулы, переход на следующий signal
+            }
+            else
+            { // Конец преамбулы, переход на следующий signal
                signal = data;
                state = !LOW;  // Инверсное состояние первой генерации следующего signal
                goto IsrStart; // Применение новых параметров в этй же итерации прерывания
@ -227,14 +271,18 @@ void IR_Encoder::isr() {
            break;

        case data:
-                if (dataSequenceCounter) {
-                    if (!(dataSequenceCounter & 1U)) { // если чётный - смена бита
+            if (dataSequenceCounter)
+            {
+                if (!(dataSequenceCounter & 1U))
+                {                                                                                                   // если чётный - смена бита
                    currentBitSequence = ((sendBuffer[dataByteCounter] >> dataBitCounter) & 1U) ? bitHigh : bitLow; // определение текущего бита
                    dataBitCounter--;
                }
                toggleCounter = currentBitSequence[!state];
                dataSequenceCounter--;
-                } else {                            // Конец data, переход на следующий signal
+            }
+            else
+            { // Конец data, переход на следующий signal
                syncLastBit = ((sendBuffer[dataByteCounter]) & 1U);
                dataByteCounter++;
                dataBitCounter = bitPerByte - 1;
@ -245,22 +293,30 @@ void IR_Encoder::isr() {
            break;

        case sync:
-                if (syncSequenceCounter) {
-                    if (!(syncSequenceCounter & 1U)) { // если чётный - смена бита
-                        if (syncSequenceCounter == 2) { // Если последний бит
+            if (syncSequenceCounter)
+            {
+                if (!(syncSequenceCounter & 1U))
+                { // если чётный - смена бита
+                    if (syncSequenceCounter == 2)
+                    { // Если последний бит
                        currentBitSequence = ((sendBuffer[dataByteCounter]) & 0b10000000) ? bitLow : bitHigh;
-                        } else {
+                    }
+                    else
+                    {
                        currentBitSequence = syncLastBit ? bitLow : bitHigh; // определение текущего бита
                        syncLastBit = !syncLastBit;
                    }
                }
                toggleCounter = currentBitSequence[!state];
                syncSequenceCounter--;
-                } else {                            // Конец sync, переход на следующий signal
+            }
+            else
+            { // Конец sync, переход на следующий signal
                signal = data;
                syncSequenceCounter = syncBits * 2;

-                    if (dataByteCounter >= sendLen) { // определение конца данных
+                if (dataByteCounter >= sendLen)
+                { // определение конца данных
                    signal = noSignal;
                }
                goto IsrStart; // Применение новых параметров в этй же итерации прерывания
@ -276,57 +332,34 @@ void IR_Encoder::isr() {
    }
 }

-
-
-
-
-void old() {///////////////////////////////////////////////////////
-    // void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
-    //     /*tmp*/bool LOW_FIRST = false;/*tmp*/
-
-    //     if (decoders != nullptr) { decoders->isPairSending = true; }
-
-    //     bool prev = 1;
-    //     bool next;
-
-    //     send_EMPTY(preambPulse); // преамбула
-    //     for (uint16_t byteNum = 0; byteNum < len; byteNum++) {
-    //         sendByte(ptr[byteNum], &prev, LOW_FIRST);
-    //         if (byteNum < len - 1) {
-    //             next = ptr[byteNum + 1] & (LOW_FIRST ? 0b00000001 : 0b10000000);
-    //         } else {
-    //             next = 0;
-    //         }
-    //         addSync(&prev, &next);
-    //     }
-
-    //     if (decoders != nullptr) { decoders->isPairSending = false; }
-
-    // }
-}
-
-void IR_Encoder::sendByte(uint8_t byte, bool* prev, bool LOW_FIRST) {
+void IR_Encoder::sendByte(uint8_t byte, bool *prev, bool LOW_FIRST)
+{
    uint8_t mask = LOW_FIRST ? 0b00000001 : 0b10000000;
-    for (uint8_t bitShift = 8; bitShift; bitShift--) {
-        digitalWrite(9, HIGH);
-        digitalWrite(9, LOW);
-        byte& mask ? send_HIGH(prev) : send_LOW();
+    for (uint8_t bitShift = 8; bitShift; bitShift--)
+    {
+        // digitalWrite(9, HIGH);
+        // digitalWrite(9, LOW);
+        byte &mask ? send_HIGH(prev) : send_LOW();
        *prev = byte & mask;
        LOW_FIRST ? mask <<= 1 : mask >>= 1;
-        digitalWrite(9, HIGH);
-        digitalWrite(9, LOW);
+        // digitalWrite(9, HIGH);
+        // digitalWrite(9, LOW);
    }
 }

-void IR_Encoder::addSync(bool* prev, bool* next) {
-    switch (syncBits) {
-        case 0: break;
+void IR_Encoder::addSync(bool *prev, bool *next)
+{
+    switch (syncBits)
+    {
+    case 0:
+        break;
    case 1:
        *prev ? send_LOW() : send_HIGH();
        *prev = !*prev;
        break;
    default:
-            for (int16_t i = 0; i < syncBits - 1; i++) {
+        for (int16_t i = 0; i < syncBits - 1; i++)
+        {
            *prev ? send_LOW() : send_HIGH();
            *prev = !*prev;
        }
@ -336,7 +369,8 @@ void IR_Encoder::addSync(bool* prev, bool* next) {
    }
 }

-void IR_Encoder::send_HIGH(bool prevBite = 1) {
+void IR_Encoder::send_HIGH(bool prevBite)
+{

    // if (/* prevBite */1) {
    //     meanderBlock(bitPauseTakts * 2, halfPeriod, LOW);
@ -345,16 +379,17 @@ void IR_Encoder::send_HIGH(bool prevBite = 1) {
    //     meanderBlock(bitTakts - (bitActiveTakts - bitPauseTakts), halfPeriod, LOW);
    //     meanderBlock(bitActiveTakts - bitPauseTakts, halfPeriod, HIGH);
    // }
-
 }

-void IR_Encoder::send_LOW() {
+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) {
+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;
@ -362,4 +397,9 @@ void IR_Encoder::send_EMPTY(uint8_t count) {
    // meanderBlock(bitPauseTakts * 2 + bitActiveTakts, halfPeriod, 0); //TODO: Отодвинуть преамбулу
 }

-
+uint8_t* IR_Encoder::bitHigh = new uint8_t[2]{
+        (bitPauseTakts) * 2 - 1,
+        (bitActiveTakts) * 2 - 1};
+uint8_t* IR_Encoder::bitLow = new uint8_t[2]{
+        (bitPauseTakts/2 + bitActiveTakts) * 2 - 1,
+        (bitPauseTakts) - 1};
--- a/IR_Encoder.h
+++ b/IR_Encoder.h
@ -1,81 +1,93 @@
 #pragma once
 #include "IR_config.h"

-//TODO: Отложенная передача после завершения приема
+// TODO: Отложенная передача после завершения приема

 class IR_DecoderRaw;
-class IR_Encoder : IR_FOX {
+class IR_Encoder : IR_FOX
+{
    friend IR_DecoderRaw;
+
 public:
+private:
    uint16_t id; /// @brief Адрес передатчика

-private:
-
 public:
-
    /// @brief Класс передатчика
    /// @param addr Адрес передатчика
    /// @param pin  Вывод передатчика
    /// @param tune Подстройка несущей частоты
    /// @param decPair Приёмник, для которого отключается приём в момент передачи передатчиком
-    IR_Encoder(uint16_t addr, uint8_t pin, IR_DecoderRaw* decPair = nullptr);
+    IR_Encoder(uint16_t addr, IR_DecoderRaw *decPair = nullptr);

-    static void timerSetup() {
-        // TIMER2 Ini
-        uint8_t oldSREG = SREG;           		// Save global interupts settings
-        cli();
-        // DDRB |= (1 << PORTB3);  //OC2A (17)
-        TCCR2A = 0;
-        TCCR2B = 0;
+    // 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 << COM2A0);                 //Переключение состояния

-        TCCR2A |= (1 << WGM21);              // Clear Timer On Compare (Сброс по совпадению)
-        TCCR2B |= (1 << CS20);               // Предделитель 1
-        TIMSK2 |= (1 << OCIE2A);             // Прерывание по совпадению
-        #if F_CPU == 16000000
-        OCR2A = /* 465 */((F_CPU / (38000 * 2)) - 2); //38кГц
-        #elif F_CPU == 8000000
-        OCR2A = ((F_CPU / (38000 * 2)) - 2); //38кГц Частота_мк / (Предделитель * Частота * 2)
-        #endif
+    // //     TCCR2A |= (1 << WGM21);  // Clear Timer On Compare (Сброс по совпадению)
+    // //     TCCR2B |= (1 << CS20);   // Предделитель 1
+    // //     TIMSK2 |= (1 << OCIE2A); // Прерывание по совпадению

-        SREG = oldSREG;                             // Return interrupt settings
-    }
+    // //     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);
+
+    void sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = false);
+    void sendData(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false);

-    void IR_Encoder::setBlindDecoders(IR_DecoderRaw* decoders [], uint8_t count);
-    void rawSend(uint8_t* ptr, uint8_t len);
-    void sendData(uint16_t addrTo, uint8_t* data, uint8_t len, bool needAccept = false);
    void sendAccept(uint16_t addrTo, uint8_t customByte = 0);
    void sendRequest(uint16_t addrTo);
-    void sendBack(uint8_t* data = nullptr, uint8_t len = 0);
-    void sendBackTo(uint16_t addrTo, uint8_t* data = nullptr, uint8_t len = 0);
+
+    void sendBack(uint8_t data);
+    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:
-    void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t* data, uint8_t len);

-    void IR_Encoder::setDecoder_isSending();
-    void sendByte(uint8_t byte, bool* prev, bool LOW_FIRST);
-    void addSync(bool* prev, bool* next);
+private:
+    void _sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len);
+
+    void setDecoder_isSending();
+    void sendByte(uint8_t byte, bool *prev, bool LOW_FIRST);
+    void addSync(bool *prev, bool *next);
    void send_HIGH(bool = 1);
    void send_LOW();
    void send_EMPTY(uint8_t count);

-    enum SignalPart : uint8_t {
+    enum SignalPart : uint8_t
+    {
        noSignal = 0,
        preamb = 1,
        data = 2,
        sync = 3
    };

-    IR_DecoderRaw* decPair;
-    IR_DecoderRaw** blindDecoders;
+    IR_DecoderRaw *decPair;
+    IR_DecoderRaw **blindDecoders;
    uint8_t decodersCount;

    uint8_t sendLen;
-    uint8_t sendBuffer[dataByteSizeMax] { 0 }; /// @brief Буффер данных для отправки
+    uint8_t sendBuffer[dataByteSizeMax]{0}; /// @brief Буффер данных для отправки

    volatile bool isSending;
    volatile bool state; /// @brief Текущий уровень генерации
@ -90,23 +102,14 @@ private:
    volatile uint8_t syncSequenceCounter;
    volatile bool syncLastBit;

-    struct BitSequence {
+    struct BitSequence
+    {
        uint8_t low;
        uint8_t high;
    };
-    static inline uint8_t* bitHigh = new uint8_t[2] {
-        (bitPauseTakts * 2) * 2 - 1,
-        (bitActiveTakts) * 2 - 1
-    };
-    static inline uint8_t* bitLow = new uint8_t[2] {
-        (bitPauseTakts + bitActiveTakts) * 2 - 1,
-        (bitPauseTakts) * 2 - 1
-    };
-    uint8_t* currentBitSequence = bitLow;
+    static uint8_t *bitHigh;
+    static uint8_t *bitLow;
+    uint8_t *currentBitSequence = bitLow;
    volatile SignalPart signal;
-
-
 };

-
-
--- a/IR_config.h
+++ b/IR_config.h
@ -1,7 +1,7 @@
 #pragma once
 #include <Arduino.h>

-// #define IRDEBUG_INFO
+#define IRDEBUG_INFO
 /*//////////////////////////////////////////////////////////////////////////////////////

 Для работы в паре положить декодер в энкодер
@ -66,10 +66,10 @@ customByte - контрольная сумма принятых данных п



-/`````````````````````` Задний сигнал машинки без адресации ``````````````````````\        В (IR_MASK_MSG_INFO & 15U) содержится количество байт
-                                                                                           сквозных команд, максимум 15
-{``````````} [````````````````````````] [````````````````````````] [``````````````]        Если полезных байт информации нет, отправляется один
-{ 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 ]        
@ -101,11 +101,15 @@ customByte - контрольная сумма принятых данных п
 /////////////////////////////////////////////////////////////////////////////////////*/
 typedef uint16_t crc_t;

+#define BRUTEFORCE_CHECK                            // Перепроверяет пакет на 1 битные ошибки //TODO: зависает
 #define bytePerPack 16                              // колличество байтов в пакете
 #ifndef freeFrec
-#define freeFrec true
+#define freeFrec false
+#endif
+
+#ifndef subBufferSize
+#define subBufferSize 5 //Буфер для складирования фронтов, пока их не обработают (передатчик)
 #endif
-#define subBufferSize 15 //Буфер для складирования фронтов, пока их не обработают (передатчик)

 #define preambPulse 3

@ -131,12 +135,11 @@ typedef uint16_t crc_t;

 // В процессе работы значения будут отклонятся в соответствии с предыдущим битом
 #define bitActiveTakts 25U                                  // длительность высокого уровня в тактах 
-#define bitPauseTakts 6U                                    // длительность низкого уровня в тактах
+#define bitPauseTakts 12U                                    // длительность низкого уровня в тактах

-#define bitTakts (bitActiveTakts+(bitPauseTakts*2U))          // Общая длительность бита в тактах
+#define bitTakts (bitActiveTakts+bitPauseTakts)          // Общая длительность бита в тактах
 #define bitTime (bitTakts*carrierPeriod)                    // Общая длительность бита
 #define tolerance 300U
-
 class IR_FOX {
 public:
    struct PackOffsets {
@ -169,13 +172,17 @@ public:
        uint16_t rTime = 0;
    };

-    static void checkaddressRuleApply(uint16_t address, uint16_t id, bool& flag) {
+    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; }
+    void setId(uint16_t id) { this->id = id; }
+
+    uint16_t id;
 protected:
    ErrorsStruct errors;
    uint8_t crc8(uint8_t* data, uint8_t start, uint8_t end, uint8_t poly) { //TODO: сделать возможность межбайтовой проверки
--- a/PacketTypes.h
+++ b/PacketTypes.h
@ -2,9 +2,12 @@
 #include "IR_config.h"

 class IR_Decoder;
-namespace PacketTypes {
-    class BasePack {
+namespace PacketTypes
+{
+    class BasePack
+    {
        friend IR_Decoder;
+
    protected:
        bool isAvailable;
        bool isRawAvailable;
@ -15,49 +18,80 @@ namespace PacketTypes {
        uint8_t addressToOffset;
        uint8_t DataOffset;

-        IR_FOX::PackInfo* packInfo;
+        IR_FOX::PackInfo *packInfo;
        uint16_t id;

-        virtual bool checkAddress();
-        void set(IR_FOX::PackInfo* packInfo, uint16_t id) {
+        virtual bool checkAddress() { return true; };
+        void set(IR_FOX::PackInfo *packInfo, uint16_t id)
+        {
            this->packInfo = packInfo;
            this->id = id;

-            if (isAvailable = checkAddress()) {
+            if (checkAddress())
+            {
                isAvailable = true;
                isRawAvailable = true;
-                #ifdef IRDEBUG_INFO
+#ifdef IRDEBUG_INFO
                Serial.print("  OK  ");
-                #endif
-            } else {
+#endif
+            }
+            else
+            {
                isRawAvailable = true;
-                #ifdef IRDEBUG_INFO
+#ifdef IRDEBUG_INFO
                Serial.print("  NOT-OK  ");
-                #endif
+#endif
            }
        }

-
-        static uint16_t _getAddrFrom(BasePack* obj) {
+        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) {
+        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) {
+        static uint8_t _getDataSize(BasePack *obj)
+        {
            return obj->packInfo->packSize - crcBytes - obj->DataOffset;
        };
-        static uint8_t* _getDataPrt(BasePack* obj) {
+        static uint8_t *_getDataPrt(BasePack *obj)
+        {
            return obj->packInfo->buffer + obj->DataOffset;
        };
-        static uint8_t _getDataRawSize(BasePack* obj) {
+        static uint8_t _getDataRawSize(BasePack *obj)
+        {
            return obj->packInfo->packSize;
        };

    public:
-        bool available() { if (isAvailable) { isAvailable = false; isRawAvailable = false; return true; } else { return false; } };
-        bool availableRaw() { if (isRawAvailable) { isRawAvailable = false; return true; } else { return false; } };
+        bool available()
+        {
+            if (isAvailable)
+            {
+                isAvailable = false;
+                isRawAvailable = false;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        };
+        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]; };
@ -66,13 +100,14 @@ namespace PacketTypes {
        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; };
+        uint8_t *getDataRawPtr() { return packInfo->buffer; };
    };

-
-    class Data : public BasePack {
+    class Data : public BasePack
+    {
    public:
-        Data() {
+        Data()
+        {
            msgOffset = 0;
            addressFromOffset = 1;
            addressToOffset = 3;
@ -83,20 +118,23 @@ namespace PacketTypes {
        uint16_t getAddrTo() { return _getAddrTo(this); };

        uint8_t getDataSize() { return _getDataSize(this); };
-        uint8_t* getDataPrt() { return _getDataPrt(this); };
+        uint8_t *getDataPrt() { return _getDataPrt(this); };
        uint8_t getDataRawSize() { return _getDataRawSize(this); };

    private:
-        bool checkAddress() override {
+        bool checkAddress() override
+        {
            bool ret;
-            IR_FOX::checkaddressRuleApply(getAddrTo(), this->id, ret);
+            IR_FOX::checkAddressRuleApply(getAddrTo(), this->id, ret);
            return ret;
        }
    };

-    class DataBack : public BasePack {
+    class DataBack : public BasePack
+    {
    public:
-        DataBack() {
+        DataBack()
+        {
            msgOffset = 0;
            addressFromOffset = 1;
            addressToOffset = 3;
@ -107,15 +145,20 @@ namespace PacketTypes {
        uint16_t getAddrTo() { return _getAddrTo(this); };

        uint8_t getDataSize() { return _getDataSize(this); };
-        uint8_t* getDataPrt() { return _getDataPrt(this); };
+        uint8_t *getDataPrt() { return _getDataPrt(this); };
        uint8_t getDataRawSize() { return _getDataRawSize(this); };
+
    private:
-        bool checkAddress() override {
+        bool checkAddress() override
+        {
            bool ret;
-            if (getMsgType() == IR_MSG_BACK_TO) {
+            if (getMsgType() == IR_MSG_BACK_TO)
+            {
                DataOffset = 5;
-                IR_FOX::checkaddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
-            } else {
+                IR_FOX::checkAddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
+            }
+            else
+            {
                DataOffset = 3;
                ret = true;
            }
@ -123,9 +166,11 @@ namespace PacketTypes {
        }
    };

-    class Accept : public BasePack {
+    class Accept : public BasePack
+    {
    public:
-        Accept() {
+        Accept()
+        {
            msgOffset = 0;
            addressFromOffset = 1;
            DataOffset = 3;
@ -133,13 +178,16 @@ namespace PacketTypes {

        uint16_t getAddrFrom() { return _getAddrFrom(this); };
        uint8_t getCustomByte() { return packInfo->buffer[DataOffset]; };
+
    private:
        bool checkAddress() override { return true; }
    };

-    class Request : public BasePack {
+    class Request : public BasePack
+    {
    public:
-        Request() {
+        Request()
+        {
            msgOffset = 0;
            addressFromOffset = 1;
            addressToOffset = 3;
@ -150,9 +198,10 @@ namespace PacketTypes {
        uint16_t getAddrTo() { return _getAddrTo(this); };

    private:
-        bool checkAddress() override {
+        bool checkAddress() override
+        {
            bool ret;
-            IR_FOX::checkaddressRuleApply(getAddrTo(), this->id, ret);
+            IR_FOX::checkAddressRuleApply(getAddrTo(), this->id, ret);
            return ret;
        }
    };
@ -250,7 +299,7 @@ namespace PacketTypes {
 // protected:
 //     bool checkAddress() override {
 //         bool ret;
-//         checkaddressRuleApply(getAddrTo(), this->id, ret);
+//         checkAddressRuleApply(getAddrTo(), this->id, ret);
 //         return ret;
 //     }
 // };
@ -271,7 +320,7 @@ namespace PacketTypes {
 //         bool ret;
 //         if (getMsgType() == IR_MSG_BACK_TO) {
 //             DataOffset = 5;
-//             checkaddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
+//             checkAddressRuleApply((packInfo->buffer[addressToOffset] << 8) | packInfo->buffer[addressToOffset + 1], this->id, ret);
 //         } else {
 //             DataOffset = 3;
 //             ret = true;
@ -294,7 +343,7 @@ namespace PacketTypes {
 // protected:
 //     bool checkAddress() override {
 //         bool ret;
-//         checkaddressRuleApply(getAddrTo(), this->id, ret);
+//         checkAddressRuleApply(getAddrTo(), this->id, ret);
 //         return ret;
 //     }
 // };
--- a/RingBuffer.h
+++ b/RingBuffer.h
@ -0,0 +1,39 @@
+#pragma once
+#include "Arduino.h"
+template <typename T, unsigned int BufferSize>
+class RingBuffer {
+public:
+    RingBuffer() : start(0), end(0) {}
+
+    bool isFull() const {
+        return ((end + 1) % BufferSize) == start;
+    }
+
+    bool isEmpty() const {
+        return start == end;
+    }
+
+    void push(T element) {
+        noInterrupts();
+        if (!isFull()) {
+            data[end] = element;
+            end = (end + 1) % BufferSize;
+        }
+        interrupts();
+    }
+
+    T* pop() {
+        noInterrupts();
+        T* value = nullptr;
+        if (!isEmpty()) {
+            value = &data[start];
+            start = (start + 1) % BufferSize;
+        }
+        interrupts();
+        return value;
+    }
+
+private:
+    T data[BufferSize];
+    unsigned int start, end;
+};
Author	SHA1	Message	Date
DashyFox	59d6e7aa23	test	2024-04-22 14:55:16 +03:00
DashyFox	b2dfee5495	public id	2024-04-22 14:55:07 +03:00
DashyFox	3965616cd1	Merge pull request #4 from Show-maket:STM32_BRUTEFORCE_FIXHACK STM32 works	2024-04-22 13:34:02 +03:00
DashyFox	16da39a293	Merge branch 'STM32' into STM32_BRUTEFORCE_FIXHACK	2024-04-22 13:33:23 +03:00
DashyFox	16a626db22	BRUTEFORCE_CHECK	2024-04-22 12:52:41 +03:00
DashyFox	5cc4555bac	upd	2024-04-22 11:26:11 +03:00
DashyFox	e334625864	STM works	2024-04-22 11:20:53 +03:00
DashyFox	03d74e30cd	json	2024-04-17 11:29:32 +03:00
DashyFox	2972560b13	json	2024-04-17 11:09:22 +03:00
DashyFox	4d12f77a8b	json	2024-04-17 11:08:31 +03:00
DashyFox	3b5045669b	upd	2024-04-17 09:58:32 +03:00
DashyFox	99e523129d	clean	2024-04-16 17:43:18 +03:00
DashyFox	0b888a5840	clean	2024-04-16 17:42:24 +03:00
DashyFox	9643670942	upd	2024-04-16 17:28:16 +03:00
DashyFox	fd62972717	modified: IR-protocol.ino	2024-04-16 16:01:50 +03:00
DashyFox	e5983c8367	modified: IR-protocol.ino	2024-04-16 16:00:23 +03:00
DashyFox	d774f87f7a	BRUTEFORCE	2024-04-16 15:58:35 +03:00
DashyFox	27a5b28a17	STM First Test	2024-04-16 15:52:59 +03:00
DashyFox	ff306e7fae	upd	2024-04-02 14:13:39 +03:00
DashyFox	886f8ab360	sendBack(uint8_t data)	2024-03-18 11:37:36 +03:00
DashyFox	8d0f45ddf1	formatting	2024-03-15 16:08:06 +03:00
DashyFox	3e3601e009	more buffer	2024-03-15 15:20:00 +03:00
DashyFox	0ba051569c	OCR2A cleanup code	2024-03-15 15:19:26 +03:00
DashyFox	c31be52d47	subBufferSize 25	2024-03-06 16:20:50 +03:00
DashyFox	9b2895ed7d	Clean	2024-03-04 15:02:04 +03:00
DashyFox	d67a6fe4ac	buffer	2024-03-01 17:54:30 +03:00
DashyFox	5547bec263	fix nullptr	2024-03-01 17:54:15 +03:00
DashyFox	af6041c5ae	isSubOverflow fix	2024-02-29 16:24:35 +03:00
DashyFox	960b3064cb	isSubOverflow	2024-02-29 15:58:53 +03:00
DashyFox	c2506fe1dc	no isSubOverflow, todo	2024-02-29 15:35:49 +03:00
DashyFox	c3b5997d84	isSubOverflow save SREG	2024-02-29 15:17:29 +03:00
DashyFox	762fb21226	isSubBufferOverflow fix	2024-02-29 14:53:30 +03:00
DashyFox	db86bcf74c	subBuffer overflow detect	2024-02-29 14:43:14 +03:00
DashyFox	24b68b953b	raw fix	2024-02-29 14:28:23 +03:00
DashyFox	60a8e58cc3	add Raw	2024-02-29 13:14:43 +03:00
DashyFox	eac364b0d3	add simple sendData	2024-02-29 12:34:38 +03:00
DashyFox	aed1543bd3	ifndef subBufferSize	2024-02-29 12:34:18 +03:00
DashyFox	51fc9a9936	rename Raw	2024-02-28 15:58:49 +03:00
DashyFox	81851e5fd8	add timer off setup	2024-02-28 15:17:48 +03:00
DashyFox	434e1aaa90	little opti	2024-02-28 13:53:27 +03:00
DashyFox	4fd4983bb9	add default params	2024-02-28 13:13:04 +03:00
DashyFox	cb1664bb4f	add nullptr protect	2024-02-28 13:11:29 +03:00
DashyFox	f6bbd96a4c	moved id to parrent class	2024-02-28 10:03:31 +03:00
DashyFox	b7d0179092	add id change func	2024-02-28 09:52:38 +03:00
DashyFox	f92851c55d	rename checkAddressRuleApply	2024-02-28 09:44:13 +03:00
DashyFox	22f7cd68ca	removed unused parametr	2024-02-28 09:43:59 +03:00