diff --git a/Inc/LoggerToSerialPort.h b/Inc/LoggerToSerialPort.h
index c8412d1..1cd50f9 100644
--- a/Inc/LoggerToSerialPort.h
+++ b/Inc/LoggerToSerialPort.h
@@ -17,6 +17,18 @@ typedef struct {
 
 } tLoggerDataBuf;
 
+typedef struct __attribute__((packed)) {
+    uint8_t  start_pkt;      // 0x02
+    uint8_t type_pkt;
+    uint8_t len_pkt;
+    uint32_t timestamp;
+    uint8_t channel;
+    uint8_t  flags;
+    uint8_t  dlc;
+    uint32_t id;
+    uint8_t  data[8];    // максимум 8 байт
+} CanLogPacket_t;
+
 typedef struct {
     tSerialPortIO *serialPortIo_VIRT;
     tSerialPortIO *serialPortIo_PHYSIC;
@@ -35,6 +47,8 @@ typedef struct {
     uint8_t bufLoggerNames[MAX_COUNT_BUF_LOG][MAX_LEN_BUF_NAME_LOG];
     uint8_t countBufLoggerNames;
 
+    uint8_t bufLoggerCan[32];
+
     osMutexId_t access;
 
     struct {
diff --git a/Src/LoggerToSerialPort.c b/Src/LoggerToSerialPort.c
index 6bbf559..052cabc 100644
--- a/Src/LoggerToSerialPort.c
+++ b/Src/LoggerToSerialPort.c
@@ -122,6 +122,68 @@ static uint32_t LoggerToSerialPort_PrintLegend(
     return strLen;
 }
 
+#include <stddef.h>   // для offsetof
+
+static void LoggerCanToSerialPort_Logging(
+        tLoggerToSerialPort *env,
+        uint16_t mChannel,
+        uint8_t mFlags,
+        uint8_t mDLC,
+        uint32_t mID,
+        uint8_t *mData,
+        uint32_t timestamp
+) {
+    if (osMutexAcquire(env->access, env->timeout) == osOK) {
+        CanLogPacket_t *pkt = (CanLogPacket_t*)env->bufLoggerCan;
+
+        // Заполняем структуру
+        pkt->start_pkt = 0x02;
+        pkt->type_pkt  = 1;
+        pkt->timestamp = timestamp;
+        pkt->channel   = mChannel;
+        pkt->flags     = mFlags;
+        pkt->dlc       = mDLC;
+        pkt->id        = mID;
+
+        // Копируем данные (только mDLC байт)
+        if (mData != NULL && mDLC > 0) {
+            memcpy(pkt->data, mData, mDLC);
+        }
+        // Остальные байты data[8] не трогаем – они не будут отправлены
+
+        // Вычисляем len_pkt = полезная нагрузка (без start, type, len, end)
+        pkt->len_pkt = (4 + 1 + 1  + 4 + mDLC + 1);   // = mDLC + 11 (без CRC)
+
+        // Размер данных без завершающих байтов (CRC и 0x03)
+        size_t data_size = offsetof(CanLogPacket_t, data) + mDLC; // от начала пакета до конца данных
+
+        // Вычисляем CRC как сумму всех байтов, кроме pkt->start_pkt,
+        // т.е. начиная с type_pkt и заканчивая последним байтом данных
+        uint8_t crc = 0;
+        uint8_t *crc_start = (uint8_t*)pkt + 1;          // пропускаем start_pkt
+        size_t crc_len = data_size - 1;                  // размер данных для CRC (без start_pkt)
+        for (size_t i = 0; i < crc_len; i++) {
+            crc += crc_start[i];
+        }
+
+        // Записываем CRC после данных
+        uint8_t *crc_ptr = (uint8_t*)pkt + data_size;
+        *crc_ptr = crc;
+
+        // Записываем байт 0x03 после CRC
+        uint8_t *end_ptr = (uint8_t*)pkt + data_size + 1;
+        *end_ptr = 0x03;
+
+        // Размер для отправки: от начала до 0x03 включительно
+        size_t pkt_size = data_size + 2; // данные + CRC + 0x03
+
+        // Отправка
+        SerialPortTransmit(env->serialPortIo_VIRT, env->bufLoggerCan, pkt_size, env->timeout);
+
+        osMutexRelease(env->access);
+    }
+}
+
 static void LoggerToSerialPort_Logging(
         tLoggerToSerialPort *env,
         char *authorStatic,
@@ -139,7 +201,6 @@ static void LoggerToSerialPort_Logging(
 //    if (adr < PERIPH_BASE) {
 //        env->timeout = 0;
 //    }
-
     char *outStr = NULL;
     uint32_t lenStr;
 
@@ -193,6 +254,9 @@ void LoggerToSerialPort_Init(
     env->logger.env = env;
     env->greenwichOffset = greenwichOffset;
     env->logger.logging = (LoggerGenericMethod) LoggerToSerialPort_Logging;
+
+    env->logger.loggingCan = (LoggerGenericCanMethod) LoggerCanToSerialPort_Logging;
+
     env->logger.getMemPrintfBufLog = (getMemPrintfBufLogMethod) getMemLoggerBufLog;
     env->rtc = rtc;
     env->flags = flags;