Обновление

Inc/CanSerialPortFrameTP.h

@@ -18,6 +18,8 @@
 
 #define WAIT_FRAME_WRITE 1000
 
+#define LEN_DEBUG_TP_BUFF 128
+
 typedef enum {
     TP_TYPE_FRAME_SF = 0,
     TP_TYPE_FRAME_FF = 1,
@@ -90,7 +92,7 @@ typedef bool (*tReceivedCan_func)(void *arg, can_rx_message_type *data);
 typedef struct {
     tSerialPortFrameIO *ioCanFrame;
     tLoggerInterface *logger;
-    char hexString[2048 * 2];
+    char hexString[LEN_DEBUG_TP_BUFF];
     volatile bool isFlowControl;
 
     uint32_t timeoutFF;

Src/CanSerialPortFrameTP.c

@@ -7,17 +7,89 @@
 #include "AsciiStringAssmeblingUtils.h"
 #include "SystemMutexCmsis.h"
 #include "CanPorts.h"
+#include <stdio.h>
 
 #define LOG_SIGN "CAN_TP"
 #define LOGGER env->logger
 
 
-char *sendLogCanHex(tCanSerialPortFrameTp *env, uint8_t *data, size_t size) {
+static char strPrintfDebug_TP[80];
+
+static void PrintfDebug(uint8_t *data, uint8_t dlc) {
+
+    switch (dlc) {
+
+        case 0:
+            sprintf(strPrintfDebug_TP, " ");
+            break;
+        case 1:
+            sprintf(strPrintfDebug_TP, "%02X", data[0]);
+            break;
+        case 2:
+            sprintf(strPrintfDebug_TP, "%02X:%02X", data[0], data[1]);
+            break;
+        case 3:
+            sprintf(strPrintfDebug_TP, "%02X:%02X:%02X", data[0], data[1], data[2]);
+            break;
+        case 4:
+            sprintf(strPrintfDebug_TP, "%02X:%02X:%02X:%02X", data[0], data[1], data[2], data[3]);
+            break;
+        case 5:
+            sprintf(strPrintfDebug_TP, "%02X:%02X:%02X:%02X:%02X", data[0], data[1], data[2], data[3],
+                    data[4]);
+            break;
+        case 6:
+            sprintf(strPrintfDebug_TP, "%02X:%02X:%02X:%02X:%02X:%02X", data[0], data[1], data[2], data[3],
+                    data[4], data[5]);
+            break;
+        case 7:
+            sprintf(strPrintfDebug_TP, "%02X:%02X:%02X:%02X:%02X:%02X:%02X", data[0], data[1], data[2],
+                    data[3], data[4],
+                    data[5], data[6]);
+            break;
+        case 8:
+            sprintf(strPrintfDebug_TP, "%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X ", data[0], data[1],
+                    data[2], data[3], data[4],
+                    data[5], data[6], data[7]);
+            break;
+        default:
+            sprintf(strPrintfDebug_TP, " ");
+    }
+
+}
+
+
+char *sendLogCanTpHex(tCanSerialPortFrameTp *env, uint8_t *data, size_t size) {
     memset(env->hexString, 0, sizeof(env->hexString));
     size_t len = 0;
-    vAsciiStringAddBytesAsHex(env->hexString, &len, data, size);
 
-    LoggerStrInfo(LOGGER, LOG_SIGN, env->hexString, strlen(env->hexString));
+
+    uint8_t full = size / 8;
+    uint8_t tail = size % 8;
+
+    for (uint8_t i = 0; i < full; ++i) {
+        PrintfDebug(&data[i * 8], 8);
+
+        if ((len + strlen(strPrintfDebug_TP))  < LEN_DEBUG_TP_BUFF) {
+            len += strlen(strPrintfDebug_TP);
+            memcpy(env->hexString, strPrintfDebug_TP, strlen(strPrintfDebug_TP));
+        } else {
+            return env->hexString;
+        }
+
+    }
+
+    if (tail > 0) {
+        PrintfDebug(&data[full * 8], tail);
+
+        if ((len + strlen(strPrintfDebug_TP))  < LEN_DEBUG_TP_BUFF) {
+            len += strlen(strPrintfDebug_TP);
+            memcpy(env->hexString, strPrintfDebug_TP, strlen(strPrintfDebug_TP));
+        } else {
+            return env->hexString;
+        }
+
+    }
 
     return env->hexString;
 }
@@ -328,52 +400,52 @@ _Noreturn void CanTpProcessing_ListenerTask(tCanSerialPortFrameTp *env) {
         if (result == TP_RECEIVED_FC_DATA) {
             if (env->isFlowControl) {
                 env->isFlowControl = false;
-                LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Принят Flow control Frame");
+                LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Flow control frame accepted");
             } else {
-                LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Принят не ожидаемый Flow control Frame");
+                LoggerErrorStatic(LOGGER, LOG_SIGN, "Error: An unexpected Flow Control Frame was received");
             }
         }
 
         if (result == TP_RECEIVED_DATA) {
-            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Приняты данные: ");
+            //sendLogCanTpHex(env, env->dataBuf->data, env->dataBuf->len);
-            sendLogCanHex(env, env->dataBuf->data, env->dataBuf->len);
+            //LoggerFormatInfo(LOGGER, LOG_SIGN, "Data received: %s", env->hexString)
 
             env->receivedTP_func(env->callback_argTp, env->dataBuf);
 
         }
 
         if (result == TP_ERROR_FS_ERROR_SIZE) {
-            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка. Переполнение приемного буфера (1)");
+            LoggerErrorStatic(LOGGER, LOG_SIGN, "Error: Receive buffer overflow (1)");
         }
 
         if (result == TP_ERROR_FC_ERROR) {
-            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка. Выставлен статус ошибки в Flow control Frame");
+            LoggerErrorStatic(LOGGER, LOG_SIGN, "Error: An error status was set in the Flow Control Frame");
         }
 
         if (result == TP_ERROR_FF_ERROR) {
-            LoggerStrInfoStatic(LOGGER, LOG_SIGN,
+            LoggerErrorStatic(LOGGER, LOG_SIGN,
-                                "Ошибка. Принят First Frame FF, но еще не завершен прием Consecutive Frame");
+                              "Error: First Frame FF received, but Consecutive Frame reception is not yet complete");
         }
 
 
         if (result == TP_ERROR_FF_ERROR_SIZE) {
-            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка. Переполнение приемного буфера (2)");
+            LoggerErrorStatic(LOGGER, LOG_SIGN, "Error: Receive buffer overflow (2)");
         }
 
         if (result == TP_ERROR_CF_ERROR) {
-            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка. Принят не ожидаемый Consecutive Frame");
+            LoggerErrorStatic(LOGGER, LOG_SIGN, "Error: Unexpected Consecutive Frame received");
         }
 
         if (result == TP_ERROR_CF_ERROR_SIZE) {
-            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка. Переполнение приемного буфера (3)");
+            LoggerErrorStatic(LOGGER, LOG_SIGN, "Error: Receive buffer overflow (3)");
         }
 
         if (result == TP_ERROR_CF_ERROR_SN) {
-            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Ошибка. Не совпадение счетчика SN в Consecutive Frame");
+            LoggerErrorStatic(LOGGER, LOG_SIGN, "Error: SN counter mismatch in Consecutive Frame");
         }
 
         if (result == TP_ERROR_FF_ERROR_TIMEOUT) {
-            LoggerStrInfoStatic(LOGGER, LOG_SIGN, "Истекло время ожидания приема Consecutive Frame");
+            LoggerErrorStatic(LOGGER, LOG_SIGN, "Error: The Consecutive Frame timed out");
         }
     }
 }