diff --git a/Core/Inc/setcan.h b/Core/Inc/setcan.h index feca0ef..a174a64 100644 --- a/Core/Inc/setcan.h +++ b/Core/Inc/setcan.h @@ -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); diff --git a/Core/Src/setcan.c b/Core/Src/setcan.c index fb6f72d..a8773bf 100644 --- a/Core/Src/setcan.c +++ b/Core/Src/setcan.c @@ -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: