diff --git a/Core/Inc/main.h b/Core/Inc/main.h index 797fe49..ba8ee9d 100644 --- a/Core/Inc/main.h +++ b/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 */ diff --git a/Core/Inc/protocan.h b/Core/Inc/setcan.h similarity index 52% rename from Core/Inc/protocan.h rename to Core/Inc/setcan.h index 466f33c..feca0ef 100644 --- a/Core/Inc/protocan.h +++ b/Core/Inc/setcan.h @@ -1,5 +1,5 @@ -#ifndef _protocan -#define _protocan +#ifndef _SETCAN +#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, /**< Инициализация прошла успешно. */ - PROTOCAN_INIT_HCAN_ERROR = 0x01U, /**< Ошибка при инициализации модуля CAN. */ - PROTOCAN_INIT_HRTC_ERROR = 0x02U, /**< Ошибка при инициализации модуля RTC. */ - PROTOCAN_INIT_TIM_ERROR = 0x04U /**< Ошибка при инициализации таймера. */ -} PROTOCAN_INIT_StatusTypeDef; + SETCAN_INIT_OK = 0x00U, /**< Инициализация прошла успешно. */ + SETCAN_INIT_HCAN_ERROR = 0x01U, /**< Ошибка при инициализации модуля CAN. */ + SETCAN_INIT_HRTC_ERROR = 0x02U, /**< Ошибка при инициализации модуля RTC. */ + SETCAN_INIT_TIM_ERROR = 0x04U /**< Ошибка при инициализации таймера. */ +} SETCAN_INIT_StatusTypeDef; /** * @brief Статус выполнения операции протокола CAN. @@ -50,11 +50,11 @@ typedef enum */ typedef enum { - PROTOCAN_OK = 0x00U, /**< Операция прошла успешно. */ - PROTOCAN_ERROR = 0x01U, /**< Обнаружена ошибка во время выполнения. */ - PROTOCAN_BUSY = 0x02U, /**< Канал занят, выполнение невозможно в данный момент. */ - PROTOCAN_TIMEOUT = 0x03U /**< Истек таймаут ожидания. */ -} PROTOCAN_StatusTypeDef; + SETCAN_OK = 0x00U, /**< Операция прошла успешно. */ + SETCAN_ERROR = 0x01U, /**< Обнаружена ошибка во время выполнения. */ + SETCAN_BUSY = 0x02U, /**< Канал занят, выполнение невозможно в данный момент. */ + SETCAN_TIMEOUT = 0x03U /**< Истек таймаут ожидания. */ +} SETCAN_StatusTypeDef; /** * @brief Уровень приоритета CAN-сообщения. @@ -62,9 +62,9 @@ typedef enum * Это перечисление определяет важность и приоритет обработки сообщения. */ typedef enum { - PROTOCAN_PRIORITY_CRITICAL = 0, /**< Критический приоритет, рекомендуется обработка без задержек. */ - PROTOCAN_PRIORITY_STANDARD = 1 /**< Стандартный приоритет, менее важный. */ -} ProtoCanPriorityType; + SETCAN_PRIORITY_CRITICAL = 0, /**< Критический приоритет, рекомендуется обработка без задержек. */ + SETCAN_PRIORITY_STANDARD = 1 /**< Стандартный приоритет, менее важный. */ +} SetCanPriorityType; /** * @brief Маршрут CAN-сообщения. @@ -72,9 +72,9 @@ typedef enum { * Это перечисление задает направление маршрута отправки сообщения. */ typedef enum { - PROTOCAN_ROUTE_FROM_PM = 0, /**< Сообщение отправляется от управляющего модуля (PM). */ - PROTOCAN_ROUTE_FROM_DEVICE = 1 /**< Сообщение отправляется от устройства (Device). */ -} ProtoCanRouteType; + SETCAN_ROUTE_FROM_PM = 0, /**< Сообщение отправляется от управляющего модуля (PM). */ + SETCAN_ROUTE_FROM_DEVICE = 1 /**< Сообщение отправляется от устройства (Device). */ +} SetCanRouteType; /** * @brief Типы сообщений CAN. @@ -82,17 +82,17 @@ typedef enum { * Перечисление определяет различные типы сообщений, используемые в протоколе. */ typedef enum { - PROTOCAN_MSGTYPE_BROADCAST = 0b0000, /**< Широковещательное сообщение. */ - PROTOCAN_MSGTYPE_DISCRETE = 0b0001, /**< Дискретное цифровое сообщение. */ - PROTOCAN_MSGTYPE_ANALOG = 0b0010, /**< Аналоговое сообщение. */ - PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE = 0b0011, /**< Сообщение общего адресного пространства. */ - PROTOCAN_MSGTYPE_MODBUS_COIL = 0b0100, /**< Сообщение Modbus - Coil. */ - PROTOCAN_MSGTYPE_MODBUS_DISCRETE = 0b0101, /**< Сообщение Modbus - Discrete. */ - PROTOCAN_MSGTYPE_MODBUS_HOLDING = 0b0110, /**< Сообщение Modbus - Holding. */ - PROTOCAN_MSGTYPE_MODBUS_INPUT = 0b0111, /**< Сообщение Modbus - Input. */ - PROTOCAN_MSGTYPE_ERROR = 0b1000, /**< Сообщение об ошибке. */ - PROTOCAN_MSGTYPE_PULSE = 0b1111, /**< Импульсное сообщение. */ -}ProtoCanMsgType; + SETCAN_MSGTYPE_BROADCAST = 0b0000, /**< Широковещательное сообщение. */ + SETCAN_MSGTYPE_DISCRETE = 0b0001, /**< Дискретное цифровое сообщение. */ + SETCAN_MSGTYPE_ANALOG = 0b0010, /**< Аналоговое сообщение. */ + SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE = 0b0011, /**< Сообщение общего адресного пространства. */ + SETCAN_MSGTYPE_MODBUS_COIL = 0b0100, /**< Сообщение Modbus - Coil. */ + SETCAN_MSGTYPE_MODBUS_DISCRETE = 0b0101, /**< Сообщение Modbus - Discrete. */ + SETCAN_MSGTYPE_MODBUS_HOLDING = 0b0110, /**< Сообщение Modbus - Holding. */ + SETCAN_MSGTYPE_MODBUS_INPUT = 0b0111, /**< Сообщение Modbus - Input. */ + SETCAN_MSGTYPE_ERROR = 0b1000, /**< Сообщение об ошибке. */ + SETCAN_MSGTYPE_PULSE = 0b1111, /**< Импульсное сообщение. */ +} SetCanMsgType; /** * @brief Типы широковещательных сообщений CAN. @@ -100,12 +100,12 @@ typedef enum { * Перечисление задает различные типы широковещательных команд, используемых в протоколе. */ typedef enum { - PROTOCAN_BROADCAST_STATUS = 0b000000000000, /**< Статус устройства. */ - PROTOCAN_BROADCAST_ONOFF = 0b000000000001, /**< Включение/выключение устройства. */ - PROTOCAN_BROADCAST_RESTARTDEVICE = 0b000000000010, /**< Перезагрузка устройства. */ - PROTOCAN_BROADCAST_RTCSETUP = 0b000000000011, /**< Настройка RTC (часы реального времени). */ - PROTOCAN_BROADCAST_END = 0b111111111111 /**< Конец диапазона широковещательных сообщений. */ -}ProtoCanBroadcastType; + SETCAN_BROADCAST_STATUS = 0b000000000000, /**< Статус устройства. */ + SETCAN_BROADCAST_ONOFF = 0b000000000001, /**< Включение/выключение устройства. */ + SETCAN_BROADCAST_RESTARTDEVICE = 0b000000000010, /**< Перезагрузка устройства. */ + SETCAN_BROADCAST_RTCSETUP = 0b000000000011, /**< Настройка RTC (часы реального времени). */ + SETCAN_BROADCAST_END = 0b111111111111 /**< Конец диапазона широковещательных сообщений. */ +} 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, /**< Аварийное состояние. */ - PROTOCAN_DISCRETE_WARNING = 0b0001, /**< Предупредительный сигнал. */ - PROTOCAN_DISCRETE_CONTROL_SIGNALS = 0b0010, /**< Управляющие сигналы. */ - PROTOCAN_DISCRETE_FLAGS = 0b0011, /**< Флаги состояния. */ - PROTOCAN_DISCRETE_RESET = 0b0100, /**< Сброс устройства. */ - PROTOCAN_DISCRETE_CHANGE_MODE = 0b0101, /**< Смена режима работы. */ - PROTOCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS = 0b0110, /**< Запрос списка параметров. */ - PROTOCAN_DISCRETE_END = 0b1111 /**< Конец диапазона дискретных сообщений. */ -}ProtoCanDiscreteType; + SETCAN_DISCRETE_ACCIDENT = 0b0000, /**< Аварийное состояние. */ + SETCAN_DISCRETE_WARNING = 0b0001, /**< Предупредительный сигнал. */ + SETCAN_DISCRETE_CONTROL_SIGNALS = 0b0010, /**< Управляющие сигналы. */ + SETCAN_DISCRETE_FLAGS = 0b0011, /**< Флаги состояния. */ + SETCAN_DISCRETE_RESET = 0b0100, /**< Сброс устройства. */ + SETCAN_DISCRETE_CHANGE_MODE = 0b0101, /**< Смена режима работы. */ + SETCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS = 0b0110, /**< Запрос списка параметров. */ + SETCAN_DISCRETE_END = 0b1111 /**< Конец диапазона дискретных сообщений. */ +} 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, /**< Универсальный тип. */ - PROTOCAN_ANALOG_SETTINGS = 0b0001, /**< Настройки. */ - PROTOCAN_ANALOG_U = 0b0010, /**< Напряжение (U). */ - PROTOCAN_ANALOG_I = 0b0011, /**< Ток (I). */ - PROTOCAN_ANALOG_T = 0b0100, /**< Температура (T). */ - PROTOCAN_ANALOG_END = 0b1111 /**< Конец диапазона типов. */ -}ProtoCanAnalogType; + SETCAN_ANALOG_UNIVERSAL = 0b0000, /**< Универсальный тип. */ + SETCAN_ANALOG_SETTINGS = 0b0001, /**< Настройки. */ + SETCAN_ANALOG_U = 0b0010, /**< Напряжение (U). */ + SETCAN_ANALOG_I = 0b0011, /**< Ток (I). */ + SETCAN_ANALOG_T = 0b0100, /**< Температура (T). */ + SETCAN_ANALOG_END = 0b1111 /**< Конец диапазона типов. */ +} SetCanAnalogType; /** * @brief Структура и представление аналогового сообщения CAN. @@ -171,10 +171,10 @@ typedef enum { typedef union{ struct msgBody_Analog{ unsigned SensorID:12; /**< Идентификатор датчика (12 бит). */ - ProtoCanAnalogType Type:4; /**< Тип аналоговых данных (4 бита). */ + SetCanAnalogType Type:4; /**< Тип аналоговых данных (4 бита). */ } Fields; /**< Структура с разбивкой по полям. */ unsigned Body; /**< Общее 16-битное представление сообщения. */ -}msgBodyAnalogType; +} msgBodyAnalogType; /** * @brief Структура и представление сообщения Modbus CAN. @@ -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 бит). */ - ProtoCanPriorityType Priority:1; /**< Приоритет (1 бит). */ + SetCanRouteType Route: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 PROTOCAN_FILTERS(void); -void PROTOCAN_LoopProcessRxMsgs(void); -PROTOCAN_StatusTypeDef PROTOCAN_ProcessAllRxMsgs(void); -PROTOCAN_StatusTypeDef PROTOCAN_ProcessSingleRxMsg(void); -PROTOCAN_StatusTypeDef PROTOCAN_SEND(ProtoCanId_t id, ProtoCanData_t data); +void SETCAN_DEINIT(uint8_t stage); +void SETCAN_FILTERS(void); +void SETCAN_LoopProcessRxMsgs(void); +SETCAN_StatusTypeDef SETCAN_ProcessAllRxMsgs(void); +SETCAN_StatusTypeDef SETCAN_ProcessSingleRxMsg(void); +SETCAN_StatusTypeDef SETCAN_SEND(SetCanId_t id, SetCanData_t data); -void ProtoCanPulseCallback(TIM_HandleTypeDef *htim); -void ProtoCanRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan); +void SetCanPulseCallback(TIM_HandleTypeDef *htim); +void SetCanRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan); -PROTOCAN_StatusTypeDef PROTOCAN_BroadcastProcessing(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastStatus(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastOnOff(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRestart(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRtcSetup(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SETCAN_BroadcastProcessing(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToBroadcastStatus(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToBroadcastOnOff(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToBroadcastRestart(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToBroadcastRtcSetup(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef PROTOCAN_DiscreticProcessing(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteAccident(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteWarning(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteControlSignals(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteFlags(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteReset(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteChangeMode(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteRequestListOfParameters(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SETCAN_DiscreticProcessing(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToDiscreteAccident(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToDiscreteWarning(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToDiscreteControlSignals(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToDiscreteFlags(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToDiscreteReset(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToDiscreteChangeMode(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToDiscreteRequestListOfParameters(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef PROTOCAN_AnalogProcessing(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUniversal(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogSettings(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUSens(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogISens(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogTSens(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SETCAN_AnalogProcessing(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToAnalogUniversal(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToAnalogSettings(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToAnalogUSens(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToAnalogISens(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); -PROTOCAN_StatusTypeDef ProtoCanMsgToModbusCoil(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToModbusDiscrete(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToModbusHolding(struct RXMsg _rxMsg); -PROTOCAN_StatusTypeDef ProtoCanMsgToModbusInput(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SETCAN_ModbusProcessing(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToModbusCoil(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToModbusDiscrete(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToModbusHolding(struct RXMsg _rxMsg); +SETCAN_StatusTypeDef SetCanMsgToModbusInput(struct RXMsg _rxMsg); -void PROTOCAN_RTC_SYNC(uint8_t *data); +void SETCAN_RTC_SYNC(uint8_t *data); #endif diff --git a/Core/Src/main.c b/Core/Src/main.c index 96b2ff5..9ad735d 100644 --- a/Core/Src/main.c +++ b/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 */ diff --git a/Core/Src/protocan.c b/Core/Src/setcan.c similarity index 75% rename from Core/Src/protocan.c rename to Core/Src/setcan.c index 8691f2e..68a599c 100644 --- a/Core/Src/protocan.c +++ b/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; } \ No newline at end of file diff --git a/MDK-ARM/F103C8T6.uvprojx b/MDK-ARM/F103C8T6.uvprojx index e0d8de7..3b4ce2d 100644 --- a/MDK-ARM/F103C8T6.uvprojx +++ b/MDK-ARM/F103C8T6.uvprojx @@ -406,14 +406,14 @@ ..\Core\Inc\canerrorbox.h - protocan.c + setcan.c 1 - ..\Core\Src\protocan.c + ..\Core\Src\setcan.c - protocan.h + setcan.h 5 - ..\Core\Inc\protocan.h + ..\Core\Inc\setcan.h main.c diff --git a/MDK-ARM/F103C8T6/F103C8T6.lnp b/MDK-ARM/F103C8T6/F103C8T6.lnp index 7d74a0d..370f5d8 100644 --- a/MDK-ARM/F103C8T6/F103C8T6.lnp +++ b/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" diff --git a/MDK-ARM/F103C8T6/can.d b/MDK-ARM/F103C8T6/can.d index 9e9c38d..ddc68d3 100644 --- a/MDK-ARM/F103C8T6/can.d +++ b/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 diff --git a/MDK-ARM/F103C8T6/canerrorbox.d b/MDK-ARM/F103C8T6/canerrorbox.d index ba97ec1..736d2fc 100644 --- a/MDK-ARM/F103C8T6/canerrorbox.d +++ b/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 diff --git a/MDK-ARM/F103C8T6/gpio.d b/MDK-ARM/F103C8T6/gpio.d index c898027..99a0e06 100644 --- a/MDK-ARM/F103C8T6/gpio.d +++ b/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 diff --git a/MDK-ARM/F103C8T6/main.d b/MDK-ARM/F103C8T6/main.d index 510d025..3b65352 100644 --- a/MDK-ARM/F103C8T6/main.d +++ b/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 diff --git a/MDK-ARM/F103C8T6/main.o b/MDK-ARM/F103C8T6/main.o index d43b5c6..9897fbe 100644 Binary files a/MDK-ARM/F103C8T6/main.o and b/MDK-ARM/F103C8T6/main.o differ diff --git a/MDK-ARM/F103C8T6/protocan.d b/MDK-ARM/F103C8T6/protocan.d deleted file mode 100644 index 8fb9315..0000000 --- a/MDK-ARM/F103C8T6/protocan.d +++ /dev/null @@ -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 diff --git a/MDK-ARM/F103C8T6/rtc.d b/MDK-ARM/F103C8T6/rtc.d index 856e979..e220f1b 100644 --- a/MDK-ARM/F103C8T6/rtc.d +++ b/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 diff --git a/MDK-ARM/F103C8T6/stm32f1xx_hal_msp.d b/MDK-ARM/F103C8T6/stm32f1xx_hal_msp.d index 4e06b54..4af2ed9 100644 --- a/MDK-ARM/F103C8T6/stm32f1xx_hal_msp.d +++ b/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 diff --git a/MDK-ARM/F103C8T6/stm32f1xx_it.d b/MDK-ARM/F103C8T6/stm32f1xx_it.d index 2e8665e..4fa420f 100644 --- a/MDK-ARM/F103C8T6/stm32f1xx_it.d +++ b/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 diff --git a/MDK-ARM/F103C8T6/tim.d b/MDK-ARM/F103C8T6/tim.d index efcdccd..2d3d78d 100644 --- a/MDK-ARM/F103C8T6/tim.d +++ b/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