all_public/F103C8T6
16
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

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

Browse Source
This commit is contained in:
Вячеслав Штейбезандт
2026-09-01 13:43:27 +03:00
parent d37f99c57b
commit 06c305216c
16 changed files with 394 additions and 427 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Core/Inc/main.h
View File

@@ -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 */

208
Core/Inc/protocan.h → Core/Inc/setcan.h
View File

@@ -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,7 +171,7 @@ typedef enum {
typedef union{
struct msgBody_Analog{
unsigned SensorID:12; /**< Идентификатор датчика (12 бит). */
ProtoCanAnalogType Type:4; /**< Тип аналоговых данных (4 бита). */
SetCanAnalogType Type:4; /**< Тип аналоговых данных (4 бита). */
} Fields; /**< Структура с разбивкой по полям. */
unsigned Body; /**< Общее 16-битное представление сообщения. */
} msgBodyAnalogType;
@@ -213,16 +213,16 @@ struct controlflags{
* Объединение позволяет обращаться к различным полям идентификатора, а также как к 29-битному целому числу.
*/
typedef union{
struct protoCanIdFields{
struct SETCANIdFields{
unsigned MsgBody:16; /**< Поле сообщения (16 бит). */
ProtoCanMsgType MsgType:4; /**< Тип сообщения (4 бита). */
SetCanMsgType MsgType:4; /**< Тип сообщения (4 бита). */
unsigned DeviceID:4; /**< Идентификатор устройства (4 бита). */
unsigned DeviceType:3; /**< Тип устройства (3 бита). */
ProtoCanRouteType Route:1; /**< Маршрут (1 бит). */
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

4
Core/Src/main.c
View File

@@ -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 */

546
Core/Src/protocan.c → Core/Src/setcan.c
View File

@@ -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;
}

8
MDK-ARM/F103C8T6.uvprojx
View File

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

2
MDK-ARM/F103C8T6/F103C8T6.lnp
View File

@@ -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"

2
MDK-ARM/F103C8T6/can.d
View File

@@ -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

2
MDK-ARM/F103C8T6/canerrorbox.d
View File

@@ -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

2
MDK-ARM/F103C8T6/gpio.d
View File

@@ -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

2
MDK-ARM/F103C8T6/main.d
View File

@@ -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

BIN
MDK-ARM/F103C8T6/main.o
View File

Binary file not shown.

33
MDK-ARM/F103C8T6/protocan.d
View File

@@ -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

2
MDK-ARM/F103C8T6/rtc.d
View File

@@ -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

2
MDK-ARM/F103C8T6/stm32f1xx_hal_msp.d
View File

@@ -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

2
MDK-ARM/F103C8T6/stm32f1xx_it.d
View File

@@ -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

2
MDK-ARM/F103C8T6/tim.d
View File

@@ -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