debug startRX and m

IR_Decoder.cpp

@@ -1,6 +1,8 @@
 #include "IR_Decoder.h"
 #include "IR_Encoder.h"
 
+// #define IRDEBUG_INFO
+
 #define checkAddr(h, l) (\
     ((uint16_t)((dataBuffer[h] << 8) | dataBuffer[l]) == addrSelf) || \
     ((uint16_t)((dataBuffer[h] << 8) | dataBuffer[l]) >= IR_Broadcast)\
@@ -31,9 +33,11 @@ void IR_Decoder::isr() {
     } else {
         if (firstUnHandledFront == &subBuffer[currentSubBufferIndex]) { // Если контроллер не успел обработать новый сигнал, принудительно пропускаем его
             firstUnHandledFront = firstUnHandledFront->next;
+            #ifdef IRDEBUG_INFO
             // Serial.println();
             // Serial.println("ERROR");
             // Serial.println();
+            #endif
         }
     }
 
@@ -50,6 +54,36 @@ void IR_Decoder::isr() {
 
 ////////////////////////////////////////////////////////////////////////////////////
 
+void IR_Decoder::start_RX() {
+
+    #ifdef IRDEBUG_INFO
+    Serial.print("\n>");
+    #endif
+
+    errors.reset();
+
+    isBufferOverflow = false;
+    isCrcCorrect = false;
+    bufBitPos = 0;
+    isData = true;
+    i_dataBuffer = 0;
+    nextControlBit = bitPerByte;
+    i_syncBit = 0;
+    isWrongPack = false;
+
+    isPreamb = true;
+    riseSyncTime = bitTime  /* 1100 */;
+
+    memset(dataBuffer, 0x00, dataByteSizeMax);
+}
+
+void IR_Decoder::listen() {
+    if (isRecive && ((micros() - prevRise) > IR_timeout)) {
+        isRecive = false; 
+        start_RX();
+    }
+}
+
 void IR_Decoder::tick() {
     listen();
     if (firstUnHandledFront == nullptr) return; //Если данных нет - ничего не делаем
@@ -61,15 +95,12 @@ void IR_Decoder::tick() {
     interrupts();
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    if (currentFront.time - prevRise > IR_timeout) {  // первый 
+    if (currentFront.time - prevRise > IR_timeout * 2 /* && !isRecive */) {  // первый 
-        errors.reset();
-        isRecive = true;
-        isPreamb = true;
-
-        riseSyncTime = bitTime  /* 1100 */;
-        start_RX();
         preambFrontCounter = preambFronts - 1U;
-
+       
+        if (!currentFront.dir) {
+            isRecive = true;
+        }
     }
 
     if (preambFrontCounter > 0) {     // в преамбуле
@@ -240,33 +271,12 @@ void IR_Decoder::tick() {
     firstUnHandledFront = firstUnHandledFront->next;  //переместить флаг на следующий элемент для обработки (next or nullptr)
 }
 
-void IR_Decoder::listen() {
-    if (isRecive && micros() - prevRise > IR_timeout * 2) {
-        isRecive = false;
-    }
-}
-
-void IR_Decoder::start_RX() {
-    // Serial.println();
-    // Serial.println(printBytes(dataBuffer, dataByteSizeMax-1, BIN));
-    // Serial.println();
-
-
-    resetAvaliable();
-    isBufferOverflow = false;
-    memset(dataBuffer, 0x00, dataByteSizeMax);
-
-    bufBitPos = 0;
-    isData = true;
-    i_dataBuffer = 0;
-    nextControlBit = bitPerByte;
-    i_syncBit = 0;
-    isWrongPack = false;
-}
-
 void IR_Decoder::writeToBuffer(bool bit) {
-    if (i_dataBuffer >= dataByteSizeMax * 8 - 1) {// проверка переполнения
+    if (i_dataBuffer > dataByteSizeMax * 8) {// проверка переполнения
         //TODO: Буффер переполнен!
+        #ifdef IRDEBUG_INFO
+        Serial.println("OverBuf");
+        #endif
         isBufferOverflow = true;
     }
     if (isBufferOverflow || isPreamb || isWrongPack) return;
@@ -277,12 +287,16 @@ void IR_Decoder::writeToBuffer(bool bit) {
         isData = !isData;
         i_syncBit = 0; // сброс счетчика битов синхронизации 
         err_syncBit = 0; // сброс счетчика ошибок синхронизации 
-        // Serial.print(" ");
+        #ifdef IRDEBUG_INFO
+        Serial.print(" ");
+        #endif
     }
 
 
     if (isData) { // Запись битов в dataBuffer
-        // Serial.print(bit);
+        #ifdef IRDEBUG_INFO
+        Serial.print(bit);
+        #endif
 
         if (i_dataBuffer % 8 == 7) {
             // Serial.print("+");
@@ -312,8 +326,10 @@ void IR_Decoder::writeToBuffer(bool bit) {
             i_syncBit++;
         }
         ////////////////////// Проверка наличия битов синхранизации //////////////////////
-        isWrongPack = err_syncBit >= syncBits;
+        isWrongPack = (err_syncBit >= syncBits);
-        // if (isWrongPack) Serial.print("****************");
+        #ifdef IRDEBUG_INFO
+        if (isWrongPack) Serial.print("****************");
+        #endif
     }//**************************************************************************************************//
 
     // Serial.print(bit);
@@ -324,12 +340,20 @@ void IR_Decoder::writeToBuffer(bool bit) {
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             //const auto testval = bufferBitSizeMax;
+    #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) * bitPerByte)) { Serial.print("  <-"); }
+    }
+    #endif
     if ((i_dataBuffer >= (8 * msgBytes)) && !isCrcCorrect) {
         uint16_t crcValue;
         switch ((dataBuffer[0] >> 5) & IR_MASK_MSG_TYPE) {
             case IR_MSG_ACCEPT:
                 if (i_dataBuffer >= ((msgBytes + addrBytes + crcBytes) * bitPerByte)) {
-                    const uint8_t dataSize = msgBytes + addrBytes;
+                    constexpr uint8_t dataSize = msgBytes + addrBytes;
                     isCrcCorrect = crcCheck(dataSize, crcValue);
                     if (isCrcCorrect && checkAddr(1, 2)) {
                         gotAccept._set(dataBuffer, msgBytes + addrBytes + crcBytes, crcValue, errors, riseSyncTime);
@@ -340,8 +364,8 @@ void IR_Decoder::writeToBuffer(bool bit) {
 
             case IR_MSG_REQUEST:
                 if (i_dataBuffer >= ((msgBytes + addrBytes + addrBytes + crcBytes) * bitPerByte)) {
-                    const uint8_t dataSize = msgBytes + addrBytes + addrBytes;
+                    constexpr uint8_t dataSize = msgBytes + addrBytes + addrBytes;
-                    isCrcCorrect = (crcCheck(dataSize, crcValue));
+                    isCrcCorrect = crcCheck(dataSize, crcValue);
                     if (isCrcCorrect && checkAddr(3, 4)) {
                         gotRequest._isAvaliable = true;
                         gotRequest._set(dataBuffer, msgBytes + addrBytes + addrBytes + crcBytes, crcValue, errors, riseSyncTime);
@@ -353,15 +377,23 @@ void IR_Decoder::writeToBuffer(bool bit) {
             case IR_MSG_DATA_ACCEPT:
             case IR_MSG_DATA_NOACCEPT:
                 if (i_dataBuffer >= ((dataBuffer[0] & IR_MASK_MSG_INFO) + crcBytes) * bitPerByte) {
-                    // Serial.println("OK");
+                    #ifdef IRDEBUG_INFO
+                    Serial.print(" IN ");
+                    #endif
                     const uint8_t dataSize = (dataBuffer[0] & IR_MASK_MSG_INFO);
                     isCrcCorrect = crcCheck(dataSize, crcValue);
                     if (isCrcCorrect && checkAddr(3, 4)) {
+                        #ifdef IRDEBUG_INFO
+                        Serial.println(" OK ");
+                        #endif
                         gotData._isAvaliable = true;
                         gotData._set(dataBuffer, (dataSize)+crcBytes, crcValue, errors, riseSyncTime);
                     } else {
                         gotRawData._isAvaliable = true;
                         gotRawData._set(dataBuffer, (dataSize)+crcBytes, crcValue, errors, riseSyncTime);
+                        #ifdef IRDEBUG_INFO
+                        Serial.println(" NOT OK ");
+                        #endif
                     }
                 }
                 break;
@@ -392,10 +424,6 @@ bool IR_Decoder::crcCheck(uint8_t len, crc_t& crc) {
     return crcOK;
 }
 
-void IR_Decoder::resetAvaliable() {
-    isCrcCorrect = false;
-}
-
 uint16_t IR_Decoder::ceil_div(uint16_t val, uint16_t divider) {
     int ret = val / divider;
     if ((val << 4) / divider - (ret << 4) >= 8)

IR_Decoder.h

@@ -190,10 +190,10 @@ public:
     /// @brief Контейнер с информацией подстройки
     RawTune gotTune;
 
+    const uint8_t isrPin; // Пин прерывания 
 
 private:
 
-    const uint8_t isrPin; // Пин прерывания 
 
     IR_Encoder* encoder;                    // Указатель на парный передатчик
     volatile uint16_t isPairSending = 0;    // Флаг передачи парного передатчика
@@ -261,8 +261,6 @@ private:
 
     /// @brief Установка и сброс начальных значений и флагов в готовность к приёму данных
     void start_RX();
-    /// @brief Сброс флагов доступности данных
-    void resetAvaliable();
 
     /// @brief Целочисленное деление с округлением вверх
     /// @param val Значение

IR_Encoder.cpp

@@ -31,6 +31,7 @@ IR_Encoder::~IR_Encoder() {
 };
 
 void IR_Encoder::sendData(uint16_t addrTo, uint8_t* data, uint8_t len, bool needAccept = false) {
+    if (len > bytePerPack) { return; }
     constexpr uint8_t dataStart = msgBytes + addrBytes + addrBytes;
     memset(sendBuffer, 0x00, dataByteSizeMax);
     uint8_t packSize = msgBytes + addrBytes + addrBytes + len + crcBytes;
@@ -122,14 +123,10 @@ void IR_Encoder::rawSend(uint8_t* ptr, uint8_t len) {
         return;
     }
 
-
-
-    sendLen = len;
-
     setDecoder_isSending();
 
-
     cli();
+    sendLen = len;
     toggleCounter = preambToggle; // Первая генерация для первого signal
 
     dataBitCounter = bitPerByte - 1;

IR_Encoder.h

@@ -6,7 +6,6 @@
 class IR_Decoder;
 class IR_Encoder : IR_FOX {
     friend IR_Decoder;
-    friend void isr(IR_Encoder& e);
 public:
     uint16_t id;      /// @brief Адрес передатчика
 
@@ -35,7 +34,7 @@ public:
         TCCR2B |= (1 << CS20);               // Предделитель 1
         TIMSK2 |= (1 << OCIE2A);             // Прерывание по совпадению
         #if F_CPU == 16000000
-        OCR2A = /* 465 */((F_CPU / (38000*2)) - 2); //38кГц
+        OCR2A = /* 465 */((F_CPU / (38000 * 2)) - 2); //38кГц
         #elif F_CPU == 8000000
         OCR2A = ((F_CPU / (38000 * 2)) - 2); //38кГц Частота_мк / (Предделитель * Частота * 2)
         #endif
@@ -56,7 +55,6 @@ public:
     volatile bool ir_out_virtual;
 private:
     void IR_Encoder::setDecoder_isSending();
-    void _sendData(uint16_t addrTo, uint8_t* data, uint8_t len, uint8_t msgType);
     void sendByte(uint8_t byte, bool* prev, bool LOW_FIRST);
     void addSync(bool* prev, bool* next);
     void send_HIGH(bool = 1);

IR_config.h

@@ -39,16 +39,16 @@ msg type:
                                         //  | xxx..... | = тип сообщения
                                         //  | ...xxxxx | = длина (максимум 32 бита)
                                         //   ---------- */
-#define IR_MSG_                      0U //  | 000..... | =  = ??
+#define IR_MSG_                      0U //  | 000..... | = Задний сигнал машинки
-#define IR_MSG_ACCEPT                1U //  | 001..... | = */  /* = подтверждение 
+#define IR_MSG_ACCEPT                1U //  | 001..... | = подтверждение 
-#define IR_MSG_REQUEST               2U //  | 010..... | = */  /* = запрос
+#define IR_MSG_REQUEST               2U //  | 010..... | = запрос
-#define IR_MSG_                      3U //  | 011..... | = */ /* = ??
+#define IR_MSG_                      3U //  | 011..... | = ??
-#define IR_MSG_                      4U //  | 100..... | = */  /* = ??
+#define IR_MSG_                      4U //  | 100..... | = ??
-#define IR_MSG_                      5U //  | 101..... | = */  /* = ??
+#define IR_MSG_                      5U //  | 101..... | = ??
-#define IR_MSG_DATA_NOACCEPT         6U //  | 110..... | = */  /* = данные, не требующие подтверждения
+#define IR_MSG_DATA_NOACCEPT         6U //  | 110..... | = данные, не требующие подтверждения
-                                        //                                      //  | \\\xxxxx | =  = L длина данных
+;//                                     //  | \\\xxxxx | =    длина данных
-#define IR_MSG_DATA_ACCEPT           7U //  | 111..... | = */  /* = данные требующие подтверждения
+#define IR_MSG_DATA_ACCEPT           7U //  | 111..... | = данные требующие подтверждения
-//                                      //  | \\\xxxxx | =  = L длина данных
+;//                                     //  | \\\xxxxx | =    длина данных
 /*                                      //   ----------
 
 /```````````````````` подтверждение ```````````````````\      /``````````````````````````````````````` запрос ``````````````````````````````````\
@@ -72,7 +72,7 @@ msg type:
 /////////////////////////////////////////////////////////////////////////////////////*/
 typedef uint16_t crc_t;
 
-#define bytePerPack 3                              // колличество байтов в пакете
+#define bytePerPack 16                              // колличество байтов в пакете
 #ifndef freeFrec
 #define freeFrec true
 #endif