upd

Stm32 opti test

IR-protocol.ino

@@ -23,18 +23,6 @@
 
 #define LoopOut PC13
 
-#define dec_ISR(n) \
-    void dec_##n##_ISR() { dec##n.isr(); }
-#define dec_Ini(n)                      \
-    IR_Decoder dec##n(dec##n##_PIN, n); \
-    dec_ISR(n)
-
-#define 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 |= status/* Simple */(dec##n);
-
 //////////////// Ini /////////////////
 
 #define INFO "IR_FOX TEST"
@@ -63,20 +51,47 @@ void EncoderISR()
 
 //-------------------------------------------------------------------
 
-dec_Ini(0);
-dec_Ini(1);
-dec_Ini(2);
-dec_Ini(3);
-dec_Ini(4);
-dec_Ini(5);
-dec_Ini(6);
-dec_Ini(7);
-// dec_Ini(8);
-// dec_Ini(9);
-// dec_Ini(10);
-// dec_Ini(11);
-// dec_Ini(12);
-// dec_Ini(13);
+IR_Decoder dec0(dec0_PIN, 0);
+void dec_0_ISR() { dec0.isr(); }
+
+IR_Decoder dec1(dec1_PIN, 1);
+void dec_1_ISR() { dec1.isr(); }
+
+IR_Decoder dec2(dec2_PIN, 2);
+void dec_2_ISR() { dec2.isr(); }
+
+IR_Decoder dec3(dec3_PIN, 3);
+void dec_3_ISR() { dec3.isr(); }
+
+IR_Decoder dec4(dec4_PIN, 4);
+void dec_4_ISR() { dec4.isr(); }
+
+IR_Decoder dec5(dec5_PIN, 5);
+void dec_5_ISR() { dec5.isr(); }
+
+IR_Decoder dec6(dec6_PIN, 6);
+void dec_6_ISR() { dec6.isr(); }
+
+IR_Decoder dec7(dec7_PIN, 7);
+void dec_7_ISR() { dec7.isr(); }
+
+// IR_Decoder dec8(dec8_PIN, 8);
+// void dec_8_ISR() { dec8.isr(); }
+
+// IR_Decoder dec9(dec9_PIN, 9);
+// void dec_9_ISR() { dec9.isr(); }
+
+// IR_Decoder dec10(dec10_PIN, 10);
+// void dec_10_ISR() { dec10.isr(); }
+
+// IR_Decoder dec11(dec11_PIN, 11);
+// void dec_11_ISR() { dec11.isr(); }
+
+// IR_Decoder dec12(dec12_PIN, 12);
+// void dec_12_ISR() { dec12.isr(); }
+
+// IR_Decoder dec13(dec13_PIN, 13);
+// void dec_13_ISR() { dec13.isr(); }
 
 /////////////////////////////////////////////////////////////////////
 uint8_t data0[] = {};
@@ -88,6 +103,7 @@ uint8_t data4[] = {42, 127, 137, 255};
 uint32_t loopTimer;
 uint8_t sig = 0;
 uint16_t targetAddr = IR_Broadcast;
+
 Timer t1(500, millis, []()
          {
              // Serial.println( digitalPinToBitMask(enc0.getPin()), BIN);
@@ -181,6 +197,7 @@ Timer t1(500, millis, []()
              // encBackward.sendData(IR_Broadcast, data2);
              // encTree.sendData(IR_Broadcast, rawData3);
          });
+
 // Timer t2(50, millis, []()
 //          { digitalToggle(LED_BUILTIN); });
 
@@ -190,8 +207,6 @@ HardwareTimer IR_Timer(TIM3);
 
 void setup()
 {
-    // MicrosTimer.setOve
-
     IR_Timer.setOverflow(carrierFrec * 2, HERTZ_FORMAT);
     IR_Timer.attachInterrupt(1, EncoderISR);
     NVIC_SetPriority(IRQn_Type::TIM3_IRQn, 0);
@@ -201,79 +216,59 @@ void setup()
     Serial.println(F(INFO));
 
     pinMode(LoopOut, OUTPUT);
-    // pinMode(SignalDetectLed, OUTPUT);
 
     pinMode(dec0_PIN, INPUT_PULLUP);
-    // pinMode(dec2_PIN, INPUT_PULLUP);
+    pinMode(dec1_PIN, INPUT_PULLUP);
+    pinMode(dec2_PIN, INPUT_PULLUP);
+    pinMode(dec3_PIN, INPUT_PULLUP);
+    pinMode(dec4_PIN, INPUT_PULLUP);
+    pinMode(dec5_PIN, INPUT_PULLUP);
+    pinMode(dec6_PIN, INPUT_PULLUP);
+    pinMode(dec7_PIN, INPUT_PULLUP);
+    // pinMode(dec8_PIN, INPUT_PULLUP);
+    // pinMode(dec9_PIN, INPUT_PULLUP);
+    // pinMode(dec10_PIN, INPUT_PULLUP);
+    // pinMode(dec11_PIN, INPUT_PULLUP);
+    // pinMode(dec12_PIN, INPUT_PULLUP);
+    // pinMode(dec13_PIN, INPUT_PULLUP);
 
-    static IR_DecoderRaw *blind[]{
-        &dec0,
-        &dec1,
-        &dec2,
-        &dec3,
-        &dec4,
-        &dec5,
-        &dec6,
-        &dec7,
-        // &dec8,
-        // &dec9,
-        // &dec10,
-        // &dec11,
-        // &dec12,
-        // &dec13,
-    };
-
-    enc0.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
-    // enc1.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
-    // enc2.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
-    // enc3.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
-    // enc10.setBlindDecoders(blind, sizeof(blind) / sizeof(IR_DecoderRaw *));
-
-    decSetup(0);
-    decSetup(1);
-    decSetup(2);
-    decSetup(3);
-    decSetup(4);
-    decSetup(5);
-    decSetup(6);
-    decSetup(7);
-    // decSetup(8);
-    // decSetup(9);
-    // decSetup(10);
-    // decSetup(11);
-    // decSetup(12);
-    // decSetup(13);
+    attachInterrupt(dec0_PIN, dec_0_ISR, CHANGE);
+    attachInterrupt(dec1_PIN, dec_1_ISR, CHANGE);
+    attachInterrupt(dec2_PIN, dec_2_ISR, CHANGE);
+    attachInterrupt(dec3_PIN, dec_3_ISR, CHANGE);
+    attachInterrupt(dec4_PIN, dec_4_ISR, CHANGE);
+    attachInterrupt(dec5_PIN, dec_5_ISR, CHANGE);
+    attachInterrupt(dec6_PIN, dec_6_ISR, CHANGE);
+    attachInterrupt(dec7_PIN, dec_7_ISR, CHANGE);
+    // attachInterrupt(dec8_PIN, dec_8_ISR, CHANGE);
+    // attachInterrupt(dec9_PIN, dec_9_ISR, CHANGE);
+    // attachInterrupt(dec10_PIN, dec_10_ISR, CHANGE);
+    // attachInterrupt(dec11_PIN, dec_11_ISR, CHANGE);
+    // attachInterrupt(dec12_PIN, dec_12_ISR, CHANGE);
+    // attachInterrupt(dec13_PIN, dec_13_ISR, CHANGE);
 }
 
 void loop()
 {
     digitalToggle(LoopOut);
     Timer::tick();
-
     IR_Decoder::tick();
 
-    bool rx_flag;
-    decStat(0);
-    decStat(1);
-    decStat(2);
-    decStat(3);
-    decStat(4);
-    decStat(5);
-    decStat(6);
-    decStat(7);
-    // decStat(8);
-    // decStat(9);
-    // decStat(10);
-    // decStat(11);
-    // decStat(12);
-    // decStat(13);
-
-    // status(decForward);
-    // status(decBackward);
-
-    // Serial.println(micros() - loopTimer);
-    // loopTimer = micros();
-    // delayMicroseconds(120*5);
+    bool rx_flag = false;
+    rx_flag |= status(dec0);
+    rx_flag |= status(dec1);
+    rx_flag |= status(dec2);
+    rx_flag |= status(dec3);
+    rx_flag |= status(dec4);
+    rx_flag |= status(dec5);
+    rx_flag |= status(dec6);
+    rx_flag |= status(dec7);
+    // rx_flag |= status(dec8);
+    // rx_flag |= status(dec9);
+    // rx_flag |= status(dec10);
+    // rx_flag |= status(dec11);
+    // rx_flag |= status(dec12);
+    // rx_flag |= status(dec13);
 
     if (Serial.available())
     {
@@ -289,13 +284,14 @@ void loop()
         case 102:
             targetAddr = 777;
             break;
-
         default:
             sig = in;
             break;
         }
     }
 }
+
+
 Timer statusSimpleDelay;
 bool statusSimple(IR_Decoder &dec)
 {
@@ -326,7 +322,7 @@ bool status(IR_Decoder &dec)
     if (dec.gotData.available())
     {
         detectSignal();
-        Serial.println(micros());
+        // Serial.println(micros());
         String str;
         if (/* dec.gotData.getDataPrt()[1] */ 1)
         {

IR_Decoder.cpp

@@ -23,12 +23,14 @@ void IR_Decoder::enable()
     {
         dec_list.push_back(this);
     }
+    pinMode(pin, INPUT_PULLUP);
     attachInterrupt(pin, (*this)(), CHANGE);
 }
 
 void IR_Decoder::disable()
 {
     detachInterrupt(pin);
+    pinMode(pin, INPUT);
     auto &dec_list = get_dec_list();
     auto it = std::find(dec_list.begin(), dec_list.end(), this);
     if (it != dec_list.end())
@@ -59,6 +61,7 @@ void IR_Decoder::tick()
 void IR_Decoder::_tick()
 {
     IR_DecoderRaw::tick();
+
     if (availableRaw())
     {
 #ifdef IRDEBUG_INFO
@@ -95,9 +98,13 @@ void IR_Decoder::_tick()
         }
         gotRaw.set(&packInfo, id);
     }
-    if (isWaitingAcceptSend && millis() - acceptSendTimer > 75)
+    if (isWaitingAcceptSend && millis() - acceptSendTimer > acceptDelay)
     {
         encoder->sendAccept(addrAcceptSendTo, acceptCustomByte);
         isWaitingAcceptSend = false;
     }
 }
+
+bool IR_Decoder::isReceive(uint8_t type) {
+    return (msgTypeReceive & 0b11111000) && ((msgTypeReceive & IR_MASK_MSG_TYPE) == type);
+} 

IR_Decoder.h

@@ -14,7 +14,7 @@ private:
     bool isWaitingAcceptSend;
     uint16_t addrAcceptSendTo;
 
-    uint16_t acceptDelay = 75;
+    uint16_t acceptDelay = IR_ResponseDelay;
     uint8_t acceptCustomByte;
 
 public:
@@ -32,6 +32,8 @@ public:
     void enable();
     void disable();
     
+    bool isReceive(uint8_t type);
+
     ~IR_Decoder();
 
     static void tick();

IR_DecoderRaw.cpp

@@ -112,16 +112,37 @@ void IR_DecoderRaw::firstRX()
 
 void IR_DecoderRaw::listenStart()
 {
-    if (isRecive && ((micros() - prevRise) > IR_timeout * 2))
+    if (isReciveRaw && ((micros() - prevRise) > IR_timeout * 2))
     {
         // Serial.print("\nlis>");
-        isRecive = false;
+        isReciveRaw = false;
         firstRX();
     }
 }
 
+
+// ---- быстрая проверка конца пакета ---------------------------------
+inline void IR_DecoderRaw::checkTimeout()
+{
+    if (!isRecive) return;     // уже не принимаем – нечего проверять
+
+    if (micros() - lastEdgeTime > IR_timeout * 2U)
+    {
+        isRecive = false;      // приём завершён
+        msgTypeReceive = 0;
+        // firstRX();             // подготовка к новому пакету
+        lastEdgeTime = micros(); // защита от повторного срабатывания
+    }
+}
+// ====================================================================
+
 void IR_DecoderRaw::tick()
 {
+    // FrontStorage *currentFrontPtr;
+    // noInterrupts();
+    // currentFrontPtr = subBuffer.pop();
+    // interrupts();
+
     FrontStorage currentFront;
     noInterrupts();
     listenStart();
@@ -130,12 +151,24 @@ void IR_DecoderRaw::tick()
     if (currentFrontPtr == nullptr)
     {
         isSubBufferOverflow = false;
+        checkTimeout();          // <--- новое место проверки
         interrupts();
         return;
     } // Если данных нет - ничего не делаем
     currentFront = *currentFrontPtr;
     interrupts();
 
+    // ---------- буфер пуст: фронтов нет, проверяем тайм-аут ----------
+    // if (currentFrontPtr == nullptr)
+    // {
+    //     isSubBufferOverflow = false;
+    //     return;
+    // }
+
+    // // ---------- есть фронт: продолжаем обработку ----------
+    // FrontStorage currentFront = *currentFrontPtr;
+    lastEdgeTime = currentFront.time;     // запоминаем любой фронт
+
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
     if (currentFront.dir)
@@ -197,7 +230,7 @@ void IR_DecoderRaw::tick()
     digitalWrite(errOut, currentFront.dir);
 #endif
 
-    if (currentFront.time > prevRise && currentFront.time - prevRise > IR_timeout * 2 && !isRecive)
+    if (currentFront.time > prevRise && currentFront.time - prevRise > IR_timeout * 2 && !isReciveRaw)
     { // первый
 #ifdef IRDEBUG
         errPulse(up, 50);
@@ -209,6 +242,7 @@ void IR_DecoderRaw::tick()
         isPreamb = true;
 
         isRecive = true;
+        isReciveRaw = true;
         isWrongPack = false;
     }
 
@@ -441,6 +475,8 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
     if (isBufferOverflow || isPreamb || isWrongPack)
     {
         isRecive = false;
+        isReciveRaw = false;
+        msgTypeReceive = 0;
         return;
     }
 
@@ -564,6 +600,8 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
             packInfo.rTime = riseSyncTime;
 
             isRecive = false;
+            isReciveRaw = false;
+            msgTypeReceive = 0;
             isAvailable = crcCheck(packSize - crcBytes, crcValue);
 
 #ifdef BRUTEFORCE_CHECK
@@ -594,6 +632,12 @@ void IR_DecoderRaw::writeToBuffer(bool bit)
         OUT_BRUTEFORCE:;
 #endif
         }
+
+        if (packSize && (i_dataBuffer == 8)) {
+            msgTypeReceive = (dataBuffer[0]>>5) | 0b11111000;
+            // SerialUSB.println(msgTypeReceive & IR_MASK_MSG_TYPE);
+
+        }
     }
 
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

IR_DecoderRaw.h

@@ -23,6 +23,7 @@
 #define riseTimeMin (riseTime - riseTolerance)
 #define aroundRise(t) (riseTimeMin < t && t < riseTimeMax)
 #define IR_timeout (riseTimeMax * (8 + syncBits + 1)) // us // таймаут в 8 data + 3 sync + 1
+constexpr uint16_t IR_ResponseDelay = ((uint16_t)(((bitTime+riseTolerance) * (8 + syncBits + 1))*2.7735))/1000;
 
 class IR_Encoder;
 class IR_DecoderRaw : virtual public IR_FOX
@@ -31,6 +32,7 @@ class IR_DecoderRaw : virtual public IR_FOX
 
 protected:
 PackInfo packInfo;
+uint8_t msgTypeReceive = 0;
 IR_Encoder *encoder; // Указатель на парный передатчик
 bool availableRaw();
 
@@ -47,7 +49,7 @@ public:
 
     inline bool isOverflow() { return isBufferOverflow; }; // Буффер переполнился
     bool isSubOverflow();
-    inline bool isReciving() { return isBufferOverflow; }; // Возвращает true, если происходит приём пакета
+    volatile inline bool isReciving() { return isRecive; }; // Возвращает true, если происходит приём пакета
 
     //////////////////////////////////////////////////////////////////////////
 private:
@@ -64,6 +66,8 @@ private:
 
     uint16_t riseSyncTime = bitTime; // Подстраиваемое время бита в мкс
 
+    volatile uint32_t lastEdgeTime = 0;   // время последнего фронта
+
     ////////////////////////////////////////////////////////////////////////
     volatile uint32_t currentSubBufferIndex; // Счетчик текущей позиции во вспомогательном буфере фронтов/спадов
 
@@ -99,7 +103,9 @@ private:
     int16_t bufBitPos = 0;         // Позиция для записи бита в буффер
 
 private:
-    void listenStart(); // @brief Слушатель для работы isReciving()
+bool isReciveRaw;
+    void listenStart();
+    void checkTimeout();                  // 
 
     /// @brief Проверка CRC. Проверяет len байт со значением crc, пришедшим в пакете
     /// @param len Длина в байтах проверяемых данных

IR_Encoder.cpp

@@ -1,15 +1,14 @@
 #include "IR_Encoder.h"
 #include "IR_DecoderRaw.h"
+#include <string.h>
 
 #define LoopOut 12
 #define ISR_Out 10
 #define TestOut 13
 
-std::list<IR_Encoder *> &IR_Encoder::get_enc_list() // определение функции
-{
-    static std::list<IR_Encoder *> dec_list; // статическая локальная переменная
-    return dec_list;                         // возвращается ссылка на переменную
-}
+IR_Encoder *IR_Encoder::head = nullptr;
+IR_Encoder *IR_Encoder::last = nullptr;
+volatile bool IR_Encoder::carrierStopPending = false;
 
 IR_Encoder::IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair, bool autoHandle)
 {
@@ -29,31 +28,276 @@ IR_Encoder::IR_Encoder(uint8_t pin, uint16_t addr, IR_DecoderRaw *decPair, bool
     {
         decPair->encoder = this;
     }
-    pinMode(pin, OUTPUT);
 
     if (autoHandle)
     {
-        get_enc_list().push_back(this);
+        if (IR_Encoder::head == nullptr)
+        {
+        IR_Encoder::head = this;
+        }
+        if (last != nullptr)
+        {
+        last->next = this;
+        }
+        last = this;
+        
+        pinMode(pin, OUTPUT);
     }
 };
  
+HardwareTimer* IR_Encoder::IR_Timer = nullptr;
+IR_Encoder::ExternalTxStartFn IR_Encoder::externalTxStartFn = nullptr;
+IR_Encoder::ExternalTxBusyFn IR_Encoder::externalTxBusyFn = nullptr;
+void *IR_Encoder::externalTxCtx = nullptr;
+
+inline HardwareTimer* IR_Encoder::get_IR_Timer(){return IR_Encoder::IR_Timer;}
+
+void IR_Encoder::carrierResume() {
+    if (IR_Timer != nullptr)
+        IR_Timer->resume();
+}
+
+void IR_Encoder::carrierPauseIfIdle() {
+    for (IR_Encoder *p = head; p != nullptr; p = p->next)
+        if (p->isSending)
+            return;
+    if (IR_Timer != nullptr)
+        IR_Timer->pause();
+}
+
+void IR_Encoder::tick() {
+    if (!carrierStopPending)
+        return;
+    carrierStopPending = false;
+    carrierPauseIfIdle();
+}
+
+void IR_Encoder::begin(HardwareTimer* timer, uint8_t channel, IRQn_Type IRQn, uint8_t priority, void(*isrCallback)()){
+    IR_Timer = timer;
+    if(IR_Timer == nullptr) return;
+    IR_Timer->pause();
+    IR_Timer->setOverflow(carrierFrec * 2, HERTZ_FORMAT);
+    IR_Timer->attachInterrupt(channel, (isrCallback == nullptr ? IR_Encoder::isr : isrCallback));
+    NVIC_SetPriority(IRQn, priority);
+    IR_Timer->pause();
+}
+
+void IR_Encoder::beginClockOnly(HardwareTimer *timer)
+{
+    IR_Timer = timer;
+    if (IR_Timer == nullptr)
+        return;
+    IR_Timer->pause();
+    IR_Timer->setOverflow(carrierFrec * 2, HERTZ_FORMAT);
+    IR_Timer->pause();
+}
+
+void IR_Encoder::setExternalTxBackend(ExternalTxStartFn startFn, ExternalTxBusyFn busyFn, void *ctx)
+{
+    externalTxStartFn = startFn;
+    externalTxBusyFn = busyFn;
+    externalTxCtx = ctx;
+}
+
+void IR_Encoder::externalFinishSend()
+{
+    if (!isSending)
+        return;
+
+    // Force output low.
+    if (port != nullptr) {
+        port->BSRR = ((uint32_t)mask) << 16;
+    }
+
+    isSending = false;
+    setDecoder_isSending();
+}
+
+size_t IR_Encoder::buildGateRuns(const uint8_t *packet, uint8_t len, IR_TxGateRun *outRuns, size_t maxRuns)
+{
+    if (packet == nullptr || outRuns == nullptr || maxRuns == 0)
+    {
+        return 0;
+    }
+    if (len == 0 || len > dataByteSizeMax)
+    {
+        return 0;
+    }
+
+    // Copy into fixed-size buffer to match original encoder behavior (safe reads past sendLen).
+    uint8_t sendBufferLocal[dataByteSizeMax] = {0};
+    memcpy(sendBufferLocal, packet, len);
+
+    uint8_t sendLenLocal = len;
+    uint8_t toggleCounterLocal = preambToggle;
+    uint8_t dataBitCounterLocal = bitPerByte - 1;
+    uint8_t dataByteCounterLocal = 0;
+    uint8_t preambFrontCounterLocal = preambPulse * 2 - 1;
+    uint8_t dataSequenceCounterLocal = bitPerByte * 2;
+    uint8_t syncSequenceCounterLocal = syncBits * 2;
+    bool syncLastBitLocal = false;
+    SignalPart signalLocal = preamb;
+    bool stateLocal = HIGH;
+    uint8_t *currentBitSequenceLocal = bitHigh;
+
+    size_t runCount = 0;
+
+    while (true)
+    {
+        const bool gate = stateLocal;
+        const uint16_t runLenTicks = (uint16_t)toggleCounterLocal + 1U;
+
+        if (runCount > 0 && outRuns[runCount - 1].gate == gate)
+        {
+            outRuns[runCount - 1].lenTicks = (uint16_t)(outRuns[runCount - 1].lenTicks + runLenTicks);
+        }
+        else
+        {
+            if (runCount >= maxRuns)
+            {
+                return 0;
+            }
+            outRuns[runCount].gate = gate;
+            outRuns[runCount].lenTicks = runLenTicks;
+            runCount++;
+        }
+
+        // Advance state to the next run boundary (equivalent to ISR iteration when toggleCounter == 0).
+        while (true)
+        {
+            switch (signalLocal)
+            {
+            case noSignal:
+                return runCount;
+
+            case preamb:
+                if (preambFrontCounterLocal)
+                {
+                    preambFrontCounterLocal--;
+                    toggleCounterLocal = preambToggle;
+                    break;
+                }
+                // End of preamble.
+                signalLocal = data;
+                stateLocal = !LOW;
+                continue;
+
+            case data:
+                if (dataSequenceCounterLocal)
+                {
+                    if (!(dataSequenceCounterLocal & 1U))
+                    {
+                        currentBitSequenceLocal = ((sendBufferLocal[dataByteCounterLocal] >> dataBitCounterLocal) & 1U) ? bitHigh : bitLow;
+                        dataBitCounterLocal--;
+                    }
+                    toggleCounterLocal = currentBitSequenceLocal[!stateLocal];
+                    dataSequenceCounterLocal--;
+                    break;
+                }
+                // End of data byte.
+                syncLastBitLocal = ((sendBufferLocal[dataByteCounterLocal]) & 1U);
+                dataByteCounterLocal++;
+                dataBitCounterLocal = bitPerByte - 1;
+                dataSequenceCounterLocal = bitPerByte * 2;
+                signalLocal = sync;
+                continue;
+
+            case sync:
+                if (syncSequenceCounterLocal)
+                {
+                    if (!(syncSequenceCounterLocal & 1U))
+                    {
+                        if (syncSequenceCounterLocal == 2)
+                        {
+                            currentBitSequenceLocal = ((sendBufferLocal[dataByteCounterLocal]) & 0b10000000) ? bitLow : bitHigh;
+                        }
+                        else
+                        {
+                            currentBitSequenceLocal = syncLastBitLocal ? bitLow : bitHigh;
+                            syncLastBitLocal = !syncLastBitLocal;
+                        }
+                    }
+                    toggleCounterLocal = currentBitSequenceLocal[!stateLocal];
+                    syncSequenceCounterLocal--;
+                    break;
+                }
+                // End of sync.
+                signalLocal = data;
+                syncSequenceCounterLocal = syncBits * 2;
+                if (dataByteCounterLocal >= sendLenLocal)
+                {
+                    signalLocal = noSignal;
+                }
+                continue;
+
+            default:
+                return 0;
+            }
+
+            stateLocal = !stateLocal;
+            break;
+        }
+    }
+}
+
+
 void IR_Encoder::enable()
 {
-    auto &enc_list = get_enc_list();
-    if (std::find(enc_list.begin(), enc_list.end(), this) == enc_list.end())
+    bool exist = false;
+    IR_Encoder *current = IR_Encoder::head;
+    while (current != nullptr)
     {
-        enc_list.push_back(this);
+        exist = (current == this);
+        if (exist) break;
+        current = current->next;
     }
+    if (!exist)
+    {
+        if (IR_Encoder::head == nullptr)
+        {
+            IR_Encoder::head = this;
+            last = this;
+        }
+        else
+        {
+            last->next = this;
+            last = this;
+        }
+        this->next = nullptr; // Указываем, что следующий за этим элементом — nullptr
+    }
+    pinMode(pin, OUTPUT);
 }
 
 void IR_Encoder::disable()
 {
-    auto &enc_list = get_enc_list();
-    auto it = std::find(enc_list.begin(), enc_list.end(), this);
-    if (it != enc_list.end())
+    IR_Encoder *current = IR_Encoder::head;
+    IR_Encoder *prev = nullptr;
+
+    while (current != nullptr)
     {
-        enc_list.erase(it);
+        if (current == this) break;
+        prev = current;
+        current = current->next;
     }
+
+    if (current != nullptr) // Элемент найден в списке
+    {
+        if (prev != nullptr)
+        {
+            prev->next = current->next; // Убираем текущий элемент из списка
+        }
+        else
+        {
+            IR_Encoder::head = current->next; // Удаляемый элемент был первым
+        }
+
+        if (current == last)
+        {
+            last = prev; // Если удаляется последний элемент, обновляем last
+        }
+    }
+
+    pinMode(pin, INPUT);
 }
 
 void IR_Encoder::setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count)
@@ -66,25 +310,23 @@ void IR_Encoder::setBlindDecoders(IR_DecoderRaw *decoders[], uint8_t count)
     blindDecoders = decoders;
 }
 
-IR_Encoder::~IR_Encoder()
-{
-    get_enc_list().remove(this);
-};
+IR_Encoder::~IR_Encoder(){};
 
-void IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept)
+IR_SendResult IR_Encoder::sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept)
 {
-    sendData(addrTo, &dataByte, 1, needAccept);
+    return sendData(addrTo, &dataByte, 1, needAccept);
 }
 
-void IR_Encoder::sendData(uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept){
-    sendDataFULL(id, addrTo, data, len, needAccept);
+IR_SendResult IR_Encoder::sendData(uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept){
+    return sendDataFULL(id, addrTo, data, len, needAccept);
 }
 
-void IR_Encoder::sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept)
+IR_SendResult IR_Encoder::sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept)
 {
     if (len > bytePerPack)
     {
-        return;
+        Serial.println("IR Pack to big");
+        return IR_SendResult(false, 0);
     }
     constexpr uint8_t dataStart = msgBytes + addrBytes + addrBytes;
     memset(sendBuffer, 0x00, dataByteSizeMax);
@@ -113,6 +355,19 @@ void IR_Encoder::sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data,
     sendBuffer[packSize - crcBytes] = crc8(sendBuffer, 0, packSize - crcBytes, poly1) & 0xFF;
     sendBuffer[packSize - crcBytes + 1] = crc8(sendBuffer, 0, packSize - crcBytes + 1, poly2) & 0xFF;
 
+    //* вывод итогового буфера
+    // Serial.print("IR SEND [len=");
+    // Serial.print(packSize);
+    // Serial.print("] : ");
+    // for (uint8_t i = 0; i < packSize; i++)
+    // {
+    //     if (sendBuffer[i] < 0x10)
+    //         Serial.print('0');
+    //     Serial.print(sendBuffer[i], HEX);
+    //     Serial.print(' ');
+    // }
+    // Serial.println();
+
     // if (decPair != nullptr) {
     //     decPair->isWaitingAccept = ((msgType >> 5) & IR_MASK_MSG_TYPE == IR_MSG_DATA_ACCEPT);
     //     if (decPair->isWaitingAccept) {
@@ -122,9 +377,14 @@ void IR_Encoder::sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data,
 
     // отправка
     rawSend(sendBuffer, packSize);
+    
+    // Возвращаем результат отправки
+    uint32_t sendTime = calculateSendTime(packSize);
+    return IR_SendResult(true, sendTime);
 }
 
-void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte)
+
+IR_SendResult IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte)
 {
     constexpr uint8_t packsize = msgBytes + addrBytes + 1U + crcBytes;
     memset(sendBuffer, 0x00, dataByteSizeMax);
@@ -145,9 +405,13 @@ void IR_Encoder::sendAccept(uint16_t addrTo, uint8_t customByte)
     sendBuffer[5] = crc8(sendBuffer, 0, 5, poly2) & 0xFF;
 
     rawSend(sendBuffer, packsize);
+    
+    // Возвращаем результат отправки
+    uint32_t sendTime = calculateSendTime(packsize);
+    return IR_SendResult(true, sendTime);
 }
 
-void IR_Encoder::sendRequest(uint16_t addrTo)
+IR_SendResult IR_Encoder::sendRequest(uint16_t addrTo)
 {
     constexpr uint8_t packsize = msgBytes + addrBytes + addrBytes + crcBytes;
     memset(sendBuffer, 0x00, dataByteSizeMax);
@@ -167,28 +431,32 @@ void IR_Encoder::sendRequest(uint16_t addrTo)
     sendBuffer[6] = crc8(sendBuffer, 0, 6, poly2) & 0xFF;
 
     rawSend(sendBuffer, packsize);
+    
+    // Возвращаем результат отправки
+    uint32_t sendTime = calculateSendTime(packsize);
+    return IR_SendResult(true, sendTime);
 }
 
-void IR_Encoder::sendBack(uint8_t data)
+IR_SendResult IR_Encoder::sendBack(uint8_t data)
 {
-    _sendBack(false, 0, &data, 1);
+    return _sendBack(false, 0, &data, 1);
 }
 
-void IR_Encoder::sendBack(uint8_t *data, uint8_t len)
+IR_SendResult IR_Encoder::sendBack(uint8_t *data, uint8_t len)
 {
-    _sendBack(false, 0, data, len);
+    return _sendBack(false, 0, data, len);
 }
 
-void IR_Encoder::sendBackTo(uint16_t addrTo, uint8_t *data, uint8_t len)
+IR_SendResult IR_Encoder::sendBackTo(uint16_t addrTo, uint8_t *data, uint8_t len)
 {
-    _sendBack(true, addrTo, data, len);
+    return _sendBack(true, addrTo, data, len);
 }
 
-void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len)
+IR_SendResult IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len)
 {
     if (len > bytePerPack)
     {
-        return;
+        return IR_SendResult(false, 0);
     }
     memset(sendBuffer, 0x00, dataByteSizeMax);
     uint8_t dataStart = msgBytes + addrBytes + (isAdressed ? addrBytes : 0);
@@ -220,6 +488,10 @@ void IR_Encoder::_sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint
 
     // отправка
     rawSend(sendBuffer, packSize);
+    
+    // Возвращаем результат отправки
+    uint32_t sendTime = calculateSendTime(packSize);
+    return IR_SendResult(true, sendTime);
 }
 
 void IR_Encoder::setDecoder_isSending()
@@ -229,6 +501,10 @@ void IR_Encoder::setDecoder_isSending()
         for (uint8_t i = 0; i < decodersCount; i++)
         {
             blindDecoders[i]->isPairSending ^= id;
+            // Serial.print("setDecoder_isSending()   id = ");
+            // Serial.print(id);
+            // Serial.print("   isPairSending = ");
+            // Serial.println(blindDecoders[i]->isPairSending);
         }
     }
 }
@@ -241,6 +517,34 @@ void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
         return;
     }
     
+    // Проверка на переполнение буфера
+    if (len > dataByteSizeMax)
+    {
+        return;
+    }
+
+    if (externalTxStartFn != nullptr)
+    {
+        if (externalTxBusyFn != nullptr && externalTxBusyFn(externalTxCtx))
+        {
+            return;
+        }
+
+        // Mark as sending and delegate actual signal output to external backend.
+        setDecoder_isSending();
+        sendLen = len;
+        isSending = true;
+
+        const bool ok = externalTxStartFn(externalTxCtx, this, ptr, len);
+        if (!ok)
+        {
+            isSending = false;
+            setDecoder_isSending();
+        }
+        return;
+    }
+    IR_Encoder::carrierResume();
+    // Serial.println("START");
     setDecoder_isSending();
 
     // noInterrupts();
@@ -259,16 +563,16 @@ void IR_Encoder::rawSend(uint8_t *ptr, uint8_t len)
     state = HIGH;
 
     currentBitSequence = bitHigh;
-    isSending = true;
     // interrupts();
 }
 
 void IR_Encoder::isr()
 {
-    //  Serial.println(get_enc_list().size());
-    for (const auto &element : get_enc_list())
+    IR_Encoder *current = IR_Encoder::head;
+    while (current != nullptr)
     {
-        element->_isr();
+      current->_isr();
+      current = current->next;
     }
 }
 
@@ -296,7 +600,10 @@ void IR_Encoder::_isr()
             // сброс счетчиков
             // ...
             isSending = false;
+            // Serial.println("STOP");
             setDecoder_isSending();
+            carrierStopPending = true;
+            // Serial.println();
             return;
             break;
 
@@ -421,6 +728,91 @@ uint8_t IR_Encoder::bitLow[2] = {
     (bitPauseTakts / 2 + bitActiveTakts) * 2 - 1,
     (bitPauseTakts)-1};
 
+uint32_t IR_Encoder::calculateSendTime(uint8_t packSize) const
+{
+    // Расчет времени отправки пакета в миллисекундах
+    
+    // Время преамбулы: preambPulse * 2 фронта * bitTakts тактов
+    uint32_t preambTime = preambPulse * 2 * bitTakts;
+    
+    // Время данных: количество бит * bitTakts тактов
+    uint32_t dataTime = packSize * 8 * bitTakts;
+    
+    // Время синхронизации: syncBits * 2 фронта * bitTakts тактов
+    uint32_t syncTime = syncBits * 2 * bitTakts;
+    
+    // Общее время в тактах
+    uint32_t totalTakts = preambTime + dataTime + syncTime;
+    
+    // Конвертируем в миллисекунды
+    // carrierPeriod - период несущей в микросекундах
+    // totalTakts * carrierPeriod / 1000 = время в миллисекундах
+    uint32_t sendTimeMs = (totalTakts * carrierPeriod) / 1000;
+    
+    return sendTimeMs;
+}
+
+// Функции для тестирования времени отправки без фактической отправки
+
+uint32_t IR_Encoder::testSendTime(uint16_t addrTo, uint8_t dataByte, bool needAccept) const
+{
+    return testSendTime(addrTo, &dataByte, 1, needAccept);
+}
+
+uint32_t IR_Encoder::testSendTime(uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept) const
+{
+    return testSendTimeFULL(id, addrTo, data, len, needAccept);
+}
+
+uint32_t IR_Encoder::testSendTimeFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data, uint8_t len, bool needAccept) const
+{
+    if (len > bytePerPack)
+    {
+        return 0; // Возвращаем 0 для недопустимого размера
+    }
+    
+    uint8_t packSize = msgBytes + addrBytes + addrBytes + len + crcBytes;
+    return calculateSendTime(packSize);
+}
+
+uint32_t IR_Encoder::testSendAccept(uint16_t addrTo, uint8_t customByte) const
+{
+    constexpr uint8_t packsize = msgBytes + addrBytes + 1U + crcBytes;
+    return calculateSendTime(packsize);
+}
+
+uint32_t IR_Encoder::testSendRequest(uint16_t addrTo) const
+{
+    constexpr uint8_t packsize = msgBytes + addrBytes + addrBytes + crcBytes;
+    return calculateSendTime(packsize);
+}
+
+uint32_t IR_Encoder::testSendBack(uint8_t data) const
+{
+    return testSendBack(false, 0, &data, 1);
+}
+
+uint32_t IR_Encoder::testSendBack(uint8_t *data, uint8_t len) const
+{
+    return testSendBack(false, 0, data, len);
+}
+
+uint32_t IR_Encoder::testSendBackTo(uint16_t addrTo, uint8_t *data, uint8_t len) const
+{
+    return testSendBack(true, addrTo, data, len);
+}
+
+uint32_t IR_Encoder::testSendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len) const
+{
+    if (len > bytePerPack)
+    {
+        return 0; // Возвращаем 0 для недопустимого размера
+    }
+    
+    uint8_t packSize = msgBytes + addrBytes + (isAdressed ? addrBytes : 0) + min(uint8_t(1), len) + crcBytes;
+    return calculateSendTime(packSize);
+}
+
 // uint8_t* IR_Encoder::bitHigh = new uint8_t[2]{
 //         (bitPauseTakts) * 2 - 0,
 //         (bitActiveTakts) * 2 - 0};

IR_Encoder.h

@@ -3,12 +3,32 @@
 
 // TODO: Отложенная передача после завершения приема
 
+// Структура для возврата результата отправки
+struct IR_SendResult {
+    bool success;           // Флаг успешности отправки
+    uint32_t sendTimeMs;    // Время отправки пакета в миллисекундах
+    
+    IR_SendResult(bool success = false, uint32_t sendTimeMs = 0) 
+        : success(success), sendTimeMs(sendTimeMs) {}
+};
+
 class IR_DecoderRaw;
 class IR_Encoder : public IR_FOX
 {
     friend IR_DecoderRaw;
-
+    static IR_Encoder *head;
+    static IR_Encoder *last;
+    IR_Encoder *next;
 public:
+    static HardwareTimer* IR_Timer;
+
+    struct IR_TxGateRun {
+        uint16_t lenTicks; // number of timer ticks at carrierFrec*2
+        bool gate;         // true: carrier enabled (output toggles), false: silent (output forced low)
+    };
+
+    using ExternalTxBusyFn = bool (*)(void *ctx);
+    using ExternalTxStartFn = bool (*)(void *ctx, IR_Encoder *enc, const uint8_t *packet, uint8_t len);
 private:
     // uint16_t id; /// @brief Адрес передатчика
 public:
@@ -18,6 +38,21 @@ public:
     /// @param decPair Приёмник, для которого отключается приём в момент передачи передатчиком
     IR_Encoder(uint8_t pin, uint16_t addr = 0, IR_DecoderRaw *decPair = nullptr, bool autoHandle = true);
     static void isr();
+    static void begin(HardwareTimer* timer, uint8_t channel, IRQn_Type IRQn, uint8_t priority, void(*isrCallback)() = nullptr);
+    /** Configure timer frequency for TX clock (carrierFrec*2) without attaching ISR. */
+    static void beginClockOnly(HardwareTimer *timer);
+    static HardwareTimer* get_IR_Timer();
+    /** Call from main loop/tick: if ISR requested carrier stop, pause timer here (not in ISR). */
+    static void tick();
+
+    /** Optional: register external TX backend (e.g. DMA driver). */
+    static void setExternalTxBackend(ExternalTxStartFn startFn, ExternalTxBusyFn busyFn, void *ctx);
+
+    /** Called by external TX backend on actual end of transmission. */
+    void externalFinishSend();
+
+    /** Build RLE runs of carrier gate for a packet (no HW access). */
+    static size_t buildGateRuns(const uint8_t *packet, uint8_t len, IR_TxGateRun *outRuns, size_t maxRuns);
 
     void enable();
     void disable();
@@ -25,30 +60,50 @@ public:
     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 sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false);
+    IR_SendResult sendData(uint16_t addrTo, uint8_t dataByte, bool needAccept = false);
+    IR_SendResult sendData(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false);
+    IR_SendResult sendDataFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false);
 
 
-    void sendAccept(uint16_t addrTo, uint8_t customByte = 0);
-    void sendRequest(uint16_t addrTo);
+    IR_SendResult sendAccept(uint16_t addrTo, uint8_t customByte = 0);
+    IR_SendResult sendRequest(uint16_t addrTo);
 
-    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);
+    IR_SendResult sendBack(uint8_t data);
+    IR_SendResult sendBack(uint8_t *data = nullptr, uint8_t len = 0);
+    IR_SendResult sendBackTo(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0);
+
+    // Функция для тестирования времени отправки без фактической отправки
+    uint32_t testSendTime(uint16_t addrTo, uint8_t dataByte, bool needAccept = false) const;
+    uint32_t testSendTime(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false) const;
+    uint32_t testSendTimeFULL(uint16_t addrFrom, uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0, bool needAccept = false) const;
+    uint32_t testSendAccept(uint16_t addrTo, uint8_t customByte = 0) const;
+    uint32_t testSendRequest(uint16_t addrTo) const;
+    uint32_t testSendBack(uint8_t data) const;
+    uint32_t testSendBack(uint8_t *data = nullptr, uint8_t len = 0) const;
+    uint32_t testSendBackTo(uint16_t addrTo, uint8_t *data = nullptr, uint8_t len = 0) const;
+
+    inline bool isBusy() const { return isSending;}
 
 
     ~IR_Encoder();
     volatile bool ir_out_virtual;
 
-private:
-    static std::list<IR_Encoder*>& get_enc_list();
-    void _sendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len);
     void _isr();
+private:
+    static volatile bool carrierStopPending;
+    static void carrierResume();
+    static void carrierPauseIfIdle();
+
+    static ExternalTxStartFn externalTxStartFn;
+    static ExternalTxBusyFn externalTxBusyFn;
+    static void *externalTxCtx;
+    IR_SendResult _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);
+    uint32_t calculateSendTime(uint8_t packSize) const;
+    uint32_t testSendBack(bool isAdressed, uint16_t addrTo, uint8_t *data, uint8_t len) const;
     void send_HIGH(bool = 1);
     void send_LOW();
     void send_EMPTY(uint8_t count);
@@ -91,4 +146,3 @@ private:
     uint8_t *currentBitSequence = bitLow;
     volatile SignalPart signal;
 };
-

IR_config.cpp

@@ -4,7 +4,6 @@ void IR_FOX::setPin(uint8_t pin){
     this->pin = pin;
     port = digitalPinToPort(pin);
     mask = digitalPinToBitMask(pin);
-    pinMode(pin, INPUT_PULLUP);
 }
 
 void IR_FOX::checkAddressRuleApply(uint16_t address, uint16_t id, bool &flag)

IR_config.h

@@ -15,7 +15,7 @@
     IR_MSG_ACCEPT с адреса 0 воспринимается всеми устройствами
 */ 
 //**** Контрольные точки ******
-#define IR_MAX_ADDR_CPU 64999
+#define IR_MAX_ADDR_CPU 63999
 #define IR_MIN_ADDR_CPU 32000
 
 // //***** Группы машинок ********
@@ -28,11 +28,11 @@
 
 //********* Машинки ***********
 #define IR_MAX_CAR 31999
-#define IR_MIN_CAR 100
+#define IR_MIN_CAR 1
 
 //***** Пульты управления *****
-#define IR_MAX_CONTROLLER 99
-#define IR_MIN_CONTROLLER 0
+#define IR_MAX_CONTROLLER 64999
+#define IR_MIN_CONTROLLER 64000
 /*
 
 /```````````````````````````````````````````````` data pack `````````````````````````````````````````````\                                  
@@ -52,14 +52,14 @@ msg type:
                                         //  | 01234567 |
                                         //   ----------
                                         //  | xxx..... | = тип сообщения
-                                        //  | ...xxxxx | = длина (максимум 31 бита)
+                                        //  | ...xxxxx | = длина (максимум 31 бита) - не больше 24 байт на тело пакета
                                         //   ---------- */
 #define IR_MSG_BACK 0U          //  | 000...... | = Задний сигнал машинки
 #define IR_MSG_ACCEPT 1U        //  | 001..... | = подтверждение
 #define IR_MSG_REQUEST 2U       //  | 010..... | = запрос
-#define IR_MSG_ 3U              //  | 011..... | = ??
+// #define IR_MSG_ 3U           //  | 011..... | = ??
 #define IR_MSG_BACK_TO 4U       //  | 100..... | = Задний сигнал машинки c адресацией
-#define IR_MSG_ 5U              //  | 101..... | = ??
+// #define IR_MSG_ 5U           //  | 101..... | = ??
 #define IR_MSG_DATA_NOACCEPT 6U //  | 110..... | = данные, не требующие подтверждения
 #define IR_MSG_DATA_ACCEPT 7U   //  | 111..... | = данные требующие подтверждения
 ;                               /*                                     //   ----------
@@ -116,13 +116,13 @@ msg type:
 typedef uint16_t crc_t;
 
 // #define BRUTEFORCE_CHECK                            // Перепроверяет пакет на 1 битные ошибки //TODO: зависает
-#define bytePerPack 16 // колличество байтов в пакете
+#define bytePerPack (31) // колличество байтов в пакете
 #ifndef freeFrec
 #define freeFrec false
 #endif
 
 #ifndef subBufferSize
-#define subBufferSize 50 // Буфер для складирования фронтов, пока их не обработают (передатчик)
+#define subBufferSize 250 // Буфер для складирования фронтов, пока их не обработают (передатчик)
 #endif
 
 #define preambPulse 3
@@ -201,6 +201,8 @@ public:
     static void checkAddressRuleApply(uint16_t address, uint16_t id, bool &flag);
     void setPin(uint8_t pin);
     inline uint8_t getPin() { return pin; };
+    inline GPIO_TypeDef *getPort() const { return port; }
+    inline uint16_t getPinMask() const { return mask; }
 
 protected:
     uint16_t id;