Templates/SETCAN
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init commit

Browse Source
This commit is contained in:
Claude Code Assistant
2026-08-20 17:24:34 +03:00
commit 3cf85a278e
2 changed files with 1837 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

320
Inc/protocan.h Normal file
View File

@@ -0,0 +1,320 @@
#ifndef _protocan
#define _protocan
#include "main.h"
#include "can.h"
#define _DEMO
#define ONLINE 1;
#define OFFLINE 0;
#define ID_MAIN_DEVICE 0x000
#define CURRENT_TYPE_DEVICE 0b001
#define CURRENT_ID_DEVICE 0b0010
#define PROTOCAN_RX_BUFFER_SIZE 128
#define SensorToModbusRegister(SensorType, SensorID) SensorType << 11 | SensorID
#define HighByteOfWord(WORD) (WORD>>8)&0xFF
#define LowByteOfWord(WORD) WORD&0xFF
/**
* @brief Статус инициализации протокола CAN.
*
* Это перечисление описывает возможные статусы после попытки инициализации.
*/
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;
/**
* @brief Статус выполнения операции протокола CAN.
*
* Это перечисление описывает возможные результаты выполнения функций протокола.
*/
typedef enum
{
PROTOCAN_OK = 0x00U, /**< Операция прошла успешно. */
PROTOCAN_ERROR = 0x01U, /**< Обнаружена ошибка во время выполнения. */
PROTOCAN_BUSY = 0x02U, /**< Канал занят, выполнение невозможно в данный момент. */
PROTOCAN_TIMEOUT = 0x03U /**< Истек таймаут ожидания. */
} PROTOCAN_StatusTypeDef;
/**
* @brief Уровень приоритета CAN-сообщения.
*
* Это перечисление определяет важность и приоритет обработки сообщения.
*/
typedef enum {
PROTOCAN_PRIORITY_CRITICAL = 0, /**< Критический приоритет, рекомендуется обработка без задержек. */
PROTOCAN_PRIORITY_STANDARD = 1 /**< Стандартный приоритет, менее важный. */
} ProtoCanPriorityType;
/**
* @brief Маршрут CAN-сообщения.
*
* Это перечисление задает направление маршрута отправки сообщения.
*/
typedef enum {
PROTOCAN_ROUTE_FROM_PM = 0, /**< Сообщение отправляется от управляющего модуля (PM). */
PROTOCAN_ROUTE_FROM_DEVICE = 1 /**< Сообщение отправляется от устройства (Device). */
} ProtoCanRouteType;
/**
* @brief Типы сообщений CAN.
*
* Перечисление определяет различные типы сообщений, используемые в протоколе.
*/
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;
/**
* @brief Типы широковещательных сообщений CAN.
*
* Перечисление задает различные типы широковещательных команд, используемых в протоколе.
*/
typedef enum {
PROTOCAN_BROADCAST_STATUS = 0b000000000000, /**< Статус устройства. */
PROTOCAN_BROADCAST_ONOFF = 0b000000000001, /**< Включение/выключение устройства. */
PROTOCAN_BROADCAST_RESTARTDEVICE = 0b000000000010, /**< Перезагрузка устройства. */
PROTOCAN_BROADCAST_RTCSETUP = 0b000000000011, /**< Настройка RTC (часы реального времени). */
PROTOCAN_BROADCAST_END = 0b111111111111 /**< Конец диапазона широковещательных сообщений. */
}ProtoCanBroadcastType;
/**
* @brief Структура и представление широковещательного сообщения CAN.
*
* Объединение позволяет обращаться к данным сообщения либо как к отдельным полям, либо как к целому 16-битному значению.
*/
typedef union{
struct msgBody_Broadcast{
unsigned Body:4; /**< Поле для дополнительных данных или кода задачи (4 бита). */
ProtoCanBroadcastType Type:12; /**< Тип широковещательного сообщения (12 бит). */
} Fields; /**< Структура с разбивкой по полям. */
unsigned Body; /**< Общее 16-битное представление сообщения. */
} msgBodyBroadcastType;
/**
* @brief Типы дискретных сообщений CAN.
*
* Перечисление задает различные виды дискретных команд или событий.
*/
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;
/**
* @brief Структура и представление дискретного сообщения CAN.
*
* Объединение позволяет обращаться к данным сообщения как к отдельным полям или как к целому 16-битному значению.
*/
typedef union{
struct msgBody_Discrete{
unsigned Body:12; /**< Поле данных или кода (12 бит). */
ProtoCanDiscreteType Type:4; /**< Тип дискретного сообщения (4 бита). */
} Fields; /**< Структура с разбивкой по полям. */
unsigned Body; /**< Общее 16-битное представление сообщения. */
} msgBodyDiscreteType;
/**
* @brief Типы аналоговых сообщений CAN.
*
* Перечисление определяет различные типы аналоговых данных или команд.
*/
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;
/**
* @brief Структура и представление аналогового сообщения CAN.
*
* Объединение позволяет обращаться к данным сообщения как к отдельным полям или как к целому 16-битному значению.
*/
typedef union{
struct msgBody_Analog{
unsigned SensorID:12; /**< Идентификатор датчика (12 бит). */
ProtoCanAnalogType Type:4; /**< Тип аналоговых данных (4 бита). */
} Fields; /**< Структура с разбивкой по полям. */
unsigned Body; /**< Общее 16-битное представление сообщения. */
}msgBodyAnalogType;
/**
* @brief Структура и представление сообщения Modbus CAN.
*
* Объединение позволяет обращаться к данным как к отдельным полям или как к целому 16-битному значению.
*/
typedef union{
struct msgBody_Modbus{
unsigned RegCount:4; /**< Количество регистров (4 бита). */
unsigned StrAdr:12; /**< Адрес строки или регистра (12 бит). */
} Fields; /**< Поля структуры сообщения Modbus. */
unsigned Body; /**< Общее 16-битное представление сообщения. */
} msgBodyModbusType;
/**
* @brief Структура и представление сообщения об ошибке CAN.
*
* Объединение позволяет обращаться к данным как к отдельным полям или как к целому 16-битному значению.
*/
typedef union{
struct msgBody_Error{
unsigned ErrorCode:8; /**< Код ошибки (8 бит). */
unsigned Info:8; /**< Дополнительная информация (8 бит). */
} Fields; /**< Поля ошибки. */
unsigned Body; /**< Общее 16-битное представление сообщения об ошибке. */
} msgBodyErrorType;
struct controlflags{
unsigned IsPulse:1;
unsigned IsRtrMode:1;
};
/**
* @brief Поля идентификатора протокола CAN.
*
* Объединение позволяет обращаться к различным полям идентификатора, а также как к 29-битному целому числу.
*/
typedef union{
struct protoCanIdFields{
unsigned MsgBody:16; /**< Поле сообщения (16 бит). */
ProtoCanMsgType MsgType:4; /**< Тип сообщения (4 бита). */
unsigned DeviceID:4; /**< Идентификатор устройства (4 бита). */
unsigned DeviceType:3; /**< Тип устройства (3 бита). */
ProtoCanRouteType Route:1; /**< Маршрут (1 бит). */
ProtoCanPriorityType Priority:1; /**< Приоритет (1 бит). */
} Fields; /**< Структура с разбивкой по полям. */
unsigned int BitAll:29; /**< Общее представление 29-битного идентификатора. */
} ProtoCanId_t;
/**
* @brief Структура для общего адресного пространства CAN.
*
* Используется для хранения данных о регистре и его содержимом.
*/
typedef struct{
struct ProtoCanCoreData{
uint16_t Type;
uint16_t Body;
uint8_t *Data;
unsigned DataCount;
} CoreData;
struct ProtoCanGeneralAddressSpaceData{
uint16_t RegStartAdr; /**< Начальный адрес регистров. */
uint16_t *Data; /**< Указатель на массив данных. */
unsigned RegCount; /**< Количество регистров. */
} GeneralAddressSpaceData;
struct ProtoCanModbusData{
uint16_t StrAdr;
uint16_t *Data;
unsigned RegCount:4;
} ModbusData;
struct ProtoCanErrorData{
uint16_t Info;
uint16_t Code;
} ErrorData;
} ProtoCanData_t;
/**
* @brief Структура данных устройства CAN.
*
* Включает статус, идентификатор, таймер последнего импульса и шаг последнего импульса.
*/
typedef struct{
unsigned Status:1; /**< Статус устройства (флаг). */
ProtoCanId_t Id; /**< Идентификатор CAN. */
unsigned TimeFromLastPulse; /**< Время с последнего импульса (мс). */
unsigned LastPulseStep; /**< Шаг последнего импульса. */
} ProtoCanDevice_t;
/**
* @brief Структура для хранения сообщения RXCAN.
*/
struct RXMsg {
/**
* @brief Структура, содержащая флаги информации.
*/
struct INFO {
unsigned EXT : 1; /**< Бит расширенного идентификатора (EXT). */
unsigned RTR : 1; /**< Бит запроса на передачу (RTR). */
} info; /**< Информационные флаги сообщения. */
ProtoCanId_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,
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 ProtoCanPulseCallback(TIM_HandleTypeDef *htim);
void ProtoCanRxFifo0MsgPendingCallback(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);
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);
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);
PROTOCAN_StatusTypeDef ProtoCanMsgToGeneralAddressSpace(struct RXMsg _rxMsg);
PROTOCAN_StatusTypeDef PROTOCAN_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);
void PROTOCAN_RTC_SYNC(uint8_t *data);
#endif

1517
Src/protocan.c Normal file
View File

@@ -0,0 +1,1517 @@
#include "protocan.h"
ProtoCanDevice_t CurrentDevice;
ProtoCanDevice_t Device_on_the_Network[8][16];
struct controlflags ControlFlags;
CAN_HandleTypeDef *_HCAN = 0;
RTC_HandleTypeDef *_HRTC = 0;
TIM_HandleTypeDef *_HTIM = 0;
/* CurrentStep - индекс следующего сообщения на обработку (пишет основной код).
LastStep - индекс последнего записанного сообщения (пишет ISR).
Оба индекса volatile: без этого компилятор вправе закэшировать значение в
регистре, т.к. в его модели исполнения прерывание в код не входит.
Сам массив rxMsg volatile НЕ объявлен - это ухудшило бы кодогенерацию и
мешало бы копированию структуры по значению. Порядок "заполнить слот, затем
опубликовать индекс" обеспечивается барьерами __DMB() в точках публикации и
чтения. */
volatile uint16_t CurrentStep = 1;
volatile uint16_t LastStep = 0;
struct RXMsg rxMsg[PROTOCAN_RX_BUFFER_SIZE];
/**
* @brief Проверяет, является ли год високосным.
* В системе год хранится как смещение от 2000. Например, значение 24 соответствует 2024.
* Эта функция добавляет 2000 к значению и проверяет, високосный ли получившийся год.
* @param year Смещение от 2000, тип uint8_t (от 0 до 255).
* @return _Bool true, если год високосный; false — иначе.
*/
_Bool IsLeapYear(uint8_t year)
{
year += 2000;
return (year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0));
}
/**
* @brief Возвращает количество доступных сообщений в буфере приёма CAN.
* Используется кольцевой буфер.
* Возвращаемое значение — количество элементов между указателями LastStep и CurrentStep.
* @return uint16_t Количество доступных сообщений, ожидающих обработки, в буфере.
*/
uint16_t AvailableCanRxMsg(void)
{
/* Однократное чтение индекса, обновляемого из ISR. */
uint16_t last = LastStep;
uint16_t current = CurrentStep;
/* Индекс прочитан до обращения к данным слота. */
__DMB();
return (uint16_t)(((unsigned)PROTOCAN_RX_BUFFER_SIZE + last - current + 1u) % PROTOCAN_RX_BUFFER_SIZE);
}
void PROTOCAN_DEINIT(uint8_t stage)
{
switch(stage)
{
case 3:
#if (USE_HAL_TIM_REGISTER_CALLBACKS == 1)
HAL_TIM_UnRegisterCallback(_HTIM, HAL_TIM_PERIOD_ELAPSED_CB_ID);
#endif
case 2:
case 1:
#if (USE_HAL_CAN_REGISTER_CALLBACKS == 1)
HAL_CAN_UnRegisterCallback(_HCAN, HAL_CAN_RX_FIFO0_MSG_PENDING_CB_ID);
#endif
}
return;
}
/**
* @brief Инициализация переферии
* @details Инициализация указателей на HCAN, HRTC, установка фильтров CAN.
* @note Фильтры CAN описаны в разделе PROTOCAN_CAN_FILTERS().
*/
PROTOCAN_INIT_StatusTypeDef PROTOCAN_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);
if(CAN_RC_RESULT != HAL_OK)
{
PROTOCAN_DEINIT(initStage);
return PROTOCAN_INIT_HCAN_ERROR;
}
#endif
} else {
PROTOCAN_DEINIT(initStage);
return PROTOCAN_INIT_HCAN_ERROR;
}
initStage++;
if(tmp_hrtc)
{
_HRTC = tmp_hrtc;
}
else
{
PROTOCAN_DEINIT(initStage);
return PROTOCAN_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);
if(TIM_RC_RESULT != HAL_OK)
{
PROTOCAN_DEINIT(initStage);
return PROTOCAN_INIT_TIM_ERROR;
}
#endif
}
else
{
PROTOCAN_DEINIT(initStage);
return PROTOCAN_INIT_TIM_ERROR;
}
initStage++;
PROTOCAN_FILTERS();
ControlFlags.IsPulse = 1;
return PROTOCAN_INIT_OK;
}
/**
* @brief Бесконечный цикл обработки входящих CAN-сообщений.
*
* Эта функция постоянно проверяет наличие доступных сообщений в буфере CAN и
* вызывает соответствующие обработчики в зависимости от типа полученного сообщения.
* Обрабатываемые типы сообщений:
* - Аналоговые данные
* - Широковещательные сообщения
* - Дискретные данные
* - Общее адресное пространство
* - Модбас сообщения
* - Ошибки
*
* Обработка сообщений осуществляется внутри бесконечного цикла с использованием
* функции AvailableCanRxMsg() для определения наличия новых сообщений.
*
* В конце каждого обработанного сообщения индекс текущего элемента буфера инкрементируется
* с учетом размера буфера через операцию по модулю.
*/
void PROTOCAN_LoopProcessRxMsgs(void)
{
while(1)
{
if(AvailableCanRxMsg())
{
if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ANALOG)
{
PROTOCAN_AnalogProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_BROADCAST)
{
PROTOCAN_BroadcastProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_DISCRETE)
{
PROTOCAN_DiscreticProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
{
ProtoCanMsgToGeneralAddressSpace(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)
{
PROTOCAN_ModbusProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ERROR)
{
PROTOCAN_RequestError(rxMsg[CurrentStep]);
}
// Обновление индекса текущего сообщения с циклическим масштабированием
CurrentStep = (uint16_t)(CurrentStep + 1) % PROTOCAN_RX_BUFFER_SIZE;
}
}
}
/**
* @brief Обрабатывает все доступные входящие CAN-сообщения.
*
* Эта функция последовательно обрабатывает все сообщения, доступные в буфере,
* вызывая соответствующие функции обработчики в зависимости от типа сообщения.
* После обработки каждого сообщения индекс текущего элемента буфера обновляется
* циклически.
*
* @return PROTOCAN_OK, если все сообщения были обработаны успешно.
* В противном случае возвращается код ошибки, полученный при обработке сообщения.
*
* Обработка происходит до тех пор, пока есть доступные сообщения, полученные функцией
* AvailableCanRxMsg().
*/
PROTOCAN_StatusTypeDef PROTOCAN_ProcessAllRxMsgs(void)
{
PROTOCAN_StatusTypeDef result = PROTOCAN_TIMEOUT;
while(AvailableCanRxMsg())
{
if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ANALOG)
{
result = PROTOCAN_AnalogProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_BROADCAST)
{
result = PROTOCAN_BroadcastProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_DISCRETE)
{
result = PROTOCAN_DiscreticProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
{
result = ProtoCanMsgToGeneralAddressSpace(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)
{
result = PROTOCAN_ModbusProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ERROR)
{
result = PROTOCAN_RequestError(rxMsg[CurrentStep]);
}
CurrentStep = (uint16_t)(CurrentStep + 1) % PROTOCAN_RX_BUFFER_SIZE;
if(result != PROTOCAN_OK)
{
return result;
}
}
return result;
}
/**
* @brief Обрабатывает одно доступное CAN-сообщение.
*
* Эта функция проверяет наличие доступных сообщений в буфере и, если таковое есть,
* выполняет обработку текущего сообщения в зависимости от его типа. После обработки
* индекс текущего сообщения обновляется циклически.
*
* @return Прошедший статус обработки:
* - PROTOCAN_OK, если сообщение успешно обработано,
* - PROTOCAN_TIMEOUT, если сообщений не было,
* - или код ошибки, возвращенный функцией обработки.
*/
PROTOCAN_StatusTypeDef PROTOCAN_ProcessSingleRxMsg(void)
{
PROTOCAN_StatusTypeDef result = PROTOCAN_TIMEOUT;
if(AvailableCanRxMsg())
{
if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ANALOG)
{
result = PROTOCAN_AnalogProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_BROADCAST)
{
result = PROTOCAN_BroadcastProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_DISCRETE)
{
result = PROTOCAN_DiscreticProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
{
result = ProtoCanMsgToGeneralAddressSpace(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)
{
result = PROTOCAN_ModbusProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == PROTOCAN_MSGTYPE_ERROR)
{
result = PROTOCAN_RequestError(rxMsg[CurrentStep]);
}
CurrentStep = (uint16_t)(CurrentStep + 1) % PROTOCAN_RX_BUFFER_SIZE;
}
return result;
}
/**
* @brief Функция обработки широковещательных запросов.
* @param struct RXMsg _rxMsg - структура для полученного сообщения.
* @details Функция, выполняющая команды, переданные в широковещательном формате с головного (master) устройства. Типы команд: Запрос статуса, запрос на включение или выключение, рестарт устройств, установка времени.
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
*/
PROTOCAN_StatusTypeDef PROTOCAN_BroadcastProcessing(struct RXMsg _rxMsg)
{
msgBodyBroadcastType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
switch(msg.Fields.Type)
{
case PROTOCAN_BROADCAST_STATUS:
{
//Обработка запроса статуса устройства
return ProtoCanMsgToBroadcastStatus(_rxMsg);
}
case PROTOCAN_BROADCAST_ONOFF:
{
//Обработка запроса на вкл/выкл
ProtoCanMsgToBroadcastOnOff(_rxMsg);
break;
}
case PROTOCAN_BROADCAST_RESTARTDEVICE:
{
ProtoCanMsgToBroadcastRestart(_rxMsg);
break;
}
case PROTOCAN_BROADCAST_RTCSETUP:
{
//Обработка запроса на синхронизацию времени
//С головным устройством
ProtoCanMsgToBroadcastRtcSetup(_rxMsg);
break;;
}
default:
//RESERVE SENSOR TYPE.
return PROTOCAN_ERROR;
break;
}
return PROTOCAN_OK;
}
/**
* @brief Формирует и отправляет широковещательное CAN-сообщение для ответа на запрос статуса.
* Устанавливает идентификатор, собирает текущие параметры времени и даты, и отправляет сообщение.
* @param _rxMsg Структура полученного по CAN запроса.
* @return HAL_StatusTypeDef Статус операции HAL, например HAL_OK при успехе.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastStatus(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.DLC = 7;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
tmp_eID.Fields.DeviceType = CURRENT_TYPE_DEVICE;
tmp_eID.Fields.DeviceID = CURRENT_ID_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
RTC_TimeTypeDef sTime = {0};
HAL_RTC_GetTime(_HRTC, &sTime, RTC_FORMAT_BIN);
data[0] = sTime.Hours;
data[1] = sTime.Minutes;
data[2] = sTime.Seconds;
RTC_DateTypeDef DateToUpdate = {0};
HAL_RTC_GetDate(_HRTC, &DateToUpdate, RTC_FORMAT_BIN);
data[3] = DateToUpdate.Year;
data[4] = DateToUpdate.Month;
data[5] = DateToUpdate.Date;
data[6] = DateToUpdate.WeekDay;
return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/**
* @brief Виртуальная слабая функция для переключения режима пульсации ON/OFF.
* Меняет состояние флага IsPulse в структуре ControlFlags.
* В данном случае — просто инвертирует его логическое значение.
* @param _rxMsg Структура полученного CAN-сообщения (Пока не используется в функции).
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastOnOff(struct RXMsg _rxMsg)
{
ControlFlags.IsPulse = !ControlFlags.IsPulse;
return PROTOCAN_OK;
}
/**
* @brief __weak функция для обработки широковещательного сообщения перезапуска устройства.
* Проверяет длину сообщения, извлекает ID из данных и, если она совпадает с текущим устройством,
* вызывает системный перезапуск.
* @param _rxMsg Структура полученного CAN-сообщения с командой перезапуска.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRestart(struct RXMsg _rxMsg)
{
if(_rxMsg.DLC == 0)
{
return PROTOCAN_ERROR;
}
msgBodyBroadcastType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
if(msg.Fields.Body == (CURRENT_ID_DEVICE / (_rxMsg.DLC*8)))
{
uint64_t page = 0;
for(uint32_t i = 0; i < _rxMsg.DLC; i++)
{
/* Приведение обязательно: Data[i] продвигается до int, и сдвиг на
32..56 бит без него - неопределённое поведение. */
page |= (uint64_t)_rxMsg.Data[i] << (i * 8u);
}
if((page >> CURRENT_ID_DEVICE) & 1u)
{
NVIC_SystemReset();
}
}
return PROTOCAN_OK;
}
/**
* @brief __weak функция для обработки запроса на синхронизацию RTC через широковещательное сообщение.
* Проверяет длину сообщения и корректность данных (время и дата). Если все проверки пройдены,
* вызывает функцию синхронизации RTC.
* @param _rxMsg Структура полученного CAN-сообщения с данными для установки времени и даты.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToBroadcastRtcSetup(struct RXMsg _rxMsg)
{
/* Нужны все 7 полей: чч, мм, сс, год, месяц, число, день недели.
Прежняя проверка (DLC > 7) пропускала в том числе пустой кадр, и время
устанавливалось из неинициализированных байт. */
if(_rxMsg.DLC != 7)
{
return PROTOCAN_ERROR;
}
else
{
static const uint8_t DaysCount_Normal[2][12] = {{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
/* Месяц нумеруется с 1, индекс массива - с 0. */
if( _rxMsg.Data[0] > 23 ||
_rxMsg.Data[1] > 59 ||
_rxMsg.Data[2] > 59 ||
_rxMsg.Data[3] > 99 ||
_rxMsg.Data[4] == 0 || _rxMsg.Data[4] > 12 ||
_rxMsg.Data[5] == 0 ||
_rxMsg.Data[5] > DaysCount_Normal[IsLeapYear(_rxMsg.Data[3])][_rxMsg.Data[4] - 1] ||
_rxMsg.Data[6] > 6)
{
return PROTOCAN_ERROR;
}
else
{
PROTOCAN_RTC_SYNC(_rxMsg.Data);
}
}
return PROTOCAN_OK;
}
/**
* @brief Функция обработки дискретных запросов.
* @param struct RXMsg _rxMsg - структура для полученного сообщения.
* @details Функция, формирующая и отправляющая ответ на запросы. Типы запросов: Аварии, Предупреждения, Управляющие сигналы, Флаги, Рестарт устройства, Изменение режима работы устройства, Запрос на устройство.
* @note Запрос на устройство. Головное (master) устройство запрашивает некоторое колличество параметров. В Data - 64 битовых адресса параметров, тип которых задаётся в Sensor ID. Имеется возможность запрашивать непоследовательные параметры.
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
*/
PROTOCAN_StatusTypeDef PROTOCAN_DiscreticProcessing(struct RXMsg _rxMsg)
{
msgBodyDiscreteType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
switch(msg.Fields.Type)
{
case PROTOCAN_DISCRETE_ACCIDENT:
{
ProtoCanMsgToDiscreteAccident(_rxMsg);
break;
}
case PROTOCAN_DISCRETE_WARNING:
{
ProtoCanMsgToDiscreteWarning(_rxMsg);
break;
}
case PROTOCAN_DISCRETE_CONTROL_SIGNALS:
{
ProtoCanMsgToDiscreteControlSignals(_rxMsg);
break;
}
case PROTOCAN_DISCRETE_FLAGS:
{
ProtoCanMsgToDiscreteFlags(_rxMsg);
break;
}
case PROTOCAN_DISCRETE_RESET:
{
ProtoCanMsgToDiscreteReset(_rxMsg);
break;
}
case PROTOCAN_DISCRETE_CHANGE_MODE:
{
ProtoCanMsgToDiscreteChangeMode(_rxMsg);
break;
}
case PROTOCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS:
{
ProtoCanMsgToDiscreteRequestListOfParameters(_rxMsg);
break;
}
default:
//RESERVE SENSOR TYPE.
return PROTOCAN_ERROR;
break;
}
return PROTOCAN_OK;
}
/**
* @brief Обработка запроса аварийных ситуаций.
* В текущей реализации — заглушка, ничего не выполняет.
* Можно реализовать отправку или обработку аварийных данных.
* @param _rxMsg Входящее сообщение с данными запроса.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteAccident(struct RXMsg _rxMsg)
{
return PROTOCAN_OK;
}
/**
* @brief Обработка запроса предупреждений.
* В текущей реализации — заглушка.
* Можно реализовать обработку или ответ на предупреждения.
* @param _rxMsg Входящее сообщение.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteWarning(struct RXMsg _rxMsg)
{
return PROTOCAN_OK;
}
/**
* @brief Обработка запроса управляющих сигналов.
* В текущей реализации — заглушка.
* Можно реализовать управление сигналами.
* @param _rxMsg Входящее сообщение.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteControlSignals(struct RXMsg _rxMsg)
{
return PROTOCAN_OK;
}
/**
* @brief Обработка запроса флагов.
* В текущей реализации — заглушка.
* Можно реализовать работу с флагами.
* @param _rxMsg Входящее сообщение.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteFlags(struct RXMsg _rxMsg)
{
return PROTOCAN_OK;
}
/**
* @brief Обработка рестарта системы по CAN-запросу.
* Выполняет программный рестарт системы.
* @param _rxMsg Входящее сообщение.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteReset(struct RXMsg _rxMsg)
{
NVIC_SystemReset();
return PROTOCAN_ERROR;
}
/**
* @brief Обработка запроса на изменение режима.
* В текущей реализации — заглушка.
* Можно реализовать изменение режима работы.
* @param _rxMsg Входящее сообщение.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteChangeMode(struct RXMsg _rxMsg)
{
return PROTOCAN_OK;
}
/**
* @brief Обработка запроса на получение списка параметров.
* В текущей реализации — заглушка.
* Можно реализовать отправку списка параметров.
* @param _rxMsg Входящее сообщение.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToDiscreteRequestListOfParameters(struct RXMsg _rxMsg)
{
return PROTOCAN_OK;
}
/**
* @brief Функция обработки аналоговых запросов.
* @param struct RXMsg _rxMsg - структура для полученного сообщения.
* @details Функция, сортирующая запросы по типам и вызывающая соответствующие функции. Типы запросов: Универсальный, Уставки, Напряжение, Ток, Температура.
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
*/
PROTOCAN_StatusTypeDef PROTOCAN_AnalogProcessing(struct RXMsg _rxMsg)
{
msgBodyAnalogType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
switch (msg.Fields.Type)
{
case PROTOCAN_ANALOG_UNIVERSAL:
{
return ProtoCanMsgToAnalogUniversal(_rxMsg);
break;
}
case PROTOCAN_ANALOG_SETTINGS:
{
return ProtoCanMsgToAnalogSettings(_rxMsg);
break;
}
case PROTOCAN_ANALOG_U:
{
return ProtoCanMsgToAnalogUSens(_rxMsg);
break;
}
case PROTOCAN_ANALOG_I:
{
return ProtoCanMsgToAnalogISens(_rxMsg);
break;
}
case PROTOCAN_ANALOG_T:
{
return ProtoCanMsgToAnalogTSens(_rxMsg);
break;
}
default:
//RESERVE SENSOR TYPE
return PROTOCAN_ERROR;
break;
}
return PROTOCAN_ERROR;
}
/**
* @brief Функция ответа на запрос данных со всех датчиков.
* Создает сообщение с определенными данными и отправляет его через CAN-шину.
* @param _rxMsg Структура входящего сообщения, используется для формирования ID.
* @return HAL_StatusTypeDef Статус выполнения операции HAL, например HAL_OK.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUniversal(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 6;
data[0] = 'U';
data[1] = 'N';
data[2] = 'I';
data[3] = 'V';
data[4] = 'E';
data[5] = 'R';
return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/**
* @brief Функция ответа на запрос уставок по CAN.
* Создает сообщение с определенными данными и отправляет его через CAN-шину.
* @param _rxMsg Структура входящего сообщения, используется только для формирования ID.
* @return HAL_StatusTypeDef Статус выполнения операции HAL, например HAL_OK.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogSettings(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 7;
data[0] = 'U';
data[1] = 'S';
data[2] = 'T';
data[3] = 'A';
data[4] = 'V';
data[5] = 'K';
data[6] = 'I';
return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/**
* @brief Функция ответа на запрос данных с датчиков напряжения.
* Создает сообщение с указанными параметрами и отправляет его через CAN-шину.
* @param _rxMsg Структура входящего сообщения, используемая для формирования идентификатора и данных.
* @return HAL_StatusTypeDef Статус выполнения операции HAL, например HAL_OK при успешной отправке.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogUSens(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 6;
msgBodyAnalogType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
data[0] = 'U';
data[1] = 'S';
data[2] = '0' + msg.Fields.SensorID / 1000;
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);
}
/**
* @brief Функция ответа на запрос данных с датчиков тока.
* Создает сообщение с определенными параметрами и отправляет его через CAN-шину.
* @param _rxMsg Структура входящего сообщения, используется для формирования идентификатора и данных.
* @return HAL_StatusTypeDef Статус операции HAL, например HAL_OK при успешной отправке.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogISens(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 6;
msgBodyAnalogType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
data[0] = 'I';
data[1] = 'S';
data[2] = '0' + msg.Fields.SensorID / 1000;
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);
}
/**
* @brief Функция ответа на запрос данных с датчиков температуры.
* Создает сообщение с определенным заголовком, формирует данные по ID сенсора и отправляет его через CAN.
* @param _rxMsg Структура полученного сообщения, которая используется для формирования идентификатора.
* @return HAL_StatusTypeDef Статус выполнения функции HAL, например HAL_OK при успехе.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToAnalogTSens(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 6;
msgBodyAnalogType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
data[0] = 'T';
data[1] = 'S';
data[2] = '0' + msg.Fields.SensorID / 1000;
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);
}
/**
* @brief Отправляет сообщение по CAN-шине в соответствии с типом протокола.
* Эта функция формирует и отправляет сообщение через CAN-шину, основываясь на типе
* переданного ID и данных. Поддерживаются типы сообщений: широковещательные, дискретные
* и аналоговые.
* @param id Идентификатор сообщения, содержащий тип сообщения и другую информацию.
* @param coreData Структура данных, включающая тип, тело и данные для передачи.
* @return PROTOCAN_StatusTypeDef Статус операции.
* @details
* В зависимости от типа сообщения (панель broadcast, discrete или analog),
* формируется соответствующий пакет данных и отправляется на шину CAN.
* Для сообщений, превышающих длину 8 байт, передача выполняется пакетами.
* В случае ошибок при добавлении сообщения в очередь передачи, возвращается ошибка.
*/
PROTOCAN_StatusTypeDef PROTOCAN_SEND_CORE(const ProtoCanId_t id, const struct ProtoCanCoreData coreData)
{
ProtoCanId_t localId = id;
CAN_TxHeaderTypeDef TxHeader;
TxHeader.IDE = CAN_ID_EXT;
TxHeader.RTR = CAN_RTR_DATA;
TxHeader.TransmitGlobalTime = DISABLE;
uint32_t TxMailBox = 0;
uint8_t canData[8];
switch(id.Fields.MsgType)
{
case PROTOCAN_MSGTYPE_BROADCAST:
{
msgBodyBroadcastType body;
body.Fields.Type = coreData.Type;
body.Fields.Body = coreData.Body;
localId.Fields.MsgBody = body.Body;
TxHeader.ExtId = localId.BitAll;
TxHeader.DLC = 0;
if(HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox) != HAL_OK)
{
return PROTOCAN_ERROR;
}
break;
}
case PROTOCAN_MSGTYPE_DISCRETE:
{
msgBodyDiscreteType body;
body.Fields.Type = coreData.Type;
uint8_t regsRemaining = coreData.DataCount;
uint8_t currentIndex = 0;
while(regsRemaining > 0)
{
uint8_t regsInPacket = (regsRemaining > 8) ? 8 : regsRemaining;
body.Fields.Body = coreData.Body + currentIndex;
localId.Fields.MsgBody = body.Body;
TxHeader.ExtId = localId.BitAll;
TxHeader.DLC = regsInPacket;
for(int i = 0; i < regsInPacket; i++)
{
canData[i] = coreData.Data[currentIndex + i];
}
HAL_StatusTypeDef status = HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox);
if(status != HAL_OK)
{
return (PROTOCAN_StatusTypeDef)status;
}
regsRemaining -= regsInPacket;
currentIndex += regsInPacket;
}
break;
}
case PROTOCAN_MSGTYPE_ANALOG:
{
msgBodyAnalogType body;
body.Fields.Type = coreData.Type;
uint8_t regsRemaining = coreData.DataCount;
uint8_t currentIndex = 0;
while(regsRemaining > 0)
{
uint8_t regsInPacket = (regsRemaining > 8) ? 8 : regsRemaining;
body.Fields.SensorID = coreData.Body + currentIndex;
localId.Fields.MsgBody = body.Body;
TxHeader.ExtId = localId.BitAll;
TxHeader.DLC = regsInPacket;
for(int i = 0; i < regsInPacket; i++)
{
canData[i] = coreData.Data[currentIndex + i];
}
HAL_StatusTypeDef status = HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox);
if(status != HAL_OK)
{
return (PROTOCAN_StatusTypeDef)status;
}
regsRemaining -= regsInPacket;
currentIndex += regsInPacket;
}
break;
}
default:
{
return PROTOCAN_ERROR;
}
}
return PROTOCAN_OK;
}
/**
* @brief Обработка и ответ на запрос общего адресного пространства.
* Формирует и передает сообщение с данными о статусе "GAS-XXXX", где XXXX — значение из сообщения _rxMsg.
* @param _rxMsg Структура входящего сообщения, содержит идентификатор и тело сообщения.
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToGeneralAddressSpace(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 8;
data[0] = 'G';
data[1] = 'A';
data[2] = 'S';
data[3] = '-';
for(int i = 0; i < 4; i++)
{
unsigned sym = (_rxMsg.eID.Fields.MsgBody >> (12 - (i * 4))) & 0xF;
if(sym >= 10)
{
data[4 + i] = sym % 10 + 'A';
}
else
{
data[4 + i] = sym + '0';
}
}
return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/**
* @brief Отправляет произвольный диапазон регистров в пакетах по, максимум, 4 регистра за раз через CAN.
* Функция разбивает передаваемый массив регистров на пакеты по 4 или меньше и отправляет их по отдельности.
* Для каждого пакета формируется уникальный MsgBody, равный адресу первого регистра в пакете.
* @param priority Приоритет сообщения CAN. ProtoCan_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)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t canData[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = id.BitAll;
uint8_t regsRemaining = regCount;
uint8_t currentIndex = 0;
while(regsRemaining > 0)
{
uint8_t regsInPacket = (regsRemaining > 4) ? 4 : regsRemaining;
tmp_eID.Fields.MsgBody = regStartAdr + currentIndex;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = regsInPacket*2;
for(int i = 0; i < regsInPacket; i++)
{
canData[(i * 2)] = LowByteOfWord(data[currentIndex + i]);
canData[(i * 2) + 1] = HighByteOfWord(data[currentIndex + i]);
}
HAL_StatusTypeDef status = HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox);
if(status != HAL_OK)
{
return (PROTOCAN_StatusTypeDef)status;
}
regsRemaining -= regsInPacket;
currentIndex += regsInPacket;
}
return (PROTOCAN_StatusTypeDef)HAL_OK;
}
/**
* @brief Обработка запроса на основе типа Modbus.
* В зависимости от типа сообщения, вызывает соответствующую функцию
* для отправки Modbus-запроса по CAN-шине.
* @param _rxMsg Структура входящего сообщения RXMsg.
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
*/
PROTOCAN_StatusTypeDef PROTOCAN_ModbusProcessing(struct RXMsg _rxMsg)
{
switch(_rxMsg.eID.Fields.MsgType)
{
case PROTOCAN_MSGTYPE_MODBUS_COIL:
{
return ProtoCanMsgToModbusCoil(_rxMsg);
break;
}
case PROTOCAN_MSGTYPE_MODBUS_DISCRETE:
{
return ProtoCanMsgToModbusDiscrete(_rxMsg);
break;
}
case PROTOCAN_MSGTYPE_MODBUS_HOLDING:
{
return ProtoCanMsgToModbusHolding(_rxMsg);
break;
}
case PROTOCAN_MSGTYPE_MODBUS_INPUT:
{
return ProtoCanMsgToModbusInput(_rxMsg);
break;
}
default:
//ERROR
return PROTOCAN_ERROR;
break;
}
return PROTOCAN_ERROR;
}
/**
* @brief __weak Функция отправки ответа на запрос Coil Modbus по CAN.
* Формирует CAN ответ на запрос Coil Modbus и отправляет его.
* @param _rxMsg Структура входящего сообщения RXMsg.
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusCoil(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 8;
msgBodyModbusType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
data[0] = 'M';
data[1] = 'C';
data[2] = ' ';
data[3] = 'S';
data[4] = msg.Fields.StrAdr;
data[5] = ' ';
data[6] = 'C';
data[7] = msg.Fields.RegCount;
return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/**
* @brief __weak Функция отправки ответа на запрос Discrete Modbus по CAN.
* Формирует CAN ответ на запрос Discrete Modbus и отправляет его.
* @param _rxMsg Структура входящего сообщения RXMsg.
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusDiscrete(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 8;
msgBodyModbusType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
data[0] = 'M';
data[1] = 'D';
data[2] = ' ';
data[3] = 'S';
data[4] = msg.Fields.StrAdr;
data[5] = ' ';
data[6] = 'C';
data[7] = msg.Fields.RegCount;
return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/**
* @brief __weak Функция отправки ответа на запрос Holding Modbus по CAN.
* Формирует CAN ответ на запрос Holding Modbus и отправляет его.
* @param _rxMsg Структура входящего сообщения RXMsg.
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusHolding(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 8;
msgBodyModbusType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
data[0] = 'M';
data[1] = 'H';
data[2] = ' ';
data[3] = 'S';
data[4] = msg.Fields.StrAdr;
data[5] = ' ';
data[6] = 'C';
data[7] = msg.Fields.RegCount;
return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/**
* @brief __weak Функция отправки ответа на запрос Input Modbus по CAN.
* Формирует CAN ответ на запрос Input Modbus и отправляет его.
* @param _rxMsg Структура входящего сообщения RXMsg.
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
*/
__weak PROTOCAN_StatusTypeDef ProtoCanMsgToModbusInput(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 8;
msgBodyModbusType msg;
msg.Body = _rxMsg.eID.Fields.MsgBody;
data[0] = 'M';
data[1] = 'I';
data[2] = ' ';
data[3] = 'S';
data[4] = msg.Fields.StrAdr;
data[5] = ' ';
data[6] = 'C';
data[7] = msg.Fields.RegCount;
return (PROTOCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/**
* @brief Отправляет данные Modbus через CAN-шину в соответствии с типом сообщения.
* Эта функция формирует и отправляет Modbus-данные по CAN-шине, поддерживая
* различные типы сообщений: Coil, Discrete, Holding Register и Input Register.
* Для сообщений, превышающих 4 регистров, данные отправляются пакетами.
* @param id Идентификатор сообщения, содержащий тип сообщения и другую информацию.
* @param modbusData Структура с данными Modbus: адрес, количество регистров и сами данные.
* @return PROTOCAN_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)
{
ProtoCanId_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)
{
// Формируем body
msgBodyModbusType body;
body.Fields.StrAdr = modbusData.StrAdr;
body.Fields.RegCount = modbusData.RegCount;
// Устанавливаем коллизию ExtId с body.Body
localId.Fields.MsgBody = (body.Body & 0xFFFF);
// Обновляем ExtId
TxHeader.ExtId = localId.BitAll;
// Остальные настройки
TxHeader.IDE = CAN_ID_EXT;
TxHeader.RTR = CAN_RTR_DATA;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.DLC = modbusData.RegCount % 8 + 1;
// Формируем CAN данные
canData[0] = LowByteOfWord(modbusData.Data[0]);
canData[1] = HighByteOfWord(modbusData.Data[0]);
if (HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox) != HAL_OK)
{
return PROTOCAN_ERROR;
}
}
else if(msgType == PROTOCAN_MSGTYPE_MODBUS_HOLDING || msgType == PROTOCAN_MSGTYPE_MODBUS_INPUT)
{
uint16_t* dataPtr = modbusData.Data;
unsigned totalRegs = modbusData.RegCount;
unsigned regsProcessed = 0;
unsigned startAddress = modbusData.StrAdr;
while (regsProcessed < totalRegs)
{
uint8_t regsInPacket = (totalRegs - regsProcessed) > 4 ? 4 : (totalRegs - regsProcessed);
// Формируем body
msgBodyModbusType body;
body.Fields.StrAdr = startAddress;
body.Fields.RegCount = regsInPacket;
// Обновляем ExtId
localId.Fields.MsgBody = (body.Body & 0xFFFF);
TxHeader.ExtId = localId.BitAll;
TxHeader.IDE = CAN_ID_EXT;
TxHeader.RTR = CAN_RTR_DATA;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.DLC = regsInPacket * 2;
// Добавляем регистры
for (int i = 0; i < regsInPacket; i++)
{
canData[i * 2] = LowByteOfWord(dataPtr[regsProcessed + i]);
canData[i * 2 + 1] = HighByteOfWord(dataPtr[regsProcessed + i]);
}
// Отправляем сообщение
if(HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox) != HAL_OK)
{
return PROTOCAN_ERROR;
}
regsProcessed += regsInPacket;
startAddress += regsInPacket;
}
}
else
{
return PROTOCAN_ERROR; // Неверный тип сообщения
}
return PROTOCAN_OK;
}
/**
* @brief __weak Функция отправки сообщения об ошибке.
* Посылает CAN сообщение с кодом ошибки. Используется, когда необходимо оповестить о неуспешной операции.
* @param _rxMsg Структура входящего сообщения RXMsg, данными которого формируется ответ-ошибка.
* @return HAL_StatusTypeDef Статус выполнения команды CAN.
*/
__weak PROTOCAN_StatusTypeDef PROTOCAN_RequestError(struct RXMsg _rxMsg)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
ProtoCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
tmp_eID.Fields.MsgType = PROTOCAN_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);
}
/**
* @brief Отправляет сообщение об ошибке по CAN-шине.
* Эта функция формирует и отправляет сообщение об ошибке с кодом и информацией,
* объединёнными в поле MsgBody идентификатора сообщения, и передаёт его через CAN.
* @param id Идентификатор сообщения, содержащий базовую информацию.
* @param errorData Структура с данными ошибки: код и дополнительная информация.
* @return PROTOCAN_StatusTypeDef Статус операции.
* @details
* В качестве данных передаётся 2 байта: старшие биты — информация об ошибке, младшие — код ошибки.
* Размер данных в CANFrames устанавливается нулевым, так как все данные инкапсулированы в MsgBody.
*/
PROTOCAN_StatusTypeDef PROTOCAN_SEND_ERROR(const ProtoCanId_t id, const struct ProtoCanErrorData errorData)
{
ProtoCanId_t localId = id;
// Структура для отправки
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t canData[8];
localId.Fields.MsgBody = ((errorData.Info << 8) | errorData.Code);
// Обновляем ExtId
TxHeader.ExtId = localId.BitAll;
// Остальные настройки
TxHeader.IDE = CAN_ID_EXT;
TxHeader.RTR = CAN_RTR_DATA;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.DLC = 0;
if(HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox) != HAL_OK)
{
return PROTOCAN_ERROR;
}
return PROTOCAN_OK;
}
/**
* @brief Записывает полученное сообщение CAN в буфер rxMsg.
* Копирует параметры расширенного ID, типы, длину данных и сам данные в указанный элемент буфера.
* @param tmp_eID Расширенный ID сообщения.
* @param tmp_IDE Тип идентификатора (например, CAN_ID_EXT).
* @param tmp_RTR Тип запроса (например, CAN_RTR_DATA).
* @param tmp_DLC Длина данных в сообщении.
* @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)
{
if(tmp_DLC > 8u)
{
tmp_DLC = 8u;
}
rxMsg[tmp_LastStep].eID.BitAll = tmp_eID.BitAll;
rxMsg[tmp_LastStep].info.EXT = tmp_IDE;
rxMsg[tmp_LastStep].info.RTR = tmp_RTR;
rxMsg[tmp_LastStep].DLC = tmp_DLC;
for(uint32_t i = 0; i < tmp_DLC; i++)
{
rxMsg[tmp_LastStep].Data[i] = tmp_DATA[i];
}
/* Слот заполнен - только теперь публикуем его. Без барьера компилятору
разрешено поднять запись LastStep выше записей в rxMsg, и обработчик
увидит наполовину заполненное сообщение. */
__DMB();
LastStep = tmp_LastStep;
}
/**
* @brief Обработка сообщений, ожидающих в FIFO, по прерыванию HAL_CAN_RxFifo0MsgPendingCallback.
* Читает все сообщения из FIFO, проверяет их тип, обновляет статус устройств сети или сохраняет сообщение в буфер.
* @param hcan Указатель на структуру управления CAN-Hardware.
*/
void ProtoCanRxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
//Обработка всех сообщений в FIFO
CAN_RxHeaderTypeDef RxHeader;
uint8_t RCAN_Data[8];
while(HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHeader, RCAN_Data) == HAL_OK)
{
//Расширенный ID
if(RxHeader.IDE == CAN_ID_EXT)
{
ProtoCanId_t ExtID_Of_RX_MSG;
ExtID_Of_RX_MSG.BitAll = RxHeader.ExtId;
//Полученное сообщение - пульс устройств в сети.
//Место в буфере не занимает, поэтому проверяется до проверки переполнения.
if(ExtID_Of_RX_MSG.Fields.MsgType == PROTOCAN_MSGTYPE_PULSE)
{
Device_on_the_Network[ExtID_Of_RX_MSG.Fields.DeviceType][ExtID_Of_RX_MSG.Fields.DeviceID].Status = 1u;
Device_on_the_Network[ExtID_Of_RX_MSG.Fields.DeviceType][ExtID_Of_RX_MSG.Fields.DeviceID].TimeFromLastPulse = 0;
//continue, а не return: остаток FIFO нужно вычитать в этом же вызове,
//иначе прерывание по непустому FIFO сработает повторно.
continue;
}
//Полезная ёмкость буфера - (PROTOCAN_RX_BUFFER_SIZE - 1): при большем
//заполнении счётчик AvailableCanRxMsg() переполняется и даёт 0 ("пусто").
if(AvailableCanRxMsg() >= (PROTOCAN_RX_BUFFER_SIZE - 1u))
{
//Буфер переполнен, кадр отбрасывается. Кадр уже извлечён из
//аппаратного FIFO, поэтому продолжаем вычитывать остаток.
continue;
}
uint16_t tmp_LastStep = (uint16_t)((LastStep + 1u) % PROTOCAN_RX_BUFFER_SIZE);
TakeRxMsgToBuffer(ExtID_Of_RX_MSG, RxHeader.IDE, RxHeader.RTR, RxHeader.DLC, RCAN_Data, tmp_LastStep);
}
}
}
/**
* @brief Функция отправки пульса устройства.
* @details Пульс устройства. Есть возможность отключить пульс по запросу.
*/
void ProtoCanPulseCallback(TIM_HandleTypeDef *htim)
{
if(ControlFlags.IsPulse)
{
static unsigned PulseStage = 0;
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
ProtoCanId_t currentID;
currentID.BitAll = 0;
currentID.Fields.Priority = PROTOCAN_PRIORITY_STANDARD;
currentID.Fields.Route = PROTOCAN_ROUTE_FROM_DEVICE;
currentID.Fields.DeviceType = CURRENT_TYPE_DEVICE;
currentID.Fields.DeviceID = CURRENT_ID_DEVICE;
currentID.Fields.MsgType = PROTOCAN_MSGTYPE_PULSE;
currentID.Fields.MsgBody = 0;
TxHeader.ExtId = currentID.BitAll;
uint8_t data[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
TxHeader.DLC = 1;
PulseStage++;
if(PulseStage > 0xFF)
{
PulseStage = 0;
}
data[0] = PulseStage;
HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
}
/**
* @brief Функция установки в RTC полученной даты/время из запроса.
* @param uint8_t *data - Байтовый массив, 7 элементов. [0] - Часы. [1] - Минуты. [2] - Секунды. [3] - Год. [4] - Месяц. [5] - Дата. [6] - День недели.
*/
void PROTOCAN_RTC_SYNC(uint8_t *data)
{
__HAL_RTC_WRITEPROTECTION_DISABLE(_HRTC);
RTC_TimeTypeDef sTime = {0};
RTC_DateTypeDef DateToUpdate = {0};
sTime.Hours = data[0];
sTime.Minutes = data[1];
sTime.Seconds = data[2];
if(HAL_RTC_SetTime(_HRTC, &sTime, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
DateToUpdate.Year = data[3];
DateToUpdate.Month = data[4];
DateToUpdate.Date = data[5];
DateToUpdate.WeekDay = data[6];
if(HAL_RTC_SetDate(_HRTC, &DateToUpdate, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
__HAL_RTC_WRITEPROTECTION_ENABLE(_HRTC);
}
/**
* @brief Настройка CAN-Фильтра.
* На основе переданных ID и маски настраивает фильтр CAN для приема только определённых сообщений.
* @param filterBank Номер фильтра (обычно 0..27).
* @param idFilter 32-битный идентификатор, используемый для фильтрации.
* @param idMask 32-битная маска, определяющая биты, проверяемые фильтром.
*/
void PROTOCAN_CONFIG_FILTER(uint8_t filterBank, uint32_t idFilter, uint32_t idMask)
{
CAN_FilterTypeDef canFilterConfig;
canFilterConfig.FilterBank = filterBank;
canFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
canFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
canFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
canFilterConfig.FilterActivation = ENABLE;
canFilterConfig.SlaveStartFilterBank = 14;
#define CAN_IDE_32 0b00000100 // Для 32-х битного масштаба
// Разбиваем 32-битный ID и маску для фильтрации на High и Low 16 бит
canFilterConfig.FilterIdHigh = (uint16_t)(((idFilter) >> 13)); // верхние 16 бит
canFilterConfig.FilterIdLow = (uint16_t)((((idFilter) << 3)) | CAN_IDE_32); // низкие 16 бит,
canFilterConfig.FilterMaskIdHigh = (uint16_t)(((idMask) >> 13));
canFilterConfig.FilterMaskIdLow = (uint16_t)((((idMask) << 3)) | CAN_IDE_32);
if(HAL_CAN_ConfigFilter(_HCAN, &canFilterConfig) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief Конфигурирует три фильтра CAN для различных типов сообщений.
*/
void PROTOCAN_FILTERS()
{
#define BIT27 (1UL << 27)
#define BITS_20_23_MASK (0xFUL << 20) // 4 бита (20..23)
#define BITS_24_26_MASK (0x7UL << 24) // 3 бита (24..26)
uint32_t filter1_id = BIT27 | (CURRENT_TYPE_DEVICE << 24) | (CURRENT_ID_DEVICE << 20);
uint32_t filter1_mask = BIT27 | BITS_24_26_MASK | BITS_20_23_MASK; // все проверяемые биты
#define BITS_16_19_MASK (0xFUL << 16)
uint32_t filter2_id = PROTOCAN_MSGTYPE_BROADCAST << 16;
uint32_t filter2_mask = BITS_16_19_MASK;
uint32_t filter3_id = PROTOCAN_MSGTYPE_PULSE << 16;
uint32_t filter3_mask = BITS_16_19_MASK;
// Первый фильтр: проверяем 20-27 биты, где 27-й всегда 1
PROTOCAN_CONFIG_FILTER(0, filter1_id, filter1_mask);
// Второй фильтр: проверяем 16-19 биты, равны PROTOCAN_MSGTYPE_BROADCASTE
PROTOCAN_CONFIG_FILTER(1, filter2_id, filter2_mask);
// Третий фильтр: проверяем 16-19 биты, равны PROTOCAN_MSGTYPE_PULSE
PROTOCAN_CONFIG_FILTER(2, filter3_id, filter3_mask);
}
/**
* @brief Отправляет CAN-сообщение в зависимости от типа сообщения.
* Эта функция анализирует тип сообщения в идентификаторе и вызывает
* соответствующую функцию отправки. В текущей реализации поддерживается только
* тип PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE.
* @param id Идентификатор CAN-сообщения, содержащий информацию о типе.
* @param data Структура с данными, которые необходимо отправить. Зависит от типа сообщения.
* @return Статус выполнения операции.
*/
PROTOCAN_StatusTypeDef PROTOCAN_SEND(ProtoCanId_t id, ProtoCanData_t data)
{
switch(id.Fields.MsgType)
{
case PROTOCAN_MSGTYPE_BROADCAST:
case PROTOCAN_MSGTYPE_DISCRETE:
case PROTOCAN_MSGTYPE_ANALOG:
{
return PROTOCAN_SEND_CORE(id, data.CoreData);
break;
}
case PROTOCAN_MSGTYPE_GENERAL_ADDRESS_SPACE:
{
/* Если есть регистры для отправки, указатель data должен быть валиден. */
if((data.GeneralAddressSpaceData.RegCount > 0U) && data.GeneralAddressSpaceData.Data == 0)
{
return PROTOCAN_ERROR;
}
return PROTOCAN_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:
{
return PROTOCAN_SEND_MODBUS(id, data.ModbusData);
break;
}
case PROTOCAN_MSGTYPE_ERROR:
{
return PROTOCAN_SEND_ERROR(id, data.ErrorData);
break;
}
default:
return PROTOCAN_ERROR;
}
return PROTOCAN_ERROR;
}