Отказ от Modbus Coil в пользу EGAS (Extended Global Address Space, Слоты), переработка алгоритмов приёма и обработки сообщений.
This commit is contained in:
+21
-2
@@ -56,6 +56,16 @@ typedef enum
|
||||
SETCAN_TIMEOUT = 0x03U /**< Истек таймаут ожидания. */
|
||||
} SETCAN_StatusTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Слот для расширенного общего адресного пространства
|
||||
*
|
||||
* Слот расширенного общего адресного пространства из трёх регистров.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
uint16_t Reg[3];
|
||||
} SetCanEgasSlot;
|
||||
|
||||
/**
|
||||
* @brief Уровень приоритета CAN-сообщения.
|
||||
*
|
||||
@@ -86,7 +96,8 @@ typedef enum {
|
||||
SETCAN_MSGTYPE_DISCRETE = 0b0001, /**< Дискретное цифровое сообщение. */
|
||||
SETCAN_MSGTYPE_ANALOG = 0b0010, /**< Аналоговое сообщение. */
|
||||
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_HOLDING = 0b0110, /**< Сообщение Modbus - Holding. */
|
||||
SETCAN_MSGTYPE_MODBUS_INPUT = 0b0111, /**< Сообщение Modbus - Input. */
|
||||
@@ -241,6 +252,14 @@ typedef struct{
|
||||
uint16_t *Data; /**< Указатель на массив данных. */
|
||||
unsigned RegCount; /**< Количество регистров. */
|
||||
} GeneralAddressSpaceData;
|
||||
struct SetCanEgasSlotsData{
|
||||
struct SetCanEgasSlotsPackage{
|
||||
SetCanEgasSlot Slot;
|
||||
uint16_t CmdWord;
|
||||
} *EgasSlotsPackage;
|
||||
unsigned EgasSlotsCount;
|
||||
uint16_t slotStartAdr;
|
||||
} EgasSlotsData;
|
||||
struct SetCanModbusData{
|
||||
uint16_t StrAdr;
|
||||
uint16_t *Data;
|
||||
@@ -318,11 +337,11 @@ SETCAN_StatusTypeDef SetCanMsgToAnalogISens(struct RXMsg _rxMsg);
|
||||
SETCAN_StatusTypeDef SetCanMsgToAnalogTSens(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_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);
|
||||
|
||||
+204
-189
@@ -110,110 +110,95 @@ SETCAN_INIT_StatusTypeDef SETCAN_INIT(CAN_HandleTypeDef *tmp_hcan, RTC_HandleTyp
|
||||
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-сообщений.
|
||||
*
|
||||
* Эта функция постоянно проверяет наличие доступных сообщений в буфере CAN и
|
||||
* вызывает соответствующие обработчики в зависимости от типа полученного сообщения.
|
||||
* Обрабатываемые типы сообщений:
|
||||
* - Аналоговые данные
|
||||
* - Широковещательные сообщения
|
||||
* - Дискретные данные
|
||||
* - Общее адресное пространство
|
||||
* - Модбас сообщения
|
||||
* - Ошибки
|
||||
* Постоянно опрашивает буфер на наличие доступных сообщений функцией
|
||||
* AvailableCanRxMsg() и для каждого сообщения вызывает обработчик через
|
||||
* SETCAN_ProccesRxMsg(). После обработки индекс текущего элемента буфера
|
||||
* инкрементируется циклически с учётом размера буфера SETCAN_RX_BUFFER_SIZE.
|
||||
*
|
||||
* Обработка сообщений осуществляется внутри бесконечного цикла с использованием
|
||||
* функции AvailableCanRxMsg() для определения наличия новых сообщений.
|
||||
*
|
||||
* В конце каждого обработанного сообщения индекс текущего элемента буфера инкрементируется
|
||||
* с учетом размера буфера через операцию по модулю.
|
||||
* Функция не возвращает управление до принудительного завершения цикла.
|
||||
*/
|
||||
void SETCAN_LoopProcessRxMsgs(void)
|
||||
{
|
||||
while(1)
|
||||
while(1)
|
||||
{
|
||||
if(AvailableCanRxMsg())
|
||||
{
|
||||
if(AvailableCanRxMsg())
|
||||
{
|
||||
if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ANALOG)
|
||||
{
|
||||
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;
|
||||
}
|
||||
SETCAN_ProccesRxMsg(rxMsg[CurrentStep]);
|
||||
// Обновление индекса текущего сообщения с циклическим масштабированием
|
||||
CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Обрабатывает все доступные входящие CAN-сообщения.
|
||||
*
|
||||
* Эта функция последовательно обрабатывает все сообщения, доступные в буфере,
|
||||
* вызывая соответствующие функции обработчики в зависимости от типа сообщения.
|
||||
* После обработки каждого сообщения индекс текущего элемента буфера обновляется
|
||||
* циклически.
|
||||
* Пока AvailableCanRxMsg() возвращает истину, последовательно обрабатывает
|
||||
* каждое сообщение, вызывая SETCAN_ProccesRxMsg() и продвигая CurrentStep
|
||||
* циклически (mod SETCAN_RX_BUFFER_SIZE). По завершении или при ошибке
|
||||
* возвращает соответствующий статус.
|
||||
*
|
||||
* @return SETCAN_OK, если все сообщения были обработаны успешно.
|
||||
* В противном случае возвращается код ошибки, полученный при обработке сообщения.
|
||||
*
|
||||
* Обработка происходит до тех пор, пока есть доступные сообщения, полученные функцией
|
||||
* AvailableCanRxMsg().
|
||||
* @return SETCAN_OK, если все сообщения обработаны успешно.
|
||||
* В случае ошибки — код ошибки, возвращенный обработчиком.
|
||||
* Если сообщений нет — CETCAN_TIMEOUT (текущий контракт статуса может отличаться в вашей системе; оставляйте чаще SETCAN_TIMEOUT, если так принято в вашем API).
|
||||
*/
|
||||
SETCAN_StatusTypeDef SETCAN_ProcessAllRxMsgs(void)
|
||||
{
|
||||
SETCAN_StatusTypeDef result = SETCAN_TIMEOUT;
|
||||
while(AvailableCanRxMsg())
|
||||
{
|
||||
if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ANALOG)
|
||||
{
|
||||
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]);
|
||||
}
|
||||
result = SETCAN_ProccesRxMsg(rxMsg[CurrentStep]);
|
||||
CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
|
||||
if(result != SETCAN_OK)
|
||||
{
|
||||
@@ -226,47 +211,20 @@ SETCAN_StatusTypeDef SETCAN_ProcessAllRxMsgs(void)
|
||||
/**
|
||||
* @brief Обрабатывает одно доступное CAN-сообщение.
|
||||
*
|
||||
* Эта функция проверяет наличие доступных сообщений в буфере и, если таковое есть,
|
||||
* выполняет обработку текущего сообщения в зависимости от его типа. После обработки
|
||||
* индекс текущего сообщения обновляется циклически.
|
||||
* Если в буфере есть доступное сообщение (AvailableCanRxMsg()), функция
|
||||
* обрабатывает текущее сообщение по индексу CurrentStep с помощью
|
||||
* SETCAN_ProccesRxMsg и затем циклически обновляет CurrentStep.
|
||||
*
|
||||
* @return Прошедший статус обработки:
|
||||
* - SETCAN_OK, если сообщение успешно обработано,
|
||||
* - SETCAN_TIMEOUT, если сообщений не было,
|
||||
* - или код ошибки, возвращенный функцией обработки.
|
||||
* @return SETCAN_OK, если сообщение обработано успешно;
|
||||
* SETCAN_TIMEOUT, если сообщений не было;
|
||||
* или код ошибки, возвращённый SETCAN_ProccesRxMsg.
|
||||
*/
|
||||
SETCAN_StatusTypeDef SETCAN_ProcessSingleRxMsg(void)
|
||||
{
|
||||
SETCAN_StatusTypeDef result = SETCAN_TIMEOUT;
|
||||
if(AvailableCanRxMsg())
|
||||
{
|
||||
if(rxMsg[CurrentStep].eID.Fields.MsgType == SETCAN_MSGTYPE_ANALOG)
|
||||
{
|
||||
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]);
|
||||
}
|
||||
result = SETCAN_ProccesRxMsg(rxMsg[CurrentStep]);
|
||||
CurrentStep = (uint16_t)(CurrentStep + 1) % SETCAN_RX_BUFFER_SIZE;
|
||||
}
|
||||
return result;
|
||||
@@ -279,7 +237,7 @@ SETCAN_StatusTypeDef SETCAN_ProcessSingleRxMsg(void)
|
||||
* @return HAL_StatusTypeDef Статус выполнения команды CAN (успех или ошибка).
|
||||
*/
|
||||
SETCAN_StatusTypeDef SETCAN_BroadcastProcessing(struct RXMsg _rxMsg)
|
||||
{
|
||||
{
|
||||
msgBodyBroadcastType msg;
|
||||
msg.Body = _rxMsg.eID.Fields.MsgBody;
|
||||
switch(msg.Fields.Type)
|
||||
@@ -292,27 +250,22 @@ SETCAN_StatusTypeDef SETCAN_BroadcastProcessing(struct RXMsg _rxMsg)
|
||||
case SETCAN_BROADCAST_ONOFF:
|
||||
{
|
||||
//Обработка запроса на вкл/выкл
|
||||
SetCanMsgToBroadcastOnOff(_rxMsg);
|
||||
break;
|
||||
return SetCanMsgToBroadcastOnOff(_rxMsg);
|
||||
}
|
||||
case SETCAN_BROADCAST_RESTARTDEVICE:
|
||||
{
|
||||
SetCanMsgToBroadcastRestart(_rxMsg);
|
||||
break;
|
||||
return SetCanMsgToBroadcastRestart(_rxMsg);
|
||||
}
|
||||
case SETCAN_BROADCAST_RTCSETUP:
|
||||
{
|
||||
//Обработка запроса на синхронизацию времени
|
||||
//С головным устройством
|
||||
SetCanMsgToBroadcastRtcSetup(_rxMsg);
|
||||
break;;
|
||||
return SetCanMsgToBroadcastRtcSetup(_rxMsg);
|
||||
}
|
||||
default:
|
||||
//RESERVE SENSOR TYPE.
|
||||
return SETCAN_ERROR;
|
||||
break;
|
||||
}
|
||||
return SETCAN_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -440,45 +393,36 @@ SETCAN_StatusTypeDef SETCAN_DiscreticProcessing(struct RXMsg _rxMsg)
|
||||
{
|
||||
case SETCAN_DISCRETE_ACCIDENT:
|
||||
{
|
||||
SetCanMsgToDiscreteAccident(_rxMsg);
|
||||
break;
|
||||
return SetCanMsgToDiscreteAccident(_rxMsg);
|
||||
}
|
||||
case SETCAN_DISCRETE_WARNING:
|
||||
{
|
||||
SetCanMsgToDiscreteWarning(_rxMsg);
|
||||
break;
|
||||
return SetCanMsgToDiscreteWarning(_rxMsg);
|
||||
}
|
||||
case SETCAN_DISCRETE_CONTROL_SIGNALS:
|
||||
{
|
||||
SetCanMsgToDiscreteControlSignals(_rxMsg);
|
||||
break;
|
||||
return SetCanMsgToDiscreteControlSignals(_rxMsg);
|
||||
}
|
||||
case SETCAN_DISCRETE_FLAGS:
|
||||
{
|
||||
SetCanMsgToDiscreteFlags(_rxMsg);
|
||||
break;
|
||||
return SetCanMsgToDiscreteFlags(_rxMsg);
|
||||
}
|
||||
case SETCAN_DISCRETE_RESET:
|
||||
{
|
||||
SetCanMsgToDiscreteReset(_rxMsg);
|
||||
break;
|
||||
return SetCanMsgToDiscreteReset(_rxMsg);
|
||||
}
|
||||
case SETCAN_DISCRETE_CHANGE_MODE:
|
||||
{
|
||||
SetCanMsgToDiscreteChangeMode(_rxMsg);
|
||||
break;
|
||||
return SetCanMsgToDiscreteChangeMode(_rxMsg);
|
||||
}
|
||||
case SETCAN_DISCRETE_REQUEST_LIST_OF_PARAMETERS:
|
||||
{
|
||||
SetCanMsgToDiscreteRequestListOfParameters(_rxMsg);
|
||||
break;
|
||||
return SetCanMsgToDiscreteRequestListOfParameters(_rxMsg);
|
||||
}
|
||||
default:
|
||||
//RESERVE SENSOR TYPE.
|
||||
return SETCAN_ERROR;
|
||||
break;
|
||||
}
|
||||
return SETCAN_OK;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -573,34 +517,27 @@ SETCAN_StatusTypeDef SETCAN_AnalogProcessing(struct RXMsg _rxMsg)
|
||||
case SETCAN_ANALOG_UNIVERSAL:
|
||||
{
|
||||
return SetCanMsgToAnalogUniversal(_rxMsg);
|
||||
break;
|
||||
}
|
||||
case SETCAN_ANALOG_SETTINGS:
|
||||
{
|
||||
return SetCanMsgToAnalogSettings(_rxMsg);
|
||||
break;
|
||||
}
|
||||
case SETCAN_ANALOG_U:
|
||||
{
|
||||
return SetCanMsgToAnalogUSens(_rxMsg);
|
||||
break;
|
||||
}
|
||||
case SETCAN_ANALOG_I:
|
||||
{
|
||||
return SetCanMsgToAnalogISens(_rxMsg);
|
||||
break;
|
||||
}
|
||||
case SETCAN_ANALOG_T:
|
||||
{
|
||||
return SetCanMsgToAnalogTSens(_rxMsg);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
//RESERVE SENSOR TYPE
|
||||
return SETCAN_ERROR;
|
||||
break;
|
||||
}
|
||||
return SETCAN_ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -941,6 +878,119 @@ SETCAN_StatusTypeDef SETCAN_SEND_GENERAL_ADDRESS_SPACE(SetCanId_t id, uint16_t r
|
||||
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.
|
||||
* В зависимости от типа сообщения, вызывает соответствующую функцию
|
||||
@@ -952,11 +1002,6 @@ SETCAN_StatusTypeDef SETCAN_ModbusProcessing(struct RXMsg _rxMsg)
|
||||
{
|
||||
switch(_rxMsg.eID.Fields.MsgType)
|
||||
{
|
||||
case SETCAN_MSGTYPE_MODBUS_COIL:
|
||||
{
|
||||
return SetCanMsgToModbusCoil(_rxMsg);
|
||||
break;
|
||||
}
|
||||
case SETCAN_MSGTYPE_MODBUS_DISCRETE:
|
||||
{
|
||||
return SetCanMsgToModbusDiscrete(_rxMsg);
|
||||
@@ -980,38 +1025,6 @@ SETCAN_StatusTypeDef SETCAN_ModbusProcessing(struct RXMsg _rxMsg)
|
||||
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.
|
||||
* Формирует CAN ответ на запрос Discrete Modbus и отправляет его.
|
||||
@@ -1111,7 +1124,7 @@ __weak SETCAN_StatusTypeDef SetCanMsgToModbusInput(struct RXMsg _rxMsg)
|
||||
/**
|
||||
* @brief Отправляет данные Modbus через CAN-шину в соответствии с типом сообщения.
|
||||
* Эта функция формирует и отправляет Modbus-данные по CAN-шине, поддерживая
|
||||
* различные типы сообщений: Coil, Discrete, Holding Register и Input Register.
|
||||
* различные типы сообщений: Discrete, Holding Register и Input Register.
|
||||
* Для сообщений, превышающих 4 регистров, данные отправляются пакетами.
|
||||
* @param id Идентификатор сообщения, содержащий тип сообщения и другую информацию.
|
||||
* @param modbusData Структура с данными Modbus: адрес, количество регистров и сами данные.
|
||||
@@ -1129,7 +1142,8 @@ SETCAN_StatusTypeDef SETCAN_SEND_MODBUS(const SetCanId_t id, const struct SetCan
|
||||
CAN_TxHeaderTypeDef TxHeader;
|
||||
uint32_t TxMailBox = 0;
|
||||
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
|
||||
msgBodyModbusType body;
|
||||
@@ -1470,7 +1484,8 @@ SETCAN_StatusTypeDef SETCAN_SEND(SetCanId_t id, SetCanData_t data)
|
||||
data.GeneralAddressSpaceData.Data,
|
||||
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_HOLDING:
|
||||
case SETCAN_MSGTYPE_MODBUS_INPUT:
|
||||
|
||||
Reference in New Issue
Block a user