2 changed files with 226 additions and 192 deletions
+21 -2
View File
@@ -56,6 +56,16 @@ typedef enum
SETCAN_TIMEOUT = 0x03U /**< Истек таймаут ожидания. */ SETCAN_TIMEOUT = 0x03U /**< Истек таймаут ожидания. */
} SETCAN_StatusTypeDef; } SETCAN_StatusTypeDef;
/**
* @brief Слот для расширенного общего адресного пространства
*
* Слот расширенного общего адресного пространства из трёх регистров.
*/
typedef struct
{
uint16_t Reg[3];
} SetCanEgasSlot;
/** /**
* @brief Уровень приоритета CAN-сообщения. * @brief Уровень приоритета CAN-сообщения.
* *
@@ -86,7 +96,8 @@ typedef enum {
SETCAN_MSGTYPE_DISCRETE = 0b0001, /**< Дискретное цифровое сообщение. */ SETCAN_MSGTYPE_DISCRETE = 0b0001, /**< Дискретное цифровое сообщение. */
SETCAN_MSGTYPE_ANALOG = 0b0010, /**< Аналоговое сообщение. */ SETCAN_MSGTYPE_ANALOG = 0b0010, /**< Аналоговое сообщение. */
SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE = 0b0011, /**< Сообщение общего адресного пространства. */ SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE = 0b0011, /**< Сообщение общего адресного пространства. */
SETCAN_MSGTYPE_MODBUS_COIL = 0b0100, /**< Сообщение Modbus - Coil. */ SETCAN_MSGTYPE_EGAS_SLOTS = 0b0100,
//SETCAN_MSGTYPE_MODBUS_COIL = 0b0100, /**< Сообщение Modbus - Coil. */
SETCAN_MSGTYPE_MODBUS_DISCRETE = 0b0101, /**< Сообщение Modbus - Discrete. */ SETCAN_MSGTYPE_MODBUS_DISCRETE = 0b0101, /**< Сообщение Modbus - Discrete. */
SETCAN_MSGTYPE_MODBUS_HOLDING = 0b0110, /**< Сообщение Modbus - Holding. */ SETCAN_MSGTYPE_MODBUS_HOLDING = 0b0110, /**< Сообщение Modbus - Holding. */
SETCAN_MSGTYPE_MODBUS_INPUT = 0b0111, /**< Сообщение Modbus - Input. */ SETCAN_MSGTYPE_MODBUS_INPUT = 0b0111, /**< Сообщение Modbus - Input. */
@@ -241,6 +252,14 @@ typedef struct{
uint16_t *Data; /**< Указатель на массив данных. */ uint16_t *Data; /**< Указатель на массив данных. */
unsigned RegCount; /**< Количество регистров. */ unsigned RegCount; /**< Количество регистров. */
} GeneralAddressSpaceData; } GeneralAddressSpaceData;
struct SetCanEgasSlotsData{
struct SetCanEgasSlotsPackage{
SetCanEgasSlot Slot;
uint16_t CmdWord;
} *EgasSlotsPackage;
unsigned EgasSlotsCount;
uint16_t slotStartAdr;
} EgasSlotsData;
struct SetCanModbusData{ struct SetCanModbusData{
uint16_t StrAdr; uint16_t StrAdr;
uint16_t *Data; uint16_t *Data;
@@ -318,11 +337,11 @@ SETCAN_StatusTypeDef SetCanMsgToAnalogISens(struct RXMsg _rxMsg);
SETCAN_StatusTypeDef SetCanMsgToAnalogTSens(struct RXMsg _rxMsg); SETCAN_StatusTypeDef SetCanMsgToAnalogTSens(struct RXMsg _rxMsg);
SETCAN_StatusTypeDef SetCanMsgToGeneralAddressSpace(struct RXMsg _rxMsg); SETCAN_StatusTypeDef SetCanMsgToGeneralAddressSpace(struct RXMsg _rxMsg);
SETCAN_StatusTypeDef SetCanMsgToEgasSlots(struct RXMsg _rxMsg);
SETCAN_StatusTypeDef SETCAN_RequestError(struct RXMsg _rxMsg); SETCAN_StatusTypeDef SETCAN_RequestError(struct RXMsg _rxMsg);
SETCAN_StatusTypeDef SETCAN_ModbusProcessing(struct RXMsg _rxMsg); SETCAN_StatusTypeDef SETCAN_ModbusProcessing(struct RXMsg _rxMsg);
SETCAN_StatusTypeDef SetCanMsgToModbusCoil(struct RXMsg _rxMsg);
SETCAN_StatusTypeDef SetCanMsgToModbusDiscrete(struct RXMsg _rxMsg); SETCAN_StatusTypeDef SetCanMsgToModbusDiscrete(struct RXMsg _rxMsg);
SETCAN_StatusTypeDef SetCanMsgToModbusHolding(struct RXMsg _rxMsg); SETCAN_StatusTypeDef SetCanMsgToModbusHolding(struct RXMsg _rxMsg);
SETCAN_StatusTypeDef SetCanMsgToModbusInput(struct RXMsg _rxMsg); SETCAN_StatusTypeDef SetCanMsgToModbusInput(struct RXMsg _rxMsg);
+198 -183
View File
@@ -110,24 +110,63 @@ SETCAN_INIT_StatusTypeDef SETCAN_INIT(CAN_HandleTypeDef *tmp_hcan, RTC_HandleTyp
return SETCAN_INIT_OK; return SETCAN_INIT_OK;
} }
/**
* @brief Диспетчер обработки одного входящего CAN-сообщения.
*
* Функция выбирает обработчик в зависимости от типа сообщения,
* содержащегося в поле rxMsg.eID.Fields.MsgType, и вызывает соответствующую
* функцию обработки.
*
* Поддерживаемые типы сообщений:
* - SETCAN_MSGTYPE_ANALOG: аналоговые запросы
* - SETCAN_MSGTYPE_BROADCAST: широковещательные сообщения
* - SETCAN_MSGTYPE_DISCRETE: дискретные запросы
* - SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE: общее адресное пространство
* - SETCAN_MSGTYPE_EGAS_SLOTS: расширенное общее адресное пространство (Слоты)
* - SETCAN_MSGTYPE_MODBUS_DISCRETE: мобас дискретный
* - SETCAN_MSGTYPE_MODBUS_HOLDING: модбас регистры удержания
* - SETCAN_MSGTYPE_MODBUS_INPUT: модбас входы
* - SETCAN_MSGTYPE_ERROR: Сообщения об ошибках
*
* @param rxMsg Структура входящего сообщения, которое нужно обработать.
* Не модифицируется внутри функции (если ваша реализация изменяет её — скорректируйте описание).
* @return SETCAN_StatusTypeDef Результат обработки, возвращённый соответствующей функцией-обработчиком.
* В случае неподдерживаемого типа возвращается SETCAN_ERROR.
*/
SETCAN_StatusTypeDef SETCAN_ProccesRxMsg(struct RXMsg rxMsg)
{
switch(rxMsg.eID.Fields.MsgType)
{
case SETCAN_MSGTYPE_ANALOG:
return SETCAN_AnalogProcessing(rxMsg);
case SETCAN_MSGTYPE_BROADCAST:
return SETCAN_BroadcastProcessing(rxMsg);
case SETCAN_MSGTYPE_DISCRETE:
return SETCAN_DiscreticProcessing(rxMsg);
case SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE:
return SetCanMsgToGeneralAddressSpace(rxMsg);
case SETCAN_MSGTYPE_EGAS_SLOTS:
return SetCanMsgToEgasSlots(rxMsg);
case SETCAN_MSGTYPE_MODBUS_DISCRETE:
case SETCAN_MSGTYPE_MODBUS_HOLDING:
case SETCAN_MSGTYPE_MODBUS_INPUT:
return SETCAN_ModbusProcessing(rxMsg);
case SETCAN_MSGTYPE_ERROR:
return SETCAN_RequestError(rxMsg);
default:
return SETCAN_ERROR;
}
}
/** /**
* @brief Бесконечный цикл обработки входящих CAN-сообщений. * @brief Бесконечный цикл обработки входящих CAN-сообщений.
* *
* Эта функция постоянно проверяет наличие доступных сообщений в буфере CAN и * Постоянно опрашивает буфер на наличие доступных сообщений функцией
* вызывает соответствующие обработчики в зависимости от типа полученного сообщения. * AvailableCanRxMsg() и для каждого сообщения вызывает обработчик через
* Обрабатываемые типы сообщений: * SETCAN_ProccesRxMsg(). После обработки индекс текущего элемента буфера
* - Аналоговые данные * инкрементируется циклически с учётом размера буфера SETCAN_RX_BUFFER_SIZE.
* - Широковещательные сообщения
* - Дискретные данные
* - Общее адресное пространство
* - Модбас сообщения
* - Ошибки
* *
* Обработка сообщений осуществляется внутри бесконечного цикла с использованием * Функция не возвращает управление до принудительного завершения цикла.
* функции AvailableCanRxMsg() для определения наличия новых сообщений.
*
* В конце каждого обработанного сообщения индекс текущего элемента буфера инкрементируется
* с учетом размера буфера через операцию по модулю.
*/ */
void SETCAN_LoopProcessRxMsgs(void) void SETCAN_LoopProcessRxMsgs(void)
{ {
@@ -135,33 +174,7 @@ void SETCAN_LoopProcessRxMsgs(void)
{ {
if(AvailableCanRxMsg()) if(AvailableCanRxMsg())
{ {
if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ANALOG) SETCAN_ProccesRxMsg(rxMsg[CurrentStep]);
{
SETCAN_AnalogProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_BROADCAST)
{
SETCAN_BroadcastProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_DISCRETE)
{
SETCAN_DiscreticProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
{
SetCanMsgToGeneralAddressSpace(rxMsg[CurrentStep]);
}
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)
{
SETCAN_ModbusProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ERROR)
{
SETCAN_RequestError(rxMsg[CurrentStep]);
}
// Обновление индекса текущего сообщения с циклическим масштабированием // Обновление индекса текущего сообщения с циклическим масштабированием
CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE; CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
} }
@@ -171,49 +184,21 @@ void SETCAN_LoopProcessRxMsgs(void)
/** /**
* @brief Обрабатывает все доступные входящие CAN-сообщения. * @brief Обрабатывает все доступные входящие CAN-сообщения.
* *
* Эта функция последовательно обрабатывает все сообщения, доступные в буфере, * Пока AvailableCanRxMsg() возвращает истину, последовательно обрабатывает
* вызывая соответствующие функции обработчики в зависимости от типа сообщения. * каждое сообщение, вызывая SETCAN_ProccesRxMsg() и продвигая CurrentStep
* После обработки каждого сообщения индекс текущего элемента буфера обновляется * циклически (mod SETCAN_RX_BUFFER_SIZE). По завершении или при ошибке
* циклически. * возвращает соответствующий статус.
* *
* @return SETCAN_OK, если все сообщения были обработаны успешно. * @return SETCAN_OK, если все сообщения обработаны успешно.
* В противном случае возвращается код ошибки, полученный при обработке сообщения. * В случае ошибки — код ошибки, возвращенный обработчиком.
* * Если сообщений нет — CETCAN_TIMEOUT (текущий контракт статуса может отличаться в вашей системе; оставляйте чаще SETCAN_TIMEOUT, если так принято в вашем API).
* Обработка происходит до тех пор, пока есть доступные сообщения, полученные функцией
* AvailableCanRxMsg().
*/ */
SETCAN_StatusTypeDef SETCAN_ProcessAllRxMsgs(void) SETCAN_StatusTypeDef SETCAN_ProcessAllRxMsgs(void)
{ {
SETCAN_StatusTypeDef result = SETCAN_TIMEOUT; SETCAN_StatusTypeDef result = SETCAN_TIMEOUT;
while(AvailableCanRxMsg()) while(AvailableCanRxMsg())
{ {
if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ANALOG) result = SETCAN_ProccesRxMsg(rxMsg[CurrentStep]);
{
result = SETCAN_AnalogProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_BROADCAST)
{
result = SETCAN_BroadcastProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_DISCRETE)
{
result = SETCAN_DiscreticProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
{
result = SetCanMsgToGeneralAddressSpace(rxMsg[CurrentStep]);
}
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 = SETCAN_ModbusProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ERROR)
{
result = SETCAN_RequestError(rxMsg[CurrentStep]);
}
CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE; CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
if(result != SETCAN_OK) if(result != SETCAN_OK)
{ {
@@ -226,47 +211,20 @@ SETCAN_StatusTypeDef SETCAN_ProcessAllRxMsgs(void)
/** /**
* @brief Обрабатывает одно доступное CAN-сообщение. * @brief Обрабатывает одно доступное CAN-сообщение.
* *
* Эта функция проверяет наличие доступных сообщений в буфере и, если таковое есть, * Если в буфере есть доступное сообщение (AvailableCanRxMsg()), функция
* выполняет обработку текущего сообщения в зависимости от его типа. После обработки * обрабатывает текущее сообщение по индексу CurrentStep с помощью
* индекс текущего сообщения обновляется циклически. * SETCAN_ProccesRxMsg и затем циклически обновляет CurrentStep.
* *
* @return Прошедший статус обработки: * @return SETCAN_OK, если сообщение обработано успешно;
* - SETCAN_OK, если сообщение успешно обработано, * SETCAN_TIMEOUT, если сообщений не было;
* - SETCAN_TIMEOUT, если сообщений не было, * или код ошибки, возвращённый SETCAN_ProccesRxMsg.
* - или код ошибки, возвращенный функцией обработки.
*/ */
SETCAN_StatusTypeDef SETCAN_ProcessSingleRxMsg(void) SETCAN_StatusTypeDef SETCAN_ProcessSingleRxMsg(void)
{ {
SETCAN_StatusTypeDef result = SETCAN_TIMEOUT; SETCAN_StatusTypeDef result = SETCAN_TIMEOUT;
if(AvailableCanRxMsg()) if(AvailableCanRxMsg())
{ {
if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ANALOG) result = SETCAN_ProccesRxMsg(rxMsg[CurrentStep]);
{
result = SETCAN_AnalogProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_BROADCAST)
{
result = SETCAN_BroadcastProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_DISCRETE)
{
result = SETCAN_DiscreticProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_GENERAL_ADDRESS_SPACE)
{
result = SetCanMsgToGeneralAddressSpace(rxMsg[CurrentStep]);
}
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 = SETCAN_ModbusProcessing(rxMsg[CurrentStep]);
}
else if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ERROR)
{
result = SETCAN_RequestError(rxMsg[CurrentStep]);
}
CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE; CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
} }
return result; return result;
@@ -292,27 +250,22 @@ SETCAN_StatusTypeDef SETCAN_BroadcastProcessing(struct RXMsg _rxMsg)
case SETCAN_BROADCAST_ONOFF: case SETCAN_BROADCAST_ONOFF:
{ {
//Обработка запроса на вкл/выкл //Обработка запроса на вкл/выкл
SetCanMsgToBroadcastOnOff(_rxMsg); return SetCanMsgToBroadcastOnOff(_rxMsg);
break;
} }
case SETCAN_BROADCAST_RESTARTDEVICE: case SETCAN_BROADCAST_RESTARTDEVICE:
{ {
SetCanMsgToBroadcastRestart(_rxMsg); return SetCanMsgToBroadcastRestart(_rxMsg);
break;
} }
case SETCAN_BROADCAST_RTCSETUP: case SETCAN_BROADCAST_RTCSETUP:
{ {
//Обработка запроса на синхронизацию времени //Обработка запроса на синхронизацию времени
//С головным устройством //С головным устройством
SetCanMsgToBroadcastRtcSetup(_rxMsg); return SetCanMsgToBroadcastRtcSetup(_rxMsg);
break;;
} }
default: default:
//RESERVE SENSOR TYPE. //RESERVE SENSOR TYPE.
return SETCAN_ERROR; return SETCAN_ERROR;
break;
} }
return SETCAN_OK;
} }
/** /**
@@ -440,45 +393,36 @@ SETCAN_StatusTypeDef SETCAN_DiscreticProcessing(struct RXMsg _rxMsg)
{ {
case SETCAN_DISCRETE_ACCIDENT: case SETCAN_DISCRETE_ACCIDENT:
{ {
SetCanMsgToDiscreteAccident(_rxMsg); return SetCanMsgToDiscreteAccident(_rxMsg);
break;
} }
case SETCAN_DISCRETE_WARNING: case SETCAN_DISCRETE_WARNING:
{ {
SetCanMsgToDiscreteWarning(_rxMsg); return SetCanMsgToDiscreteWarning(_rxMsg);
break;
} }
case SETCAN_DISCRETE_CONTROL_SIGNALS: case SETCAN_DISCRETE_CONTROL_SIGNALS:
{ {
SetCanMsgToDiscreteControlSignals(_rxMsg); return SetCanMsgToDiscreteControlSignals(_rxMsg);
break;
} }
case SETCAN_DISCRETE_FLAGS: case SETCAN_DISCRETE_FLAGS:
{ {
SetCanMsgToDiscreteFlags(_rxMsg); return SetCanMsgToDiscreteFlags(_rxMsg);
break;
} }
case SETCAN_DISCRETE_RESET: case SETCAN_DISCRETE_RESET:
{ {
SetCanMsgToDiscreteReset(_rxMsg); return SetCanMsgToDiscreteReset(_rxMsg);
break;
} }
case SETCAN_DISCRETE_CHANGE_MODE: case SETCAN_DISCRETE_CHANGE_MODE:
{ {
SetCanMsgToDiscreteChangeMode(_rxMsg); return SetCanMsgToDiscreteChangeMode(_rxMsg);
break;
} }
case SETCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS: case SETCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS:
{ {
SetCanMsgToDiscreteRequestListOfParameters(_rxMsg); return SetCanMsgToDiscreteRequestListOfParameters(_rxMsg);
break;
} }
default: default:
//RESERVE SENSOR TYPE. //RESERVE SENSOR TYPE.
return SETCAN_ERROR; return SETCAN_ERROR;
break;
} }
return SETCAN_OK;
} }
/** /**
@@ -573,34 +517,27 @@ SETCAN_StatusTypeDef SETCAN_AnalogProcessing(struct RXMsg _rxMsg)
case SETCAN_ANALOG_UNIVERSAL: case SETCAN_ANALOG_UNIVERSAL:
{ {
return SetCanMsgToAnalogUniversal(_rxMsg); return SetCanMsgToAnalogUniversal(_rxMsg);
break;
} }
case SETCAN_ANALOG_SETTINGS: case SETCAN_ANALOG_SETTINGS:
{ {
return SetCanMsgToAnalogSettings(_rxMsg); return SetCanMsgToAnalogSettings(_rxMsg);
break;
} }
case SETCAN_ANALOG_U: case SETCAN_ANALOG_U:
{ {
return SetCanMsgToAnalogUSens(_rxMsg); return SetCanMsgToAnalogUSens(_rxMsg);
break;
} }
case SETCAN_ANALOG_I: case SETCAN_ANALOG_I:
{ {
return SetCanMsgToAnalogISens(_rxMsg); return SetCanMsgToAnalogISens(_rxMsg);
break;
} }
case SETCAN_ANALOG_T: case SETCAN_ANALOG_T:
{ {
return SetCanMsgToAnalogTSens(_rxMsg); return SetCanMsgToAnalogTSens(_rxMsg);
break;
} }
default: default:
//RESERVE SENSOR TYPE //RESERVE SENSOR TYPE
return SETCAN_ERROR; return SETCAN_ERROR;
break;
} }
return SETCAN_ERROR;
} }
/** /**
@@ -804,7 +741,7 @@ SETCAN_StatusTypeDef SETCAN_SEND_CORE(const SetCanId_t id, const struct SetCanCo
TxHeader.DLC = regsInPacket; TxHeader.DLC = regsInPacket;
for(int i = 0; i < regsInPacket; i++) for(int i = 0; i < regsInPacket; i++)
{ {
canData[i] = coreData.Data[coreData.DataCount - regsRemaining]; canData[i] = coreData.Data[coreData.DataCount - regsRemaining + i];
} }
HAL_StatusTypeDef status = HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox); HAL_StatusTypeDef status = HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox);
if(status != HAL_OK) if(status != HAL_OK)
@@ -941,6 +878,119 @@ SETCAN_StatusTypeDef SETCAN_SEND_GENERAL_ADDRESS_SPACE(SetCanId_t id, uint16_t r
return (SETCAN_StatusTypeDef)HAL_OK; return (SETCAN_StatusTypeDef)HAL_OK;
} }
/**
* @brief Обработка и ответ на запрос общего адресного пространства.
* Формирует и передает сообщение с данными о статусе "GAS-XXXX", где XXXX — значение из сообщения _rxMsg.
* @param _rxMsg Структура входящего сообщения, содержит идентификатор и тело сообщения.
*/
__weak SETCAN_StatusTypeDef SetCanMsgToEgasSlots(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;
SetCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = SETCAN_ROUTE_FROM_DEVICE;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 8;
data[0] = 'G';
data[1] = 'S';
data[2] = '-';
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 (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/**
* @brief Отправка EGAS-слотов через CAN.
*
* Функция отправляет последовательность слотов EGAS, используя данные из структуры
* SetCanEgasSlotsData. Для каждого слота формируется CAN-сообщение длиной 8 байт и отправляется
* через HAL_CAN_AddTxMessage. Номер ExtId формируется на основе переданного id и текущего индекса слота.
*
* Layout данных в каждом сообщении (8 байт):
* - data[0] = LowByte(CmdWord)
* - data[1] = HighByte(CmdWord)
* - data[2 + (0*2)] = LowByte(Reg[0])
* - data[2 + (0*2) + 1] = HighByte(Reg[0])
* - data[2 + (1*2)] = LowByte(Reg[1])
* - data[2 + (1*2) + 1] = HighByte(Reg[1])
* - data[2 + (2*2)] = LowByte(Reg[2])
* - data[2 + (2*2) + 1] = HighByte(Reg[2])
*
* MsgBody каждого сообщения устанавливается как slotStartAdr + currentIndex.
*
* Параметры структуры egasData:
* - egasData.EgasSlotsPackage: указатель на массив пакетов слотов (SetCanEgasSlotsPackage),
* каждый пакет содержит Slot (SetCanEgasSlot) и CmdWord.
* - egasData.EgasSlotsCount: количество слотов в отправке.
* - egasData.slotStartAdr: стартовый адрес слота, от которого строятся MsgBody для сообщений.
*
* Функция возвращает SETCAN_OK при успешной отправке всех слотов. При ошибке
* HAL_CAN_AddTxMessage возвращается соответствующий код HAL, преобразованный к SETCAN_StatusTypeDef.
*
* @param id Идентификатор CAN в расширенном формате (SetCanId_t), используемый для формирования ExtId.
* @param egasData Структура SetCanEgasSlotsData, содержащая пакеты слотов, количество слотов и стартовый адрес.
* @return SETCAN_OK если все слоты отправлены успешно; иначе возвращается код ошибки HAL, преобразованный к SETCAN_StatusTypeDef.
*/
SETCAN_StatusTypeDef SETCAN_SEND_EGAS_SLOTS(SetCanId_t id, const struct SetCanEgasSlotsData egasData)
{
CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0;
uint8_t canData[8];
TxHeader.IDE = CAN_ID_EXT;
TxHeader.TransmitGlobalTime = DISABLE;
TxHeader.RTR = CAN_RTR_DATA;
SetCanId_t tmp_eID;
tmp_eID.BitAll = id.BitAll;
uint8_t slotsRemaining = egasData.EgasSlotsCount;
uint8_t currentIndex = 0;
while(slotsRemaining > 0)
{
tmp_eID.Fields.MsgBody = egasData.slotStartAdr + currentIndex;
TxHeader.ExtId = tmp_eID.BitAll;
TxHeader.DLC = 8;
canData[0] = LowByteOfWord(egasData.EgasSlotsPackage[currentIndex].CmdWord);
canData[1] = HighByteOfWord(egasData.EgasSlotsPackage[currentIndex].CmdWord);
for(int i = 0; i < 3; i++)
{
canData[2 + (i * 2)] = LowByteOfWord(egasData.EgasSlotsPackage[currentIndex].Slot.Reg[i]);
canData[2 + (i * 2) + 1] = HighByteOfWord(egasData.EgasSlotsPackage[currentIndex].Slot.Reg[i]);
}
HAL_StatusTypeDef status = HAL_CAN_AddTxMessage(_HCAN, &TxHeader, canData, &TxMailBox);
if(status != HAL_OK)
{
return (SETCAN_StatusTypeDef)status;
}
slotsRemaining--;
currentIndex++;
}
return (SETCAN_StatusTypeDef)HAL_OK;
}
/** /**
* @brief Обработка запроса на основе типа Modbus. * @brief Обработка запроса на основе типа Modbus.
* В зависимости от типа сообщения, вызывает соответствующую функцию * В зависимости от типа сообщения, вызывает соответствующую функцию
@@ -952,11 +1002,6 @@ SETCAN_StatusTypeDef SETCAN_ModbusProcessing(struct RXMsg _rxMsg)
{ {
switch(_rxMsg.eID.Fields.MsgType) switch(_rxMsg.eID.Fields.MsgType)
{ {
case SETCAN_MSGTYPE_MODBUS_COIL:
{
return SetCanMsgToModbusCoil(_rxMsg);
break;
}
case SETCAN_MSGTYPE_MODBUS_DISCRETE: case SETCAN_MSGTYPE_MODBUS_DISCRETE:
{ {
return SetCanMsgToModbusDiscrete(_rxMsg); return SetCanMsgToModbusDiscrete(_rxMsg);
@@ -980,38 +1025,6 @@ SETCAN_StatusTypeDef SETCAN_ModbusProcessing(struct RXMsg _rxMsg)
return SETCAN_ERROR; return SETCAN_ERROR;
} }
/**
* @brief __weak Функция отправки ответа на запрос Coil Modbus по CAN.
* Формирует CAN ответ на запрос Coil Modbus и отправляет его.
* @param _rxMsg Структура входящего сообщения RXMsg.
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
*/
__weak SETCAN_StatusTypeDef SetCanMsgToModbusCoil(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;
SetCanId_t tmp_eID;
tmp_eID.BitAll = _rxMsg.eID.BitAll;
tmp_eID.Fields.Route = SETCAN_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 (SETCAN_StatusTypeDef)HAL_CAN_AddTxMessage(_HCAN, &TxHeader, data, &TxMailBox);
}
/** /**
* @brief __weak Функция отправки ответа на запрос Discrete Modbus по CAN. * @brief __weak Функция отправки ответа на запрос Discrete Modbus по CAN.
* Формирует CAN ответ на запрос Discrete Modbus и отправляет его. * Формирует CAN ответ на запрос Discrete Modbus и отправляет его.
@@ -1111,7 +1124,7 @@ __weak SETCAN_StatusTypeDef SetCanMsgToModbusInput(struct RXMsg _rxMsg)
/** /**
* @brief Отправляет данные Modbus через CAN-шину в соответствии с типом сообщения. * @brief Отправляет данные Modbus через CAN-шину в соответствии с типом сообщения.
* Эта функция формирует и отправляет Modbus-данные по CAN-шине, поддерживая * Эта функция формирует и отправляет Modbus-данные по CAN-шине, поддерживая
* различные типы сообщений: Coil, Discrete, Holding Register и Input Register. * различные типы сообщений: Discrete, Holding Register и Input Register.
* Для сообщений, превышающих 4 регистров, данные отправляются пакетами. * Для сообщений, превышающих 4 регистров, данные отправляются пакетами.
* @param id Идентификатор сообщения, содержащий тип сообщения и другую информацию. * @param id Идентификатор сообщения, содержащий тип сообщения и другую информацию.
* @param modbusData Структура с данными Modbus: адрес, количество регистров и сами данные. * @param modbusData Структура с данными Modbus: адрес, количество регистров и сами данные.
@@ -1129,7 +1142,8 @@ SETCAN_StatusTypeDef SETCAN_SEND_MODBUS(const SetCanId_t id, const struct SetCan
CAN_TxHeaderTypeDef TxHeader; CAN_TxHeaderTypeDef TxHeader;
uint32_t TxMailBox = 0; uint32_t TxMailBox = 0;
uint8_t canData[8]; uint8_t canData[8];
if(msgType == SETCAN_MSGTYPE_MODBUS_COIL || msgType == SETCAN_MSGTYPE_MODBUS_DISCRETE) if(//msgType == SETCAN_MSGTYPE_MODBUS_COIL ||
msgType == SETCAN_MSGTYPE_MODBUS_DISCRETE)
{ {
// Формируем body // Формируем body
msgBodyModbusType body; msgBodyModbusType body;
@@ -1470,7 +1484,8 @@ SETCAN_StatusTypeDef SETCAN_SEND(SetCanId_t id, SetCanData_t data)
data.GeneralAddressSpaceData.Data, data.GeneralAddressSpaceData.Data,
data.GeneralAddressSpaceData.RegCount); data.GeneralAddressSpaceData.RegCount);
} }
case SETCAN_MSGTYPE_MODBUS_COIL: case SETCAN_MSGTYPE_EGAS_SLOTS:
return SETCAN_SEND_EGAS_SLOTS(id, data.EgasSlotsData);
case SETCAN_MSGTYPE_MODBUS_DISCRETE: case SETCAN_MSGTYPE_MODBUS_DISCRETE:
case SETCAN_MSGTYPE_MODBUS_HOLDING: case SETCAN_MSGTYPE_MODBUS_HOLDING:
case SETCAN_MSGTYPE_MODBUS_INPUT: case SETCAN_MSGTYPE_MODBUS_INPUT: