Переименование Protocan в Setcan

Core/Inc/main.h

@@ -31,7 +31,7 @@ extern "C" {
 
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
-#include "protocan.h"
+#include "setcan.h"
 #include "canerrorbox.h"
 /* USER CODE END Includes */
 

Core/Inc/setcan.h

@@ -1,5 +1,5 @@
-#ifndef _protocan
+#ifndef _SETCAN
-#define _protocan
+#define _SETCAN
 #include "main.h"
 #include "can.h"
 
@@ -24,7 +24,7 @@
 #define CURRENT_ID_DEVICE 0b0010
 #endif
 
-#define PROTOCAN_RX_BUFFER_SIZE 128
+#define SETCAN_RX_BUFFER_SIZE 128
 
 #define SensorToModbusRegister(SensorType, SensorID) SensorType << 11 | SensorID
 #define HighByteOfWord(WORD) (WORD>>8)&0xFF
@@ -37,11 +37,11 @@
  */
 typedef enum
 {
-  PROTOCAN_INIT_OK = 0x00U,            /**< Инициализация прошла успешно. */
+  SETCAN_INIT_OK = 0x00U,            /**< Инициализация прошла успешно. */
-  PROTOCAN_INIT_HCAN_ERROR = 0x01U,    /**< Ошибка при инициализации модуля CAN. */
+  SETCAN_INIT_HCAN_ERROR = 0x01U,    /**< Ошибка при инициализации модуля CAN. */
-  PROTOCAN_INIT_HRTC_ERROR = 0x02U,    /**< Ошибка при инициализации модуля RTC. */
+  SETCAN_INIT_HRTC_ERROR = 0x02U,    /**< Ошибка при инициализации модуля RTC. */
-  PROTOCAN_INIT_TIM_ERROR = 0x04U      /**< Ошибка при инициализации таймера. */
+  SETCAN_INIT_TIM_ERROR = 0x04U      /**< Ошибка при инициализации таймера. */
-} PROTOCAN_INIT_StatusTypeDef;
+} SETCAN_INIT_StatusTypeDef;
 
 /**
  * @brief Статус выполнения операции протокола CAN.
@@ -50,11 +50,11 @@ typedef enum
  */
 typedef enum
 {
-  PROTOCAN_OK       = 0x00U, /**< Операция прошла успешно. */
+  SETCAN_OK       = 0x00U, /**< Операция прошла успешно. */
-  PROTOCAN_ERROR    = 0x01U, /**< Обнаружена ошибка во время выполнения. */
+  SETCAN_ERROR    = 0x01U, /**< Обнаружена ошибка во время выполнения. */
-  PROTOCAN_BUSY     = 0x02U, /**< Канал занят, выполнение невозможно в данный момент. */
+  SETCAN_BUSY     = 0x02U, /**< Канал занят, выполнение невозможно в данный момент. */
-  PROTOCAN_TIMEOUT  = 0x03U  /**< Истек таймаут ожидания. */
+  SETCAN_TIMEOUT  = 0x03U  /**< Истек таймаут ожидания. */
-} PROTOCAN_StatusTypeDef;
+} SETCAN_StatusTypeDef;
 
 /**
  * @brief Уровень приоритета CAN-сообщения.
@@ -62,9 +62,9 @@ typedef enum
  * Это перечисление определяет важность и приоритет обработки сообщения.
  */
 typedef enum {
-	PROTOCAN_PRIORITY_CRITICAL = 0,   /**< Критический приоритет, рекомендуется обработка без задержек. */
+	SETCAN_PRIORITY_CRITICAL = 0,   /**< Критический приоритет, рекомендуется обработка без задержек. */
-	PROTOCAN_PRIORITY_STANDARD = 1    /**< Стандартный приоритет, менее важный. */
+	SETCAN_PRIORITY_STANDARD = 1    /**< Стандартный приоритет, менее важный. */
-} ProtoCanPriorityType;
+} SetCanPriorityType;
 
 /**
  * @brief Маршрут CAN-сообщения.
@@ -72,9 +72,9 @@ typedef enum {
  * Это перечисление задает направление маршрута отправки сообщения.
  */
 typedef enum {
-	PROTOCAN_ROUTE_FROM_PM = 0,      /**< Сообщение отправляется от управляющего модуля (PM). */
+	SETCAN_ROUTE_FROM_PM = 0,      /**< Сообщение отправляется от управляющего модуля (PM). */
-	PROTOCAN_ROUTE_FROM_DEVICE = 1   /**< Сообщение отправляется от устройства (Device). */
+	SETCAN_ROUTE_FROM_DEVICE = 1   /**< Сообщение отправляется от устройства (Device). */
-} ProtoCanRouteType;
+} SetCanRouteType;
 
 /**
  * @brief Типы сообщений CAN.
@@ -82,17 +82,17 @@ typedef enum {
  * Перечисление определяет различные типы сообщений, используемые в протоколе.
  */
 typedef enum {
-	PROTOCAN_MSGTYPE_BROADCAST = 0b0000,             /**< Широковещательное сообщение. */
+	SETCAN_MSGTYPE_BROADCAST = 0b0000,             /**< Широковещательное сообщение. */
-	PROTOCAN_MSGTYPE_DISCRETE = 0b0001,              /**< Дискретное цифровое сообщение. */
+	SETCAN_MSGTYPE_DISCRETE = 0b0001,              /**< Дискретное цифровое сообщение. */
-	PROTOCAN_MSGTYPE_ANALOG = 0b0010,                /**< Аналоговое сообщение. */
+	SETCAN_MSGTYPE_ANALOG = 0b0010,                /**< Аналоговое сообщение. */
-	PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE = 0b0011, /**< Сообщение общего адресного пространства. */
+	SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE = 0b0011, /**< Сообщение общего адресного пространства. */
-	PROTOCAN_MSGTYPE_MODBUS_COIL = 0b0100,           /**< Сообщение Modbus - Coil. */
+	SETCAN_MSGTYPE_MODBUS_COIL = 0b0100,           /**< Сообщение Modbus - Coil. */
-	PROTOCAN_MSGTYPE_MODBUS_DISCRETE = 0b0101,       /**< Сообщение Modbus - Discrete. */
+	SETCAN_MSGTYPE_MODBUS_DISCRETE = 0b0101,       /**< Сообщение Modbus - Discrete. */
-	PROTOCAN_MSGTYPE_MODBUS_HOLDING = 0b0110,        /**< Сообщение Modbus - Holding. */
+	SETCAN_MSGTYPE_MODBUS_HOLDING = 0b0110,        /**< Сообщение Modbus - Holding. */
-	PROTOCAN_MSGTYPE_MODBUS_INPUT = 0b0111,          /**< Сообщение Modbus - Input. */
+	SETCAN_MSGTYPE_MODBUS_INPUT = 0b0111,          /**< Сообщение Modbus - Input. */
-	PROTOCAN_MSGTYPE_ERROR = 0b1000,                 /**< Сообщение об ошибке. */
+	SETCAN_MSGTYPE_ERROR = 0b1000,                 /**< Сообщение об ошибке. */
-	PROTOCAN_MSGTYPE_PULSE = 0b1111,                 /**< Импульсное сообщение. */
+	SETCAN_MSGTYPE_PULSE = 0b1111,                 /**< Импульсное сообщение. */
-}ProtoCanMsgType;
+} SetCanMsgType;
 
 /**
  * @brief Типы широковещательных сообщений CAN.
@@ -100,12 +100,12 @@ typedef enum {
  * Перечисление задает различные типы широковещательных команд, используемых в протоколе.
  */
 typedef enum {
-	PROTOCAN_BROADCAST_STATUS = 0b000000000000,       /**< Статус устройства. */
+	SETCAN_BROADCAST_STATUS = 0b000000000000,       /**< Статус устройства. */
-	PROTOCAN_BROADCAST_ONOFF = 0b000000000001,        /**< Включение/выключение устройства. */
+	SETCAN_BROADCAST_ONOFF = 0b000000000001,        /**< Включение/выключение устройства. */
-	PROTOCAN_BROADCAST_RESTARTDEVICE = 0b000000000010, /**< Перезагрузка устройства. */
+	SETCAN_BROADCAST_RESTARTDEVICE = 0b000000000010, /**< Перезагрузка устройства. */
-	PROTOCAN_BROADCAST_RTCSETUP = 0b000000000011,      /**< Настройка RTC (часы реального времени). */
+	SETCAN_BROADCAST_RTCSETUP = 0b000000000011,      /**< Настройка RTC (часы реального времени). */
-	PROTOCAN_BROADCAST_END = 0b111111111111          /**< Конец диапазона широковещательных сообщений. */
+	SETCAN_BROADCAST_END = 0b111111111111          /**< Конец диапазона широковещательных сообщений. */
-}ProtoCanBroadcastType;
+} SetCanBroadcastType;
 
 /**
  * @brief Структура и представление широковещательного сообщения CAN.
@@ -115,7 +115,7 @@ typedef enum {
 typedef union{
     struct msgBody_Broadcast{
         unsigned Body:4; /**< Поле для дополнительных данных или кода задачи (4 бита). */
-        ProtoCanBroadcastType Type:12; /**< Тип широковещательного сообщения (12 бит). */
+        SetCanBroadcastType Type:12; /**< Тип широковещательного сообщения (12 бит). */
     } Fields; /**< Структура с разбивкой по полям. */
     unsigned Body; /**< Общее 16-битное представление сообщения. */
 } msgBodyBroadcastType;
@@ -126,15 +126,15 @@ typedef union{
  * Перечисление задает различные виды дискретных команд или событий.
  */
 typedef enum {
-	PROTOCAN_DISCRETE_ACCIDENT = 0b0000,                       /**< Аварийное состояние. */
+	SETCAN_DISCRETE_ACCIDENT = 0b0000,                       /**< Аварийное состояние. */
-	PROTOCAN_DISCRETE_WARNING = 0b0001,                        /**< Предупредительный сигнал. */
+	SETCAN_DISCRETE_WARNING = 0b0001,                        /**< Предупредительный сигнал. */
-	PROTOCAN_DISCRETE_CONTROL_SIGNALS = 0b0010,                /**< Управляющие сигналы. */
+	SETCAN_DISCRETE_CONTROL_SIGNALS = 0b0010,                /**< Управляющие сигналы. */
-	PROTOCAN_DISCRETE_FLAGS = 0b0011,                          /**< Флаги состояния. */
+	SETCAN_DISCRETE_FLAGS = 0b0011,                          /**< Флаги состояния. */
-	PROTOCAN_DISCRETE_RESET = 0b0100,                          /**< Сброс устройства. */
+	SETCAN_DISCRETE_RESET = 0b0100,                          /**< Сброс устройства. */
-	PROTOCAN_DISCRETE_CHANGE_MODE = 0b0101,                    /**< Смена режима работы. */
+	SETCAN_DISCRETE_CHANGE_MODE = 0b0101,                    /**< Смена режима работы. */
-	PROTOCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS = 0b0110,   /**< Запрос списка параметров. */
+	SETCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS = 0b0110,   /**< Запрос списка параметров. */
-	PROTOCAN_DISCRETE_END = 0b1111                              /**< Конец диапазона дискретных сообщений. */
+	SETCAN_DISCRETE_END = 0b1111                              /**< Конец диапазона дискретных сообщений. */
-}ProtoCanDiscreteType;
+} SetCanDiscreteType;
 
 /**
  * @brief Структура и представление дискретного сообщения CAN.
@@ -144,7 +144,7 @@ typedef enum {
 typedef union{
     struct msgBody_Discrete{
         unsigned Body:12; /**< Поле данных или кода (12 бит). */
-        ProtoCanDiscreteType Type:4; /**< Тип дискретного сообщения (4 бита). */
+        SetCanDiscreteType Type:4; /**< Тип дискретного сообщения (4 бита). */
     } Fields; /**< Структура с разбивкой по полям. */
     unsigned Body; /**< Общее 16-битное представление сообщения. */
 } msgBodyDiscreteType;
@@ -155,13 +155,13 @@ typedef union{
  * Перечисление определяет различные типы аналоговых данных или команд.
  */
 typedef enum {
-	PROTOCAN_ANALOG_UNIVERSAL = 0b0000,    /**< Универсальный тип. */
+	SETCAN_ANALOG_UNIVERSAL = 0b0000,    /**< Универсальный тип. */
-	PROTOCAN_ANALOG_SETTINGS = 0b0001,     /**< Настройки. */
+	SETCAN_ANALOG_SETTINGS = 0b0001,     /**< Настройки. */
-	PROTOCAN_ANALOG_U = 0b0010,            /**< Напряжение (U). */
+	SETCAN_ANALOG_U = 0b0010,            /**< Напряжение (U). */
-	PROTOCAN_ANALOG_I = 0b0011,            /**< Ток (I). */
+	SETCAN_ANALOG_I = 0b0011,            /**< Ток (I). */
-	PROTOCAN_ANALOG_T = 0b0100,            /**< Температура (T). */
+	SETCAN_ANALOG_T = 0b0100,            /**< Температура (T). */
-	PROTOCAN_ANALOG_END = 0b1111           /**< Конец диапазона типов. */
+	SETCAN_ANALOG_END = 0b1111           /**< Конец диапазона типов. */
-}ProtoCanAnalogType;
+} SetCanAnalogType;
 
 /**
  * @brief Структура и представление аналогового сообщения CAN.
@@ -171,7 +171,7 @@ typedef enum {
 typedef union{
     struct msgBody_Analog{
         unsigned SensorID:12; /**< Идентификатор датчика (12 бит). */
-        ProtoCanAnalogType Type:4; /**< Тип аналоговых данных (4 бита). */
+        SetCanAnalogType Type:4; /**< Тип аналоговых данных (4 бита). */
     } Fields; /**< Структура с разбивкой по полям. */
     unsigned Body; /**< Общее 16-битное представление сообщения. */
 } msgBodyAnalogType;
@@ -213,16 +213,16 @@ struct controlflags{
  * Объединение позволяет обращаться к различным полям идентификатора, а также как к 29-битному целому числу.
  */
 typedef union{
-	struct protoCanIdFields{
+	struct SETCANIdFields{
 		unsigned MsgBody:16;                 /**< Поле сообщения (16 бит). */
-		ProtoCanMsgType MsgType:4;           /**< Тип сообщения (4 бита). */
+		SetCanMsgType MsgType:4;           /**< Тип сообщения (4 бита). */
 		unsigned DeviceID:4;                 /**< Идентификатор устройства (4 бита). */
 		unsigned DeviceType:3;               /**< Тип устройства (3 бита). */
-		ProtoCanRouteType Route:1;           /**< Маршрут (1 бит). */
+		SetCanRouteType Route:1;           /**< Маршрут (1 бит). */
-		ProtoCanPriorityType Priority:1;     /**< Приоритет (1 бит). */
+		SetCanPriorityType Priority:1;     /**< Приоритет (1 бит). */
 	} Fields; /**< Структура с разбивкой по полям. */
   unsigned int BitAll:29; /**< Общее представление 29-битного идентификатора. */
-} ProtoCanId_t;
+} SetCanId_t;
 
 /**
  * @brief Структура для общего адресного пространства CAN.
@@ -230,27 +230,27 @@ typedef union{
  * Используется для хранения данных о регистре и его содержимом.
  */
 typedef struct{
-	struct ProtoCanCoreData{
+	struct SetCanCoreData{
 		uint16_t Type;
 		uint16_t Body;
 		uint8_t *Data;
 		unsigned DataCount;
 	} CoreData;
-	struct ProtoCanGeneralAddressSpaceData{
+	struct SetCanGeneralAddressSpaceData{
 		uint16_t RegStartAdr; /**< Начальный адрес регистров. */
 		uint16_t *Data; /**< Указатель на массив данных. */
 		unsigned RegCount; /**< Количество регистров. */
 	} GeneralAddressSpaceData;
-	struct ProtoCanModbusData{
+	struct SetCanModbusData{
 		uint16_t StrAdr;
 		uint16_t *Data;
 		unsigned RegCount:4;
 	} ModbusData;
-	struct ProtoCanErrorData{
+	struct SetCanErrorData{
 		uint16_t Info;
 		uint16_t Code;
 	} ErrorData;
-} ProtoCanData_t;
+} SetCanData_t;
 
 /**
  * @brief Структура данных устройства CAN.
@@ -259,10 +259,10 @@ typedef struct{
  */
 typedef struct{
 	unsigned Status:1; /**< Статус устройства (флаг). */
-	ProtoCanId_t Id; /**< Идентификатор CAN. */
+	SetCanId_t Id; /**< Идентификатор CAN. */
 	unsigned TimeFromLastPulse; /**< Время с последнего импульса (мс). */
 	unsigned LastPulseStep; /**< Шаг последнего импульса. */
-} ProtoCanDevice_t;
+} SetCanDevice_t;
 
 /**
  * @brief Структура для хранения сообщения RXCAN.
@@ -275,58 +275,58 @@ struct RXMsg {
         unsigned EXT : 1; /**< Бит расширенного идентификатора (EXT). */
         unsigned RTR : 1; /**< Бит запроса на передачу (RTR). */
     } info; /**< Информационные флаги сообщения. */
-    ProtoCanId_t eID; /**< Идентификатор CAN-сообщения. */
+    SetCanId_t eID; /**< Идентификатор CAN-сообщения. */
     uint16_t DLC; /**< Длина данных (Data Length Code). */
     uint8_t Data[8]; /**< Массив данных (до 8 байт). */
 };
 
 uint16_t AvailableCanRxMsg(void);
 
-PROTOCAN_INIT_StatusTypeDef PROTOCAN_INIT(CAN_HandleTypeDef *tmp_hcan,
+SETCAN_INIT_StatusTypeDef SETCAN_INIT(CAN_HandleTypeDef *tmp_hcan,
 																					RTC_HandleTypeDef *tmp_hrtc,
 																					TIM_HandleTypeDef *tmp_tim);
-void PROTOCAN_DEINIT(uint8_t stage);
+void SETCAN_DEINIT(uint8_t stage);
-void PROTOCAN_FILTERS(void);
+void SETCAN_FILTERS(void);
-void PROTOCAN_LoopProcessRxMsgs(void);
+void SETCAN_LoopProcessRxMsgs(void);
-PROTOCAN_StatusTypeDef PROTOCAN_ProcessAllRxMsgs(void);
+SETCAN_StatusTypeDef SETCAN_ProcessAllRxMsgs(void);
-PROTOCAN_StatusTypeDef PROTOCAN_ProcessSingleRxMsg(void);
+SETCAN_StatusTypeDef SETCAN_ProcessSingleRxMsg(void);
-PROTOCAN_StatusTypeDef PROTOCAN_SEND(ProtoCanId_t id, ProtoCanData_t data);
+SETCAN_StatusTypeDef SETCAN_SEND(SetCanId_t id, SetCanData_t data);
 
-void ProtoCanPulseCallback(TIM_HandleTypeDef *htim);
+void SetCanPulseCallback(TIM_HandleTypeDef *htim);
-void ProtoCanRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan);
+void SetCanRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan);
 
-PROTOCAN_StatusTypeDef PROTOCAN_BroadcastProcessing(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SETCAN_BroadcastProcessing(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastStatus(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToBroadcastStatus(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastOnOff(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToBroadcastOnOff(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRestart(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToBroadcastRestart(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRtcSetup(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToBroadcastRtcSetup(struct RXMsg _rxMsg);
 
-PROTOCAN_StatusTypeDef PROTOCAN_DiscreticProcessing(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SETCAN_DiscreticProcessing(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteAccident(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToDiscreteAccident(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteWarning(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToDiscreteWarning(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteControlSignals(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToDiscreteControlSignals(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteFlags(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToDiscreteFlags(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteReset(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToDiscreteReset(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteChangeMode(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToDiscreteChangeMode(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteRequestListOfParameters(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToDiscreteRequestListOfParameters(struct RXMsg _rxMsg);
 
-PROTOCAN_StatusTypeDef PROTOCAN_AnalogProcessing(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SETCAN_AnalogProcessing(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUniversal(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToAnalogUniversal(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogSettings(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToAnalogSettings(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUSens(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToAnalogUSens(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogISens(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToAnalogISens(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogTSens(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToAnalogTSens(struct RXMsg _rxMsg);
 
-PROTOCAN_StatusTypeDef ProtoCanMsgToGeneralAddressSpace(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToGeneralAddressSpace(struct RXMsg _rxMsg);
 
-PROTOCAN_StatusTypeDef PROTOCAN_RequestError(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SETCAN_RequestError(struct RXMsg _rxMsg);
 
-PROTOCAN_StatusTypeDef PROTOCAN_ModbusProcessing(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SETCAN_ModbusProcessing(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToModbusCoil(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToModbusCoil(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToModbusDiscrete(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToModbusDiscrete(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToModbusHolding(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToModbusHolding(struct RXMsg _rxMsg);
-PROTOCAN_StatusTypeDef ProtoCanMsgToModbusInput(struct RXMsg _rxMsg);
+SETCAN_StatusTypeDef SetCanMsgToModbusInput(struct RXMsg _rxMsg);
 
-void PROTOCAN_RTC_SYNC(uint8_t *data);
+void SETCAN_RTC_SYNC(uint8_t *data);
 
 #endif

Core/Src/main.c

@@ -92,11 +92,11 @@ int main(void)
   MX_RTC_Init();
   MX_TIM4_Init();
   /* USER CODE BEGIN 2 */
-	if(PROTOCAN_INIT(&hcan, &hrtc, &htim4) == PROTOCAN_OK)
+	if(SETCAN_INIT(&hcan, &hrtc, &htim4) == SETCAN_OK)
 	{
 		HAL_CAN_Start(&hcan);
 		HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING | CAN_IT_ERROR | CAN_IT_BUSOFF | CAN_IT_LAST_ERROR_CODE);
-		PROTOCAN_LoopProcessRxMsgs();
+		SETCAN_LoopProcessRxMsgs();
 	}
   /* USER CODE END 2 */
 

Core/Src/setcan.c

@@ -1,7 +1,7 @@
-#include "protocan.h"
+#include "setcan.h"
 
-ProtoCanDevice_t CurrentDevice;
+SetCanDevice_t CurrentDevice;
-ProtoCanDevice_t Device_on_the_Network[8][16];
+SetCanDevice_t Device_on_the_Network[8][16];
 struct controlflags ControlFlags;
 
 CAN_HandleTypeDef *_HCAN = 0;
@@ -10,7 +10,7 @@ TIM_HandleTypeDef *_HTIM = 0;
 
 uint8_t CurrentStep = 1;
 uint8_t LastStep = 0;
-struct RXMsg rxMsg[PROTOCAN_RX_BUFFER_SIZE];
+struct RXMsg rxMsg[SETCAN_RX_BUFFER_SIZE];
 
 /**
 * @brief Проверяет, является ли год високосным.
@@ -33,10 +33,10 @@ _Bool IsLeapYear(uint8_t year)
 */
 uint16_t AvailableCanRxMsg(void)
 {
-	return ((uint16_t)(PROTOCAN_RX_BUFFER_SIZE + (LastStep - CurrentStep + 1))) % PROTOCAN_RX_BUFFER_SIZE;
+	return ((uint16_t)(SETCAN_RX_BUFFER_SIZE + (LastStep - CurrentStep + 1))) % SETCAN_RX_BUFFER_SIZE;
 }
 
-void PROTOCAN_DEINIT(uint8_t stage)
+void SETCAN_DEINIT(uint8_t stage)
 {
 	switch(stage)
 	{
@@ -56,25 +56,25 @@ void PROTOCAN_DEINIT(uint8_t stage)
 /**
 * @brief Инициализация переферии
 * @details Инициализация указателей на HCAN, HRTC, установка фильтров CAN.
-* @note Фильтры CAN описаны в разделе PROTOCAN_CAN_FILTERS().
+* @note Фильтры CAN описаны в разделе SETCAN_CAN_FILTERS().
 */
-PROTOCAN_INIT_StatusTypeDef PROTOCAN_INIT(CAN_HandleTypeDef *tmp_hcan, RTC_HandleTypeDef *tmp_hrtc, TIM_HandleTypeDef *tmp_tim)
+SETCAN_INIT_StatusTypeDef SETCAN_INIT(CAN_HandleTypeDef *tmp_hcan, RTC_HandleTypeDef *tmp_hrtc, TIM_HandleTypeDef *tmp_tim)
 {
 	unsigned initStage = 0;
 	if(tmp_hcan)
 	{
 		_HCAN = tmp_hcan;
 		#if (USE_HAL_CAN_REGISTER_CALLBACKS == 1)
-		HAL_StatusTypeDef CAN_RC_RESULT = HAL_CAN_RegisterCallback(_HCAN, HAL_CAN_RX_FIFO0_MSG_PENDING_CB_ID, ProtoCanRxFifo0MsgPendingCallback); 
+		HAL_StatusTypeDef CAN_RC_RESULT = HAL_CAN_RegisterCallback(_HCAN, HAL_CAN_RX_FIFO0_MSG_PENDING_CB_ID, SetCanRxFifo0MsgPendingCallback); 
 		if(CAN_RC_RESULT != HAL_OK)
 		{
-			PROTOCAN_DEINIT(initStage);
+			SETCAN_DEINIT(initStage);
-			return PROTOCAN_INIT_HRTC_ERROR;
+			return SETCAN_INIT_HRTC_ERROR;
 		}
 		#endif
 	}	else {
-		PROTOCAN_DEINIT(initStage);
+		SETCAN_DEINIT(initStage);
-		return PROTOCAN_INIT_HCAN_ERROR;
+		return SETCAN_INIT_HCAN_ERROR;
 	}
 	initStage++;
 	if(tmp_hrtc)
@@ -83,31 +83,31 @@ PROTOCAN_INIT_StatusTypeDef PROTOCAN_INIT(CAN_HandleTypeDef *tmp_hcan, RTC_Handl
 	}
 	else
 	{
-		PROTOCAN_DEINIT(initStage);
+		SETCAN_DEINIT(initStage);
-		return PROTOCAN_INIT_HRTC_ERROR;
+		return SETCAN_INIT_HRTC_ERROR;
 	}
 	initStage++;
 	if(tmp_tim)
 	{
 		_HTIM = tmp_tim;
 		#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)
-		HAL_StatusTypeDef TIM_RC_RESULT = HAL_TIM_RegisterCallback(_HTIM, HAL_TIM_PERIOD_ELAPSED_CB_ID, ProtoCanPulseCallback);
+		HAL_StatusTypeDef TIM_RC_RESULT = HAL_TIM_RegisterCallback(_HTIM, HAL_TIM_PERIOD_ELAPSED_CB_ID, SetCanPulseCallback);
 		if(TIM_RC_RESULT != HAL_OK)
 		{
-			PROTOCAN_DEINIT(initStage);
+			SETCAN_DEINIT(initStage);
-			return PROTOCAN_INIT_HRTC_ERROR;
+			return SETCAN_INIT_HRTC_ERROR;
 		}
 		#endif
 	}
 	else
 	{
-		PROTOCAN_DEINIT(initStage);
+		SETCAN_DEINIT(initStage);
-		return PROTOCAN_INIT_TIM_ERROR;
+		return SETCAN_INIT_TIM_ERROR;
 	}
 	initStage++;
-	PROTOCAN_FILTERS();
+	SETCAN_FILTERS();
 	ControlFlags.IsPulse = 1;
-	return PROTOCAN_INIT_OK;
+	return SETCAN_INIT_OK;
 }
 
 /**
@@ -129,41 +129,41 @@ PROTOCAN_INIT_StatusTypeDef PROTOCAN_INIT(CAN_HandleTypeDef *tmp_hcan, RTC_Handl
  * В конце каждого обработанного сообщения индекс текущего элемента буфера инкрементируется
  * с учетом размера буфера через операцию по модулю.
  */
-void PROTOCAN_LoopProcessRxMsgs(void)
+void SETCAN_LoopProcessRxMsgs(void)
 {
     while(1)
     {
         if(AvailableCanRxMsg())
         {
-            if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ANALOG)
+            if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ANALOG)
             {
-                PROTOCAN_AnalogProcessing(rxMsg[CurrentStep]);
+                SETCAN_AnalogProcessing(rxMsg[CurrentStep]);
             }
-            else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_BROADCAST)
+            else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_BROADCAST)
             {
-                PROTOCAN_BroadcastProcessing(rxMsg[CurrentStep]);
+                SETCAN_BroadcastProcessing(rxMsg[CurrentStep]);
             }
-            else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_DISCRETE)
+            else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_DISCRETE)
             {
-                PROTOCAN_DiscreticProcessing(rxMsg[CurrentStep]);
+                SETCAN_DiscreticProcessing(rxMsg[CurrentStep]);
             }
-            else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
+            else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
             {
-                ProtoCanMsgToGeneralAddressSpace(rxMsg[CurrentStep]);
+                SetCanMsgToGeneralAddressSpace(rxMsg[CurrentStep]);
             }
-            else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_COIL ||
+            else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_COIL ||
-                    rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_DISCRETE ||
+                    rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_DISCRETE ||
-                    rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_HOLDING ||
+                    rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_HOLDING ||
-                    rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_INPUT)
+                    rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_INPUT)
             {
-                PROTOCAN_ModbusProcessing(rxMsg[CurrentStep]);
+                SETCAN_ModbusProcessing(rxMsg[CurrentStep]);
             }
-            else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ERROR)
+            else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ERROR)
             {
-                PROTOCAN_RequestError(rxMsg[CurrentStep]);
+                SETCAN_RequestError(rxMsg[CurrentStep]);
             }
             // Обновление индекса текущего сообщения с циклическим масштабированием
-            CurrentStep = (uint16_t)(CurrentStep + 1) % PROTOCAN_RX_BUFFER_SIZE;
+            CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
         }
     }
 }
@@ -176,46 +176,46 @@ void PROTOCAN_LoopProcessRxMsgs(void)
  * После обработки каждого сообщения индекс текущего элемента буфера обновляется
  * циклически.
  *
- * @return PROTOCAN_OK, если все сообщения были обработаны успешно.
+ * @return SETCAN_OK, если все сообщения были обработаны успешно.
  *         В противном случае возвращается код ошибки, полученный при обработке сообщения.
  *
  * Обработка происходит до тех пор, пока есть доступные сообщения, полученные функцией
  * AvailableCanRxMsg().
  */
-PROTOCAN_StatusTypeDef PROTOCAN_ProcessAllRxMsgs(void)
+SETCAN_StatusTypeDef SETCAN_ProcessAllRxMsgs(void)
 {
-	PROTOCAN_StatusTypeDef result = PROTOCAN_TIMEOUT;
+	SETCAN_StatusTypeDef result = SETCAN_TIMEOUT;
 	while(AvailableCanRxMsg())
 	{
-		if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ANALOG)
+		if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ANALOG)
 		{
-			result = PROTOCAN_AnalogProcessing(rxMsg[CurrentStep]);
+			result = SETCAN_AnalogProcessing(rxMsg[CurrentStep]);
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_BROADCAST)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_BROADCAST)
 		{
-			result = PROTOCAN_BroadcastProcessing(rxMsg[CurrentStep]);					
+			result = SETCAN_BroadcastProcessing(rxMsg[CurrentStep]);					
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_DISCRETE)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_DISCRETE)
 		{
-			result = PROTOCAN_DiscreticProcessing(rxMsg[CurrentStep]);
+			result = SETCAN_DiscreticProcessing(rxMsg[CurrentStep]);
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
 		{
-			result = ProtoCanMsgToGeneralAddressSpace(rxMsg[CurrentStep]);
+			result = SetCanMsgToGeneralAddressSpace(rxMsg[CurrentStep]);
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_COIL ||
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_COIL ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_DISCRETE ||
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_DISCRETE ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_HOLDING ||
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_HOLDING ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_INPUT)
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_INPUT)
 		{
-			result = PROTOCAN_ModbusProcessing(rxMsg[CurrentStep]);
+			result = SETCAN_ModbusProcessing(rxMsg[CurrentStep]);
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ERROR)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ERROR)
 		{
-			result = PROTOCAN_RequestError(rxMsg[CurrentStep]);
+			result = SETCAN_RequestError(rxMsg[CurrentStep]);
 		}
-		CurrentStep = (uint16_t)(CurrentStep + 1) % PROTOCAN_RX_BUFFER_SIZE;
+		CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
-		if(result != PROTOCAN_OK)
+		if(result != SETCAN_OK)
 		{
 			return result;
 		}
@@ -231,43 +231,43 @@ PROTOCAN_StatusTypeDef PROTOCAN_ProcessAllRxMsgs(void)
  * индекс текущего сообщения обновляется циклически.
  *
  * @return Прошедший статус обработки:
- * - PROTOCAN_OK, если сообщение успешно обработано,
+ * - SETCAN_OK, если сообщение успешно обработано,
- * - PROTOCAN_TIMEOUT, если сообщений не было,
+ * - SETCAN_TIMEOUT, если сообщений не было,
  * - или код ошибки, возвращенный функцией обработки.
  */
-PROTOCAN_StatusTypeDef PROTOCAN_ProcessSingleRxMsg(void)
+SETCAN_StatusTypeDef SETCAN_ProcessSingleRxMsg(void)
 {
-	PROTOCAN_StatusTypeDef result = PROTOCAN_TIMEOUT;
+	SETCAN_StatusTypeDef result = SETCAN_TIMEOUT;
 	if(AvailableCanRxMsg())
 	{
-		if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ANALOG)
+		if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ANALOG)
 		{
-			result = PROTOCAN_AnalogProcessing(rxMsg[CurrentStep]);
+			result = SETCAN_AnalogProcessing(rxMsg[CurrentStep]);
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_BROADCAST)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_BROADCAST)
 		{
-			result = PROTOCAN_BroadcastProcessing(rxMsg[CurrentStep]);					
+			result = SETCAN_BroadcastProcessing(rxMsg[CurrentStep]);					
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_DISCRETE)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_DISCRETE)
 		{
-			result = PROTOCAN_DiscreticProcessing(rxMsg[CurrentStep]);
+			result = SETCAN_DiscreticProcessing(rxMsg[CurrentStep]);
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
 		{
-			result = ProtoCanMsgToGeneralAddressSpace(rxMsg[CurrentStep]);
+			result = SetCanMsgToGeneralAddressSpace(rxMsg[CurrentStep]);
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_COIL ||
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_COIL ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_DISCRETE ||
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_DISCRETE ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_HOLDING ||
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_HOLDING ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_INPUT)
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_INPUT)
 		{
-			result = PROTOCAN_ModbusProcessing(rxMsg[CurrentStep]);
+			result = SETCAN_ModbusProcessing(rxMsg[CurrentStep]);
 		}
-		else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ERROR)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ERROR)
 		{
-			result = PROTOCAN_RequestError(rxMsg[CurrentStep]);
+			result = SETCAN_RequestError(rxMsg[CurrentStep]);
 		}
-		CurrentStep = (uint16_t)(CurrentStep + 1) % PROTOCAN_RX_BUFFER_SIZE;
+		CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
 	}
 	return result;
 }
@@ -278,41 +278,41 @@ PROTOCAN_StatusTypeDef PROTOCAN_ProcessSingleRxMsg(void)
 * @details Функция, выполняющая команды, переданные в широковещательном формате с головного (master) устройства. Типы команд: Запрос статуса, запрос на включение или выключение, рестарт устройств, установка времени.
 * @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
 */
-PROTOCAN_StatusTypeDef PROTOCAN_BroadcastProcessing(struct RXMsg _rxMsg)
+SETCAN_StatusTypeDef SETCAN_BroadcastProcessing(struct RXMsg _rxMsg)
 {	
 	msgBodyBroadcastType msg;
 	msg.Body = _rxMsg.eID.Fields.MsgBody;
 	switch(msg.Fields.Type)
 	{
-		case PROTOCAN_BROADCAST_STATUS:
+		case SETCAN_BROADCAST_STATUS:
 		{
 			//Обработка запроса статуса устройства
-			return ProtoCanMsgToBroadcastStatus(_rxMsg);
+			return SetCanMsgToBroadcastStatus(_rxMsg);
 		}
-		case PROTOCAN_BROADCAST_ONOFF:
+		case SETCAN_BROADCAST_ONOFF:
 		{
 			//Обработка запроса на вкл/выкл 
-			ProtoCanMsgToBroadcastOnOff(_rxMsg);
+			SetCanMsgToBroadcastOnOff(_rxMsg);
 			break;
 		}
-		case PROTOCAN_BROADCAST_RESTARTDEVICE:
+		case SETCAN_BROADCAST_RESTARTDEVICE:
 		{
-			ProtoCanMsgToBroadcastRestart(_rxMsg);
+			SetCanMsgToBroadcastRestart(_rxMsg);
 			break;
 		}
-		case PROTOCAN_BROADCAST_RTCSETUP:
+		case SETCAN_BROADCAST_RTCSETUP:
 		{
 			//Обработка запроса на синхронизацию времени
 			//С головным устройством
-			ProtoCanMsgToBroadcastRtcSetup(_rxMsg);
+			SetCanMsgToBroadcastRtcSetup(_rxMsg);
 			break;;
 		}
 		default:
 			//RESERVE SENSOR TYPE.
-			return PROTOCAN_ERROR;
+			return SETCAN_ERROR;
 			break;
 	}
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -321,7 +321,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_BroadcastProcessing(struct RXMsg _rxMsg)
 * @param _rxMsg Структура полученного по CAN запроса.
 * @return HAL_StatusTypeDef Статус операции HAL, например HAL_OK при успехе.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastStatus(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToBroadcastStatus(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -330,9 +330,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastStatus(struct RXMsg _rxMsg)
 	TxHeader.DLC = 7;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	tmp_eID.Fields.DeviceType = CURRENT_TYPE_DEVICE;
 	tmp_eID.Fields.DeviceID = CURRENT_ID_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
@@ -347,7 +347,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastStatus(struct RXMsg _rxMsg)
 	data[4] = DateToUpdate.Month;
 	data[5] = DateToUpdate.Date;
 	data[6] = DateToUpdate.WeekDay;
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -356,10 +356,10 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastStatus(struct RXMsg _rxMsg)
 * В данном случае — просто инвертирует его логическое значение.
 * @param _rxMsg Структура полученного CAN-сообщения (Пока не используется в функции).
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastOnOff(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToBroadcastOnOff(struct RXMsg _rxMsg)
 {
 	ControlFlags.IsPulse = !ControlFlags.IsPulse;
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -368,11 +368,11 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastOnOff(struct RXMsg _rxMsg)
 * вызывает системный перезапуск.
 * @param _rxMsg Структура полученного CAN-сообщения с командой перезапуска.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRestart(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToBroadcastRestart(struct RXMsg _rxMsg)
 {
 	if(_rxMsg.DLC == 0)
 	{
-		return PROTOCAN_ERROR;
+		return SETCAN_ERROR;
 	}
 	msgBodyBroadcastType msg;
 	msg.Body = _rxMsg.eID.Fields.MsgBody;
@@ -388,7 +388,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRestart(struct RXMsg _rxMsg)
 			NVIC_SystemReset();
 		}
 	}
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -397,11 +397,11 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRestart(struct RXMsg _rxMsg)
 * вызывает функцию синхронизации RTC.
 * @param _rxMsg Структура полученного CAN-сообщения с данными для установки времени и даты.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRtcSetup(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToBroadcastRtcSetup(struct RXMsg _rxMsg)
 {
 	if(_rxMsg.DLC > 7)
 	{
-		return PROTOCAN_ERROR;
+		return SETCAN_ERROR;
 	}
 	else
 	{
@@ -415,14 +415,14 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRtcSetup(struct RXMsg _rxMsg
 				_rxMsg.Data[5] > DaysCount_Normal[IsLeapYear(_rxMsg.Data[3])][_rxMsg.Data[4]] ||
 				_rxMsg.Data[6] > 6)
 		{
-			return PROTOCAN_ERROR;
+			return SETCAN_ERROR;
 		}
 		else
 		{
-			PROTOCAN_RTC_SYNC(_rxMsg.Data);
+			SETCAN_RTC_SYNC(_rxMsg.Data);
 		}
 	}
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -432,53 +432,53 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRtcSetup(struct RXMsg _rxMsg
 * @note Запрос на устройство. Головное (master) устройство запрашивает некоторое колличество параметров. В Data - 64 битовых адресса параметров, тип которых задаётся в Sensor ID. Имеется возможность запрашивать непоследовательные параметры.
 * @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
 */
-PROTOCAN_StatusTypeDef PROTOCAN_DiscreticProcessing(struct RXMsg _rxMsg)
+SETCAN_StatusTypeDef SETCAN_DiscreticProcessing(struct RXMsg _rxMsg)
 {
 	msgBodyDiscreteType msg;
 	msg.Body = _rxMsg.eID.Fields.MsgBody;
 	switch(msg.Fields.Type)
 	{
-		case PROTOCAN_DISCRETE_ACCIDENT:
+		case SETCAN_DISCRETE_ACCIDENT:
 		{
-			ProtoCanMsgToDiscreteAccident(_rxMsg);
+			SetCanMsgToDiscreteAccident(_rxMsg);
 			break;
 		}
-		case PROTOCAN_DISCRETE_WARNING:
+		case SETCAN_DISCRETE_WARNING:
 		{
-			ProtoCanMsgToDiscreteWarning(_rxMsg);
+			SetCanMsgToDiscreteWarning(_rxMsg);
 			break;
 		}
-		case PROTOCAN_DISCRETE_CONTROL_SIGNALS:
+		case SETCAN_DISCRETE_CONTROL_SIGNALS:
 		{
-			ProtoCanMsgToDiscreteControlSignals(_rxMsg);
+			SetCanMsgToDiscreteControlSignals(_rxMsg);
 			break;
 		}
-		case PROTOCAN_DISCRETE_FLAGS:
+		case SETCAN_DISCRETE_FLAGS:
 		{
-			ProtoCanMsgToDiscreteFlags(_rxMsg);
+			SetCanMsgToDiscreteFlags(_rxMsg);
 			break;
 		}
-		case PROTOCAN_DISCRETE_RESET:
+		case SETCAN_DISCRETE_RESET:
 		{
-			ProtoCanMsgToDiscreteReset(_rxMsg);
+			SetCanMsgToDiscreteReset(_rxMsg);
 			break;
 		}
-		case PROTOCAN_DISCRETE_CHANGE_MODE:
+		case SETCAN_DISCRETE_CHANGE_MODE:
 		{
-			ProtoCanMsgToDiscreteChangeMode(_rxMsg);
+			SetCanMsgToDiscreteChangeMode(_rxMsg);
 			break;
 		}
-		case PROTOCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS:
+		case SETCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS:
 		{
-			ProtoCanMsgToDiscreteRequestListOfParameters(_rxMsg);
+			SetCanMsgToDiscreteRequestListOfParameters(_rxMsg);
 			break;
 		}
 		default:
 			//RESERVE SENSOR TYPE.
-			return PROTOCAN_ERROR;
+			return SETCAN_ERROR;
 			break;
 	}
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -487,9 +487,9 @@ PROTOCAN_StatusTypeDef PROTOCAN_DiscreticProcessing(struct RXMsg _rxMsg)
 * Можно реализовать отправку или обработку аварийных данных.
 * @param _rxMsg Входящее сообщение с данными запроса.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteAccident(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToDiscreteAccident(struct RXMsg _rxMsg)
 {
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -498,9 +498,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteAccident(struct RXMsg _rxMsg)
 * Можно реализовать обработку или ответ на предупреждения.
 * @param _rxMsg Входящее сообщение.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteWarning(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToDiscreteWarning(struct RXMsg _rxMsg)
 {
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -509,9 +509,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteWarning(struct RXMsg _rxMsg)
 * Можно реализовать управление сигналами.
 * @param _rxMsg Входящее сообщение.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteControlSignals(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToDiscreteControlSignals(struct RXMsg _rxMsg)
 {
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -520,9 +520,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteControlSignals(struct RXMsg _
 * Можно реализовать работу с флагами.
 * @param _rxMsg Входящее сообщение.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteFlags(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToDiscreteFlags(struct RXMsg _rxMsg)
 {
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -530,10 +530,10 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteFlags(struct RXMsg _rxMsg)
 * Выполняет программный рестарт системы.
 * @param _rxMsg Входящее сообщение.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteReset(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToDiscreteReset(struct RXMsg _rxMsg)
 {
 	NVIC_SystemReset();
-	return PROTOCAN_ERROR;
+	return SETCAN_ERROR;
 }
 
 /**
@@ -542,9 +542,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteReset(struct RXMsg _rxMsg)
 * Можно реализовать изменение режима работы.
 * @param _rxMsg Входящее сообщение.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteChangeMode(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToDiscreteChangeMode(struct RXMsg _rxMsg)
 {
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -553,9 +553,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteChangeMode(struct RXMsg _rxMs
 * Можно реализовать отправку списка параметров.
 * @param _rxMsg Входящее сообщение.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteRequestListOfParameters(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToDiscreteRequestListOfParameters(struct RXMsg _rxMsg)
 {
-	return PROTOCAN_OK;
+	return SETCAN_OK;
 }
 
 /**
@@ -564,43 +564,43 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteRequestListOfParameters(struc
 * @details Функция, сортирующая запросы по типам и вызывающая соответствующие функции. Типы запросов: Универсальный, Уставки, Напряжение, Ток, Температура.
 * @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
 */
-PROTOCAN_StatusTypeDef PROTOCAN_AnalogProcessing(struct RXMsg _rxMsg)
+SETCAN_StatusTypeDef SETCAN_AnalogProcessing(struct RXMsg _rxMsg)
 {
 	msgBodyAnalogType msg;
 	msg.Body = _rxMsg.eID.Fields.MsgBody;
 	switch (msg.Fields.Type)
 	{
-		case PROTOCAN_ANALOG_UNIVERSAL:
+		case SETCAN_ANALOG_UNIVERSAL:
 		{
-			return ProtoCanMsgToAnalogUniversal(_rxMsg);
+			return SetCanMsgToAnalogUniversal(_rxMsg);
 			break;
 		}
-		case PROTOCAN_ANALOG_SETTINGS:
+		case SETCAN_ANALOG_SETTINGS:
 		{
-			return ProtoCanMsgToAnalogSettings(_rxMsg);
+			return SetCanMsgToAnalogSettings(_rxMsg);
 			break;
 		}
-		case PROTOCAN_ANALOG_U:
+		case SETCAN_ANALOG_U:
 		{
-			return ProtoCanMsgToAnalogUSens(_rxMsg);
+			return SetCanMsgToAnalogUSens(_rxMsg);
 			break;
 		}
-		case PROTOCAN_ANALOG_I:
+		case SETCAN_ANALOG_I:
 		{
-			return ProtoCanMsgToAnalogISens(_rxMsg);		
+			return SetCanMsgToAnalogISens(_rxMsg);		
 			break;
 		}
-		case PROTOCAN_ANALOG_T:
+		case SETCAN_ANALOG_T:
 		{
-			return ProtoCanMsgToAnalogTSens(_rxMsg);
+			return SetCanMsgToAnalogTSens(_rxMsg);
 			break;
 		}
 		default:
 			//RESERVE SENSOR TYPE
-			return PROTOCAN_ERROR;
+			return SETCAN_ERROR;
 			break;
 	}
-	return PROTOCAN_ERROR;
+	return SETCAN_ERROR;
 }
 
 /**
@@ -609,7 +609,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_AnalogProcessing(struct RXMsg _rxMsg)
 * @param _rxMsg Структура входящего сообщения, используется для формирования ID.
 * @return HAL_StatusTypeDef Статус выполнения операции HAL, например HAL_OK.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUniversal(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToAnalogUniversal(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -617,9 +617,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUniversal(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 6;
 	data[0] = 'U';
@@ -628,7 +628,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUniversal(struct RXMsg _rxMsg)
 	data[3] = 'V';
 	data[4] = 'E';
 	data[5] = 'R';
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -637,7 +637,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUniversal(struct RXMsg _rxMsg)
 * @param _rxMsg Структура входящего сообщения, используется только для формирования ID.
 * @return HAL_StatusTypeDef Статус выполнения операции HAL, например HAL_OK.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogSettings(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToAnalogSettings(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -645,9 +645,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogSettings(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 7;
 	data[0] = 'U';
@@ -657,7 +657,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogSettings(struct RXMsg _rxMsg)
 	data[4] = 'V';
 	data[5] = 'K';
 	data[6] = 'I';
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -666,7 +666,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogSettings(struct RXMsg _rxMsg)
 * @param _rxMsg Структура входящего сообщения, используемая для формирования идентификатора и данных.
 * @return HAL_StatusTypeDef Статус выполнения операции HAL, например HAL_OK при успешной отправке.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUSens(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToAnalogUSens(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -674,9 +674,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUSens(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 6;
 	msgBodyAnalogType msg;
@@ -687,7 +687,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUSens(struct RXMsg _rxMsg)
 	data[3] = '0' + msg.Fields.SensorID / 100 % 10;
 	data[4] = '0' + msg.Fields.SensorID / 10 % 10;
 	data[5] = '0' + msg.Fields.SensorID % 10;
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -696,7 +696,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUSens(struct RXMsg _rxMsg)
 * @param _rxMsg Структура входящего сообщения, используется для формирования идентификатора и данных.
 * @return HAL_StatusTypeDef Статус операции HAL, например HAL_OK при успешной отправке.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogISens(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToAnalogISens(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -704,9 +704,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogISens(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 6;
 	msgBodyAnalogType msg;
@@ -717,7 +717,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogISens(struct RXMsg _rxMsg)
 	data[3] = '0' + msg.Fields.SensorID / 100 % 10;
 	data[4] = '0' + msg.Fields.SensorID / 10 % 10;
 	data[5] = '0' + msg.Fields.SensorID % 10;
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -726,7 +726,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogISens(struct RXMsg _rxMsg)
 * @param _rxMsg Структура полученного сообщения, которая используется для формирования идентификатора.
 * @return HAL_StatusTypeDef Статус выполнения функции HAL, например HAL_OK при успехе.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogTSens(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToAnalogTSens(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -734,9 +734,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogTSens(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 6;
 	msgBodyAnalogType msg;
@@ -747,7 +747,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogTSens(struct RXMsg _rxMsg)
 	data[3] = '0' + msg.Fields.SensorID / 100 % 10;
 	data[4] = '0' + msg.Fields.SensorID / 10 % 10;
 	data[5] = '0' + msg.Fields.SensorID % 10;
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -757,16 +757,16 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogTSens(struct RXMsg _rxMsg)
  * и аналоговые.
  * @param id Идентификатор сообщения, содержащий тип сообщения и другую информацию.
  * @param coreData Структура данных, включающая тип, тело и данные для передачи.
- * @return PROTOCAN_StatusTypeDef Статус операции.
+ * @return SETCAN_StatusTypeDef Статус операции.
  * @details
  * В зависимости от типа сообщения (панель broadcast, discrete или analog),
  * формируется соответствующий пакет данных и отправляется на шину CAN.
  * Для сообщений, превышающих длину 8 байт, передача выполняется пакетами.
  * В случае ошибок при добавлении сообщения в очередь передачи, возвращается ошибка.
  */
-PROTOCAN_StatusTypeDef PROTOCAN_SEND_CORE(const ProtoCanId_t id, const struct ProtoCanCoreData coreData)
+SETCAN_StatusTypeDef SETCAN_SEND_CORE(const SetCanId_t id, const struct SetCanCoreData coreData)
 {
-	ProtoCanId_t localId = id;
+	SetCanId_t localId = id;
   uint8_t msgType = localId.Fields.MsgType;
   CAN_TxHeaderTypeDef TxHeader;
   TxHeader.IDE = CAN_ID_EXT;
@@ -776,7 +776,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_CORE(const ProtoCanId_t id, const struct Pr
 	uint8_t canData[8];
 	switch(id.Fields.MsgType)
 	{
-		case PROTOCAN_MSGTYPE_BROADCAST:
+		case SETCAN_MSGTYPE_BROADCAST:
 		{
 			msgBodyBroadcastType body;
 			body.Fields.Type = coreData.Type;
@@ -786,10 +786,10 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_CORE(const ProtoCanId_t id, const struct Pr
 			TxHeader.DLC = 0;
 			if(HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox) != HAL_OK)
 			{
-				return PROTOCAN_ERROR;
+				return SETCAN_ERROR;
 			}
 		}
-		case PROTOCAN_MSGTYPE_DISCRETE:
+		case SETCAN_MSGTYPE_DISCRETE:
 		{
 			msgBodyDiscreteType body;
 			body.Fields.Type = coreData.Type;
@@ -809,14 +809,14 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_CORE(const ProtoCanId_t id, const struct Pr
 				HAL_StatusTypeDef status = HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox);
 				if(status != HAL_OK)
 				{
-					return (PROTOCAN_StatusTypeDef)status;
+					return (SETCAN_StatusTypeDef)status;
 				}
 				regsRemaining -= regsInPacket;
 				currentIndex += regsInPacket;
 			}
 			break;
 		}
-		case PROTOCAN_MSGTYPE_ANALOG:
+		case SETCAN_MSGTYPE_ANALOG:
 		{
 			msgBodyAnalogType body;
 			body.Fields.Type = coreData.Type;
@@ -836,7 +836,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_CORE(const ProtoCanId_t id, const struct Pr
 				HAL_StatusTypeDef status = HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox);
 				if(status != HAL_OK)
 				{
-					return (PROTOCAN_StatusTypeDef)status;
+					return (SETCAN_StatusTypeDef)status;
 				}
 				regsRemaining -= regsInPacket;
 				currentIndex += regsInPacket;
@@ -845,10 +845,10 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_CORE(const ProtoCanId_t id, const struct Pr
 		}
 		default:
 		{
-			return PROTOCAN_ERROR;
+			return SETCAN_ERROR;
 		}
 	}
-  return PROTOCAN_OK;
+  return SETCAN_OK;
 }
 
 /**
@@ -856,7 +856,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_CORE(const ProtoCanId_t id, const struct Pr
 * Формирует и передает сообщение с данными о статусе "GAS-XXXX", где XXXX — значение из сообщения _rxMsg.
 * @param _rxMsg Структура входящего сообщения, содержит идентификатор и тело сообщения.
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToGeneralAddressSpace(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToGeneralAddressSpace(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -864,9 +864,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToGeneralAddressSpace(struct RXMsg _rxM
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 8;
 	data[0] = 'G';
@@ -885,20 +885,20 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToGeneralAddressSpace(struct RXMsg _rxM
 			data[4 + i] = sym + '0';
 		}
 	}
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
  * @brief Отправляет произвольный диапазон регистров в пакетах по, максимум, 4 регистра за раз через CAN.
  * Функция разбивает передаваемый массив регистров на пакеты по 4 или меньше и отправляет их по отдельности.
  * Для каждого пакета формируется уникальный MsgBody, равный адресу первого регистра в пакете.
- * @param priority Приоритет сообщения CAN. ProtoCan_Priority_TypeDef
+ * @param priority Приоритет сообщения CAN. SETCAN_Priority_TypeDef
  * @param regStartAdr Адрес первого регистра из всего массива.
  * @param data Указатель на массив регистров для отправки.
  * @param regCount Общее количество регистров для отправки.
  * @return Возвращает статус отправки: HAL_OK при успехе, или код ошибки HAL_StatusTypeDef при сбое.
  */
-PROTOCAN_StatusTypeDef PROTOCAN_SEND_GENERAL_ADDRESS_SPACE(ProtoCanId_t id, uint16_t regStartAdr, uint16_t *data, uint8_t regCount)
+SETCAN_StatusTypeDef SETCAN_SEND_GENERAL_ADDRESS_SPACE(SetCanId_t id, uint16_t regStartAdr, uint16_t *data, uint8_t regCount)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -908,7 +908,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_GENERAL_ADDRESS_SPACE(ProtoCanId_t id, uint
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
 	
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = id.BitAll;
 	
 	uint8_t regsRemaining = regCount;
@@ -932,13 +932,13 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_GENERAL_ADDRESS_SPACE(ProtoCanId_t id, uint
 		
 		if(status != HAL_OK)
 		{
-			return (PROTOCAN_StatusTypeDef)status;
+			return (SETCAN_StatusTypeDef)status;
 		}
 		
 		regsRemaining -= regsInPacket;
     currentIndex += regsInPacket;
 	}
-	return (PROTOCAN_StatusTypeDef)HAL_OK;
+	return (SETCAN_StatusTypeDef)HAL_OK;
 }
 
 /**
@@ -948,36 +948,36 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_GENERAL_ADDRESS_SPACE(ProtoCanId_t id, uint
 * @param _rxMsg Структура входящего сообщения RXMsg.
 * @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
 */
-PROTOCAN_StatusTypeDef PROTOCAN_ModbusProcessing(struct RXMsg _rxMsg)
+SETCAN_StatusTypeDef SETCAN_ModbusProcessing(struct RXMsg _rxMsg)
 {
 	switch(_rxMsg.eID.Fields.MsgType)
 	{
-		case PROTOCAN_MSGTYPE_MODBUS_COIL:
+		case SETCAN_MSGTYPE_MODBUS_COIL:
 		{
-			return ProtoCanMsgToModbusCoil(_rxMsg);
+			return SetCanMsgToModbusCoil(_rxMsg);
 			break;
 		}
-		case PROTOCAN_MSGTYPE_MODBUS_DISCRETE:
+		case SETCAN_MSGTYPE_MODBUS_DISCRETE:
 		{
-			return ProtoCanMsgToModbusDiscrete(_rxMsg);
+			return SetCanMsgToModbusDiscrete(_rxMsg);
 			break;
 		}
-		case PROTOCAN_MSGTYPE_MODBUS_HOLDING:
+		case SETCAN_MSGTYPE_MODBUS_HOLDING:
 		{	
-			return ProtoCanMsgToModbusHolding(_rxMsg);
+			return SetCanMsgToModbusHolding(_rxMsg);
 			break;
 		}
-		case PROTOCAN_MSGTYPE_MODBUS_INPUT:
+		case SETCAN_MSGTYPE_MODBUS_INPUT:
 		{
-			return ProtoCanMsgToModbusInput(_rxMsg);
+			return SetCanMsgToModbusInput(_rxMsg);
 			break;
 		}
 		default:
 			//ERROR
-			return PROTOCAN_ERROR;
+			return SETCAN_ERROR;
 			break;
 	}
-	return PROTOCAN_ERROR;
+	return SETCAN_ERROR;
 }
 
 /**
@@ -986,7 +986,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_ModbusProcessing(struct RXMsg _rxMsg)
 * @param _rxMsg Структура входящего сообщения RXMsg.
 * @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusCoil(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToModbusCoil(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -994,9 +994,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusCoil(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 8;
 	msgBodyModbusType msg;
@@ -1009,7 +1009,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusCoil(struct RXMsg _rxMsg)
 	data[5] = ' ';
 	data[6] = 'C';
 	data[7] = msg.Fields.RegCount;
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -1018,7 +1018,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusCoil(struct RXMsg _rxMsg)
 * @param _rxMsg Структура входящего сообщения RXMsg.
 * @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusDiscrete(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToModbusDiscrete(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -1026,9 +1026,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusDiscrete(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 8;
 	msgBodyModbusType msg;
@@ -1041,7 +1041,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusDiscrete(struct RXMsg _rxMsg)
 	data[5] = ' ';
 	data[6] = 'C';
 	data[7] = msg.Fields.RegCount;
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -1050,7 +1050,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusDiscrete(struct RXMsg _rxMsg)
 * @param _rxMsg Структура входящего сообщения RXMsg.
 * @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusHolding(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToModbusHolding(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -1058,9 +1058,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusHolding(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 8;
 	msgBodyModbusType msg;
@@ -1073,7 +1073,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusHolding(struct RXMsg _rxMsg)
 	data[5] = ' ';
 	data[6] = 'C';
 	data[7] = msg.Fields.RegCount;
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -1082,7 +1082,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusHolding(struct RXMsg _rxMsg)
 * @param _rxMsg Структура входящего сообщения RXMsg.
 * @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
 */
-__weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusInput(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SetCanMsgToModbusInput(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -1090,9 +1090,9 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusInput(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 8;
 	msgBodyModbusType msg;
@@ -1105,7 +1105,7 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusInput(struct RXMsg _rxMsg)
 	data[5] = ' ';
 	data[6] = 'C';
 	data[7] = msg.Fields.RegCount;
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -1115,21 +1115,21 @@ __weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusInput(struct RXMsg _rxMsg)
  * Для сообщений, превышающих 4 регистров, данные отправляются пакетами.
  * @param id Идентификатор сообщения, содержащий тип сообщения и другую информацию.
  * @param modbusData Структура с данными Modbus: адрес, количество регистров и сами данные.
- * @return PROTOCAN_StatusTypeDef Статус операции.
+ * @return SETCAN_StatusTypeDef Статус операции.
  * @details
  * В зависимости от типа Modbus (coil/discrete или holding/input), формируется
  * соответствующий CAN-пакет. Для coil/discrete отправляется один пакет, для holding/input —
  * несколько, по 4 регистра в пакете. В случае ошибок при добавлении сообщения API HAL возвращается ошибка.
  */
-PROTOCAN_StatusTypeDef PROTOCAN_SEND_MODBUS(const ProtoCanId_t id, const struct ProtoCanModbusData modbusData)
+SETCAN_StatusTypeDef SETCAN_SEND_MODBUS(const SetCanId_t id, const struct SetCanModbusData modbusData)
 {
-	ProtoCanId_t localId = id;
+	SetCanId_t localId = id;
   uint8_t msgType = localId.Fields.MsgType;
 	// Структура для отправки
   CAN_TxHeaderTypeDef TxHeader;
   uint32_t TxMailBox = 0;
 	uint8_t canData[8];
-  if(msgType == PROTOCAN_MSGTYPE_MODBUS_COIL || msgType == PROTOCAN_MSGTYPE_MODBUS_DISCRETE)
+  if(msgType == SETCAN_MSGTYPE_MODBUS_COIL || msgType == SETCAN_MSGTYPE_MODBUS_DISCRETE)
 	{
     // Формируем body
     msgBodyModbusType body;
@@ -1149,10 +1149,10 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_MODBUS(const ProtoCanId_t id, const struct
     canData[1] = HighByteOfWord(modbusData.Data[0]);
     if (HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox) != HAL_OK)
 		{
-			return PROTOCAN_ERROR;
+			return SETCAN_ERROR;
     }
   }
-	else if(msgType == PROTOCAN_MSGTYPE_MODBUS_HOLDING || msgType == PROTOCAN_MSGTYPE_MODBUS_INPUT)
+	else if(msgType == SETCAN_MSGTYPE_MODBUS_HOLDING || msgType == SETCAN_MSGTYPE_MODBUS_INPUT)
 	{
     uint16_t* dataPtr = modbusData.Data;
     unsigned totalRegs = modbusData.RegCount;
@@ -1181,7 +1181,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_MODBUS(const ProtoCanId_t id, const struct
       // Отправляем сообщение
       if(HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox) != HAL_OK)
 			{
-				return PROTOCAN_ERROR;
+				return SETCAN_ERROR;
       }
       regsProcessed += regsInPacket;
       startAddress += regsInPacket;
@@ -1189,9 +1189,9 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_MODBUS(const ProtoCanId_t id, const struct
   }
 	else
 	{
-		return PROTOCAN_ERROR; // Неверный тип сообщения
+		return SETCAN_ERROR; // Неверный тип сообщения
   }
-  return PROTOCAN_OK;
+  return SETCAN_OK;
 }
 
 /**
@@ -1200,7 +1200,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_MODBUS(const ProtoCanId_t id, const struct
 * @param _rxMsg Структура входящего сообщения RXMsg, данными которого формируется ответ-ошибка.
 * @return HAL_StatusTypeDef Статус выполнения команды CAN.
 */
-__weak PROTOCAN_StatusTypeDef PROTOCAN_RequestError(struct RXMsg _rxMsg)
+__weak SETCAN_StatusTypeDef SETCAN_RequestError(struct RXMsg _rxMsg)
 {
 	CAN_TxHeaderTypeDef TxHeader;
 	uint32_t TxMailBox = 0;
@@ -1208,17 +1208,17 @@ __weak PROTOCAN_StatusTypeDef PROTOCAN_RequestError(struct RXMsg _rxMsg)
 	TxHeader.IDE = CAN_ID_EXT;
 	TxHeader.TransmitGlobalTime = DISABLE;
 	TxHeader.RTR = CAN_RTR_DATA;
-	ProtoCanId_t tmp_eID;
+	SetCanId_t tmp_eID;
 	tmp_eID.BitAll = _rxMsg.eID.BitAll;
-	tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
-	tmp_eID.Fields.MsgType = PROTOCAN_MSGTYPE_ERROR;
+	tmp_eID.Fields.MsgType = SETCAN_MSGTYPE_ERROR;
 	msgBodyErrorType msg;
 	msg.Fields.ErrorCode = 0xFF;
 	msg.Fields.Info = 0;
 	tmp_eID.Fields.MsgBody = msg.Body;
 	TxHeader.ExtId = tmp_eID.BitAll;
 	TxHeader.DLC = 0;
-	return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
+	return (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
 }
 
 /**
@@ -1227,14 +1227,14 @@ __weak PROTOCAN_StatusTypeDef PROTOCAN_RequestError(struct RXMsg _rxMsg)
  * объединёнными в поле MsgBody идентификатора сообщения, и передаёт его через CAN.
  * @param id Идентификатор сообщения, содержащий базовую информацию.
  * @param errorData Структура с данными ошибки: код и дополнительная информация.
- * @return PROTOCAN_StatusTypeDef Статус операции.
+ * @return SETCAN_StatusTypeDef Статус операции.
  * @details
  * В качестве данных передаётся 2 байта: старшие биты — информация об ошибке, младшие — код ошибки.
  * Размер данных в CANFrames устанавливается нулевым, так как все данные инкапсулированы в MsgBody.
  */
-PROTOCAN_StatusTypeDef PROTOCAN_SEND_ERROR(const ProtoCanId_t id, const struct ProtoCanErrorData errorData)
+SETCAN_StatusTypeDef SETCAN_SEND_ERROR(const SetCanId_t id, const struct SetCanErrorData errorData)
 {
-	ProtoCanId_t localId = id;
+	SetCanId_t localId = id;
   uint8_t msgType = localId.Fields.MsgType;
 	// Структура для отправки
   CAN_TxHeaderTypeDef TxHeader;
@@ -1250,9 +1250,9 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_ERROR(const ProtoCanId_t id, const struct P
 	TxHeader.DLC = 0;
 	if(HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox) != HAL_OK)
 	{
-		return PROTOCAN_ERROR;
+		return SETCAN_ERROR;
   }
-  return PROTOCAN_OK;
+  return SETCAN_OK;
 }
 
 /**
@@ -1265,7 +1265,7 @@ PROTOCAN_StatusTypeDef PROTOCAN_SEND_ERROR(const ProtoCanId_t id, const struct P
 * @param tmp_DATA Указатель на массив данных, полученных из CAN.
 * @param tmp_LastStep Индекс позиции в буфере, куда записывать сообщение.
 */
-void TakeRxMsgToBuffer(ProtoCanId_t tmp_eID, uint32_t tmp_IDE, uint32_t tmp_RTR, uint32_t tmp_DLC, uint8_t *tmp_DATA, uint16_t tmp_LastStep)
+void TakeRxMsgToBuffer(SetCanId_t tmp_eID, uint32_t tmp_IDE, uint32_t tmp_RTR, uint32_t tmp_DLC, uint8_t *tmp_DATA, uint16_t tmp_LastStep)
 {
 	rxMsg[tmp_LastStep].eID.BitAll = tmp_eID.BitAll;
 	rxMsg[tmp_LastStep].info.EXT = tmp_IDE;
@@ -1283,7 +1283,7 @@ void TakeRxMsgToBuffer(ProtoCanId_t tmp_eID, uint32_t tmp_IDE, uint32_t tmp_RTR,
 * Читает все сообщения из FIFO, проверяет их тип, обновляет статус устройств сети или сохраняет сообщение в буфер.
 * @param hcan Указатель на структуру управления CAN-Hardware.
 */
-void ProtoCanRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
+void SetCanRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
 {
 	//Обработка всех сообщений в FIFO
 	CAN_RxHeaderTypeDef RxHeader;
@@ -1293,16 +1293,16 @@ void ProtoCanRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
 		//Расширенный ID
 		if(RxHeader.IDE == CAN_ID_EXT)
 		{
-			if(!((PROTOCAN_RX_BUFFER_SIZE + LastStep - (CurrentStep - 1)) & PROTOCAN_RX_BUFFER_SIZE))
+			if(!((SETCAN_RX_BUFFER_SIZE + LastStep - (CurrentStep - 1)) & SETCAN_RX_BUFFER_SIZE))
 			{
 				//Буффер переполнен
 				return;
 			}
-			uint16_t tmp_LastStep = (uint16_t)(LastStep + 1) % PROTOCAN_RX_BUFFER_SIZE;
+			uint16_t tmp_LastStep = (uint16_t)(LastStep + 1) % SETCAN_RX_BUFFER_SIZE;
-			ProtoCanId_t ExtID_Of_RX_MSG;
+			SetCanId_t ExtID_Of_RX_MSG;
 			ExtID_Of_RX_MSG.BitAll = RxHeader.ExtId;
 			//Полученное сообщение - пульс устройств в сети
-			if(ExtID_Of_RX_MSG.Fields.MsgType == PROTOCAN_MSGTYPE_PULSE)
+			if(ExtID_Of_RX_MSG.Fields.MsgType == SETCAN_MSGTYPE_PULSE)
 			{
 				Device_on_the_Network[ExtID_Of_RX_MSG.Fields.DeviceType][ExtID_Of_RX_MSG.Fields.DeviceID].Status = ONLINE;
 				Device_on_the_Network[ExtID_Of_RX_MSG.Fields.DeviceType][ExtID_Of_RX_MSG.Fields.DeviceID].TimeFromLastPulse = 0;
@@ -1317,20 +1317,20 @@ void ProtoCanRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
 * @brief Функция отправки пульса устройства.
 * @details Пульс устройства. Есть возможность отключить пульс по запросу.
 */
-void ProtoCanPulseCallback(TIM_HandleTypeDef *htim)
+void SetCanPulseCallback(TIM_HandleTypeDef *htim)
 {
 	if(ControlFlags.IsPulse)
 	{
 		static unsigned PulseStage = 0;
 		CAN_TxHeaderTypeDef TxHeader;
 		uint32_t TxMailBox = 0;
-		ProtoCanId_t currentID;
+		SetCanId_t currentID;
 		currentID.BitAll = 0;
-		currentID.Fields.Priority = PROTOCAN_PRIORITY_STANDARD;
+		currentID.Fields.Priority = SETCAN_PRIORITY_STANDARD;
-		currentID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+		currentID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
 		currentID.Fields.DeviceType = CURRENT_TYPE_DEVICE;
 		currentID.Fields.DeviceID = CURRENT_ID_DEVICE;
-		currentID.Fields.MsgType = PROTOCAN_MSGTYPE_PULSE;
+		currentID.Fields.MsgType = SETCAN_MSGTYPE_PULSE;
 		currentID.Fields.MsgBody = 0;
 		TxHeader.ExtId = currentID.BitAll;
 		uint8_t data[8];
@@ -1354,7 +1354,7 @@ void ProtoCanPulseCallback(TIM_HandleTypeDef *htim)
 * @brief Функция установки в RTC полученной даты/время из запроса.
 * @param uint8_t *data - Байтовый массив, 7 элементов. [0] - Часы. [1] - Минуты. [2] - Секунды. [3] - Год. [4] - Месяц. [5] - Дата. [6] - День недели.
 */
-void PROTOCAN_RTC_SYNC(uint8_t *data)
+void SETCAN_RTC_SYNC(uint8_t *data)
 {
 	__HAL_RTC_WRITEPROTECTION_DISABLE(_HRTC);
 	RTC_TimeTypeDef sTime = {0};
@@ -1384,7 +1384,7 @@ void PROTOCAN_RTC_SYNC(uint8_t *data)
 * @param idFilter 32-битный идентификатор, используемый для фильтрации.
 * @param idMask 32-битная маска, определяющая биты, проверяемые фильтром.
 */
-void PROTOCAN_CONFIG_FILTER(uint8_t filterBank, uint32_t idFilter, uint32_t idMask)
+void SETCAN_CONFIG_FILTER(uint8_t filterBank, uint32_t idFilter, uint32_t idMask)
 {
 	CAN_FilterTypeDef canFilterConfig;
   canFilterConfig.FilterBank = filterBank;
@@ -1408,7 +1408,7 @@ void PROTOCAN_CONFIG_FILTER(uint8_t filterBank, uint32_t idFilter, uint32_t idMa
 /**
 * @brief Конфигурирует три фильтра CAN для различных типов сообщений.
 */
-void PROTOCAN_FILTERS()
+void SETCAN_FILTERS()
 {
 	#define BIT27 (1UL << 27)
 	#define BITS_20_23_MASK (0xFUL << 20)       // 4 бита (20..23)
@@ -1423,68 +1423,68 @@ void PROTOCAN_FILTERS()
 	#endif
 	#define BITS_16_19_MASK (0xFUL << 16)
 
-	uint32_t filter2_id = PROTOCAN_MSGTYPE_BROADCAST << 16;
+	uint32_t filter2_id = SETCAN_MSGTYPE_BROADCAST << 16;
 	uint32_t filter2_mask = BITS_16_19_MASK;
 
-	uint32_t filter3_id = PROTOCAN_MSGTYPE_PULSE << 16;
+	uint32_t filter3_id = SETCAN_MSGTYPE_PULSE << 16;
 	uint32_t filter3_mask = BITS_16_19_MASK;
 	
   // Первый фильтр: проверяем 20-27 биты, где 27-й всегда 1
-  PROTOCAN_CONFIG_FILTER(0, filter1_id, filter1_mask);
+  SETCAN_CONFIG_FILTER(0, filter1_id, filter1_mask);
 
-  // Второй фильтр: проверяем 16-19 биты, равны PROTOCAN_MSGTYPE_BROADCASTE
+  // Второй фильтр: проверяем 16-19 биты, равны SETCAN_MSGTYPE_BROADCASTE
-  PROTOCAN_CONFIG_FILTER(1, filter2_id, filter2_mask);
+  SETCAN_CONFIG_FILTER(1, filter2_id, filter2_mask);
 
-  // Третий фильтр: проверяем 16-19 биты, равны PROTOCAN_MSGTYPE_PULSE
+  // Третий фильтр: проверяем 16-19 биты, равны SETCAN_MSGTYPE_PULSE
-  PROTOCAN_CONFIG_FILTER(2, filter3_id, filter3_mask);
+  SETCAN_CONFIG_FILTER(2, filter3_id, filter3_mask);
 }
 
 /**
  * @brief Отправляет CAN-сообщение в зависимости от типа сообщения.
  * Эта функция анализирует тип сообщения в идентификаторе и вызывает 
  * соответствующую функцию отправки. В текущей реализации поддерживается только
- * тип PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE.
+ * тип SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE.
  * @param id   Идентификатор CAN-сообщения, содержащий информацию о типе.
  * @param data Структура с данными, которые необходимо отправить. Зависит от типа сообщения.
  * @return Статус выполнения операции.
  */
-PROTOCAN_StatusTypeDef PROTOCAN_SEND(ProtoCanId_t id, ProtoCanData_t data)
+SETCAN_StatusTypeDef SETCAN_SEND(SetCanId_t id, SetCanData_t data)
 {
 	switch(id.Fields.MsgType) 
 	{
-		case PROTOCAN_MSGTYPE_BROADCAST:
+		case SETCAN_MSGTYPE_BROADCAST:
-		case PROTOCAN_MSGTYPE_DISCRETE:
+		case SETCAN_MSGTYPE_DISCRETE:
-		case PROTOCAN_MSGTYPE_ANALOG:
+		case SETCAN_MSGTYPE_ANALOG:
 		{
-			return PROTOCAN_SEND_CORE(id, data.CoreData);
+			return SETCAN_SEND_CORE(id, data.CoreData);
 			break;
 		}
-		case PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE:
+		case SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE:
 		{
 			/* Если есть регистры для отправки, указатель data должен быть валиден. */      
 			if((data.GeneralAddressSpaceData.RegCount > 0U) && data.GeneralAddressSpaceData.Data == 0)
 			{
-				return PROTOCAN_ERROR;
+				return SETCAN_ERROR;
       }
-			return PROTOCAN_SEND_GENERAL_ADDRESS_SPACE(id, data.GeneralAddressSpaceData.RegStartAdr,
+			return SETCAN_SEND_GENERAL_ADDRESS_SPACE(id, data.GeneralAddressSpaceData.RegStartAdr,
 																										 data.GeneralAddressSpaceData.Data,
 																										 data.GeneralAddressSpaceData.RegCount);
     }
-		case PROTOCAN_MSGTYPE_MODBUS_COIL:
+		case SETCAN_MSGTYPE_MODBUS_COIL:
-		case PROTOCAN_MSGTYPE_MODBUS_DISCRETE:
+		case SETCAN_MSGTYPE_MODBUS_DISCRETE:
-		case PROTOCAN_MSGTYPE_MODBUS_HOLDING:
+		case SETCAN_MSGTYPE_MODBUS_HOLDING:
-		case PROTOCAN_MSGTYPE_MODBUS_INPUT:
+		case SETCAN_MSGTYPE_MODBUS_INPUT:
 		{
-			return PROTOCAN_SEND_MODBUS(id, data.ModbusData);
+			return SETCAN_SEND_MODBUS(id, data.ModbusData);
 			break;
 		}
-		case PROTOCAN_MSGTYPE_ERROR:
+		case SETCAN_MSGTYPE_ERROR:
 		{
-			return PROTOCAN_SEND_ERROR(id, data.ErrorData);
+			return SETCAN_SEND_ERROR(id, data.ErrorData);
 			break;
 		}
     default:
-			return PROTOCAN_ERROR;
+			return SETCAN_ERROR;
   }
-	return PROTOCAN_ERROR;
+	return SETCAN_ERROR;
 }

MDK-ARM/F103C8T6.uvprojx

@@ -406,14 +406,14 @@
               <FilePath>..\Core\Inc\canerrorbox.h</FilePath>
             </File>
             <File>
-              <FileName>protocan.c</FileName>
+              <FileName>setcan.c</FileName>
               <FileType>1</FileType>
-              <FilePath>..\Core\Src\protocan.c</FilePath>
+              <FilePath>..\Core\Src\setcan.c</FilePath>
             </File>
             <File>
-              <FileName>protocan.h</FileName>
+              <FileName>setcan.h</FileName>
               <FileType>5</FileType>
-              <FilePath>..\Core\Inc\protocan.h</FilePath>
+              <FilePath>..\Core\Inc\setcan.h</FilePath>
             </File>
             <File>
               <FileName>main.c</FileName>

MDK-ARM/F103C8T6/F103C8T6.lnp

@@ -1,7 +1,7 @@
 --cpu Cortex-M3
 "f103c8t6\startup_stm32f103xb.o"
 "f103c8t6\canerrorbox.o"
-"f103c8t6\protocan.o"
+"f103c8t6\setcan.o"
 "f103c8t6\main.o"
 "f103c8t6\gpio.o"
 "f103c8t6\can.o"

MDK-ARM/F103C8T6/can.d

@@ -30,4 +30,4 @@ f103c8t6/can.o: ..\Core\Src\can.c ..\Core\Inc\can.h ..\Core\Inc\main.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc_ex.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim_ex.h \
-  ..\Core\Inc\protocan.h ..\Core\Inc\canerrorbox.h
+  ..\Core\Inc\setcan.h ..\Core\Inc\canerrorbox.h

MDK-ARM/F103C8T6/canerrorbox.d

@@ -31,4 +31,4 @@ f103c8t6/canerrorbox.o: ..\Core\Src\canerrorbox.c \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc_ex.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim_ex.h \
-  ..\Core\Inc\protocan.h ..\Core\Inc\can.h
+  ..\Core\Inc\setcan.h ..\Core\Inc\can.h

MDK-ARM/F103C8T6/gpio.d

@@ -30,4 +30,4 @@ f103c8t6/gpio.o: ..\Core\Src\gpio.c ..\Core\Inc\gpio.h ..\Core\Inc\main.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc_ex.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim_ex.h \
-  ..\Core\Inc\protocan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h
+  ..\Core\Inc\setcan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h

MDK-ARM/F103C8T6/main.d

@@ -30,5 +30,5 @@ f103c8t6/main.o: ..\Core\Src\main.c ..\Core\Inc\main.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc_ex.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim_ex.h \
-  ..\Core\Inc\protocan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h \
+  ..\Core\Inc\setcan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h \
   ..\Core\Inc\rtc.h ..\Core\Inc\tim.h ..\Core\Inc\gpio.h

MDK-ARM/F103C8T6/protocan.d

@@ -1,33 +0,0 @@
-f103c8t6/protocan.o: ..\Core\Src\protocan.c ..\Core\Inc\protocan.h \
-  ..\Core\Inc\main.h ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal.h \
-  ..\Core\Inc\stm32f1xx_hal_conf.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rcc.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_def.h \
-  ..\Drivers\CMSIS\Device\ST\STM32F1xx\Include\stm32f1xx.h \
-  ..\Drivers\CMSIS\Device\ST\STM32F1xx\Include\stm32f103xb.h \
-  ..\Drivers\CMSIS\Include\core_cm3.h \
-  C:\Keil_v5\ARM\ARMCLANG\Bin\..\include\stdint.h \
-  ..\Drivers\CMSIS\Include\cmsis_version.h \
-  ..\Drivers\CMSIS\Include\cmsis_compiler.h \
-  ..\Drivers\CMSIS\Include\cmsis_armclang.h \
-  C:\Keil_v5\ARM\ARMCLANG\Bin\..\include\arm_compat.h \
-  C:\Keil_v5\ARM\ARMCLANG\Bin\..\include\arm_acle.h \
-  ..\Drivers\CMSIS\Device\ST\STM32F1xx\Include\system_stm32f1xx.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\Legacy\stm32_hal_legacy.h \
-  C:\Keil_v5\ARM\ARMCLANG\Bin\..\include\stddef.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rcc_ex.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_gpio.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_gpio_ex.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_exti.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_dma.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_dma_ex.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_can.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_cortex.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_flash.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_flash_ex.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_pwr.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc_ex.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim.h \
-  ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim_ex.h \
-  ..\Core\Inc\canerrorbox.h ..\Core\Inc\can.h

MDK-ARM/F103C8T6/rtc.d

@@ -30,4 +30,4 @@ f103c8t6/rtc.o: ..\Core\Src\rtc.c ..\Core\Inc\rtc.h ..\Core\Inc\main.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc_ex.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim_ex.h \
-  ..\Core\Inc\protocan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h
+  ..\Core\Inc\setcan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h

MDK-ARM/F103C8T6/stm32f1xx_hal_msp.d

@@ -30,4 +30,4 @@ f103c8t6/stm32f1xx_hal_msp.o: ..\Core\Src\stm32f1xx_hal_msp.c \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc_ex.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim_ex.h \
-  ..\Core\Inc\protocan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h
+  ..\Core\Inc\setcan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h

MDK-ARM/F103C8T6/stm32f1xx_it.d

@@ -30,5 +30,5 @@ f103c8t6/stm32f1xx_it.o: ..\Core\Src\stm32f1xx_it.c ..\Core\Inc\main.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc_ex.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim_ex.h \
-  ..\Core\Inc\protocan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h \
+  ..\Core\Inc\setcan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h \
   ..\Core\Inc\stm32f1xx_it.h

MDK-ARM/F103C8T6/tim.d

@@ -30,4 +30,4 @@ f103c8t6/tim.o: ..\Core\Src\tim.c ..\Core\Inc\tim.h ..\Core\Inc\main.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_rtc_ex.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim.h \
   ..\Drivers\STM32F1xx_HAL_Driver\Inc\stm32f1xx_hal_tim_ex.h \
-  ..\Core\Inc\protocan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h
+  ..\Core\Inc\setcan.h ..\Core\Inc\can.h ..\Core\Inc\canerrorbox.h