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

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;
-ProtoCanDevice_t Device_on_the_Network[8][16];
+SetCanDevice_t CurrentDevice;
+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);
-			return PROTOCAN_INIT_HRTC_ERROR;
+			SETCAN_DEINIT(initStage);
+			return SETCAN_INIT_HRTC_ERROR;
 		}
 		#endif
 	}	else {
-		PROTOCAN_DEINIT(initStage);
-		return PROTOCAN_INIT_HCAN_ERROR;
+		SETCAN_DEINIT(initStage);
+		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);
-		return PROTOCAN_INIT_HRTC_ERROR;
+		SETCAN_DEINIT(initStage);
+		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);
-			return PROTOCAN_INIT_HRTC_ERROR;
+			SETCAN_DEINIT(initStage);
+			return SETCAN_INIT_HRTC_ERROR;
 		}
 		#endif
 	}
 	else
 	{
-		PROTOCAN_DEINIT(initStage);
-		return PROTOCAN_INIT_TIM_ERROR;
+		SETCAN_DEINIT(initStage);
+		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 ||
-                    rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_DISCRETE ||
-                    rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_HOLDING ||
-                    rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_INPUT)
+            else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_COIL ||
+                    rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_DISCRETE ||
+                    rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_HOLDING ||
+                    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 ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_DISCRETE ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_HOLDING ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_INPUT)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_COIL ||
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_DISCRETE ||
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_HOLDING ||
+			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;
-		if(result != PROTOCAN_OK)
+		CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
+		if(result != SETCAN_OK)
 		{
 			return result;
 		}
@@ -231,43 +231,43 @@ PROTOCAN_StatusTypeDef PROTOCAN_ProcessAllRxMsgs(void)
  * индекс текущего сообщения обновляется циклически.
  *
  * @return Прошедший статус обработки:
- * - PROTOCAN_OK, если сообщение успешно обработано,
- * - PROTOCAN_TIMEOUT, если сообщений не было,
+ * - SETCAN_OK, если сообщение успешно обработано,
+ * - 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 ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_DISCRETE ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_HOLDING ||
-			rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_MODBUS_INPUT)
+		else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_COIL ||
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_DISCRETE ||
+			rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_MODBUS_HOLDING ||
+			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.MsgType = PROTOCAN_MSGTYPE_ERROR;
+	tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
+	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;
-			ProtoCanId_t ExtID_Of_RX_MSG;
+			uint16_t tmp_LastStep = (uint16_t)(LastStep + 1) % SETCAN_RX_BUFFER_SIZE;
+			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.Route = PROTOCAN_ROUTE_FROM_DEVICE;
+		currentID.Fields.Priority = SETCAN_PRIORITY_STANDARD;
+		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
-  PROTOCAN_CONFIG_FILTER(1, filter2_id, filter2_mask);
+  // Второй фильтр: проверяем 16-19 биты, равны SETCAN_MSGTYPE_BROADCASTE
+  SETCAN_CONFIG_FILTER(1, filter2_id, filter2_mask);
 
-  // Третий фильтр: проверяем 16-19 биты, равны PROTOCAN_MSGTYPE_PULSE
-  PROTOCAN_CONFIG_FILTER(2, filter3_id, filter3_mask);
+  // Третий фильтр: проверяем 16-19 биты, равны SETCAN_MSGTYPE_PULSE
+  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 PROTOCAN_MSGTYPE_DISCRETE:
-		case PROTOCAN_MSGTYPE_ANALOG:
+		case SETCAN_MSGTYPE_BROADCAST:
+		case SETCAN_MSGTYPE_DISCRETE:
+		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 PROTOCAN_MSGTYPE_MODBUS_DISCRETE:
-		case PROTOCAN_MSGTYPE_MODBUS_HOLDING:
-		case PROTOCAN_MSGTYPE_MODBUS_INPUT:
+		case SETCAN_MSGTYPE_MODBUS_COIL:
+		case SETCAN_MSGTYPE_MODBUS_DISCRETE:
+		case SETCAN_MSGTYPE_MODBUS_HOLDING:
+		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;
 }