Отказ от Modbus Coil в пользу EGAS (Extended Global Address Space, Слоты), переработка алгоритмов приёма и обработки сообщений.

This commit is contained in:
Вячеслав Штейбезандт
2026-11-18 15:25:20 +03:00
parent bf460a82b8
commit 8da4a697ef
2 changed files with 225 additions and 191 deletions
+21 -2
View File
@@ -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
View File
@@ -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: