code-sierra
/
chg-stn-motherboard-ti-mcu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
chg-stn-motherboard-ti-mcu/ivec_ECU/ivec_ecu_uart/src/ivec_ecu_uart.c

572 lines
22 KiB
C
Raw Blame History

#include "../ivec_ECU/ivec_ecu_uart/inc/ivec_ecu_uart.h"
#include "ivec_cmplx_queue.h"
#include "../Core/Include/ivec_mcal_uart.h"
#define LOG_STRING "ivec-ecu-UART"
//#define NFC_UART_BUFFER_MAX_SIZE 256
#define DATA_PACKET_TIMEOUT_MS 300
volatile static CmplxFifoQueueHandle_s __gprv_xUartResponseQueue[IVEC_ECU_UART_PORT_MAX] = { 0 };
//static uint8_t __gprv_u8NFCUartDataBuffer[NFC_UART_BUFFER_MAX_SIZE];
/**
* @brief UART receive callback for processing received data.
*
* This function is invoked when data is received over UART on different UART ports.
* The received data is enqueued into the appropriate FIFO queue based on the UART port.
*
* @param[in] uartPort The UART port number where the data was received.
* @param[in] eventType The event type indicating the status of the UART reception.
* @param[in] pu8Buffer Pointer to the received data buffer.
* @param[in] u32Size Size of the received data buffer.
*/
static void __prv_EcuCanOverUartMsgCallback(IVEC_McalUartPort_e eUartPort, IVEC_ECU_UartEvent_e eEventType,int8_t* pu8Buffer, uint32_t u32Size)
{
switch (eUartPort)
{
case IVEC_MCAL_UART_PORT_2:
if (eEventType == IVEC_ECU_UART_EVENT_RX_ARRIVED) {
u8CMPLX_FifoEnqueue((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[IVEC_ECU_UART_PORT2], pu8Buffer, u32Size);
}
break;
case IVEC_MCAL_UART_PORT_3:
if (eEventType == IVEC_ECU_UART_EVENT_RX_ARRIVED) {
u8CMPLX_FifoEnqueue((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[IVEC_ECU_UART_PORT3], pu8Buffer, u32Size);
}
case IVEC_MCAL_UART_PORT_4:
if (eEventType == IVEC_ECU_UART_EVENT_RX_ARRIVED) {
u8CMPLX_FifoEnqueue((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[IVEC_ECU_UART_PORT4], pu8Buffer, u32Size);
}
break;
default:
break;
}
}
/**
* @brief Calculates the checksum for the given packet.
*
* This function computes a two-byte checksum for the provided data packet. The
* checksum is calculated by summing the bytes of the packet (excluding the sync data),
* with each byte of the checksum being constrained to 8 bits.
*
* @param[in] pkt Pointer to the packet data for which the checksum is to be calculated.
* @param[in] len Length of the packet data.
* @param[out] checksum Pointer to a buffer where the calculated checksum will be stored.
* The checksum consists of two bytes.
*/
static void _prv_EcuCalculateChecksum(uint8_t* pkt, int i32Len, uint8_t* u8CheckSum) {
uint8_t l_u8CheckSumFirst = 0, l_u8CheckSumSecond = 0;
/* Incremented to ignore Sync data */
for (int u32Index = 2; u32Index < i32Len - 2; u32Index++) {
l_u8CheckSumFirst += pkt[u32Index];
l_u8CheckSumSecond += l_u8CheckSumFirst;
}
l_u8CheckSumFirst &= 0xFF;
l_u8CheckSumSecond &= 0xFF;
u8CheckSum[0] = l_u8CheckSumFirst;
u8CheckSum[1] = l_u8CheckSumSecond;
}
/**
* @brief Initializes UART with specified configurations and a FIFO queue.
*
* This function initializes the UART interface by configuring the UART port,
* setting up the receive callback, and initializing the FIFO queue for the
* specified UART port. It also sets the UART parameters such as baud rate,
* flow control, data bits, stop bits, and parity bits.
*
* @param[in] pxUartHandle Pointer to the UART handle structure containing
* UART port configuration and queue settings.
*
* @return IVEC_EcuCommonErr_e Status of the initialization process:
* - `commonECU_SUCCESS`: Initialization was successful.
* - `commonECU_INIT_FAIL`: Initialization failed.
*
* @details
* - The function validates the UART port number and configures the appropriate
* FIFO queue for receiving data.
* - Initializes the UART configuration with provided parameters (baud rate, flow control,
* data bits, stop bits, and parity).
* - Sets the UART receive callback to `__prv_EcuCanOverUartMsgCallback`.
* - If the initialization of the FIFO queue or UART fails, the function returns
* `commonECU_INIT_FAIL`.
*/
IVEC_EcuCommonErr_e xECU_UartInit(IVEC_EcuUartHandle_s* pxUartHandle)
{
if (pxUartHandle->eUartPortNumber >= IVEC_ECU_UART_PORT_MAX)
{
return commonMCAL_INIT_FAIL;
}
IVEC_ECU_FUNC_ENTRY(LOG_STRING);
IVEC_EcuCommonErr_e l_eFuncStatus = commonECU_SUCCESS;
uint8_t l_i32Ret = 0;
IVEC_ECU_LOG(LOG_STRING, "UART Initializing Queue");
if (pxUartHandle->eUartPortNumber < IVEC_ECU_UART_PORT_MAX)
{
__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber].i32ElementSize = sizeof(uint8_t);
switch (pxUartHandle->eUartPortNumber)
{
case IVEC_ECU_UART_PORT2:
__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber].i32TotalElements = pxUartHandle->u16QbufSize;
__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber].pu8Buffer = pxUartHandle->u8Qbuffer;
break;
case IVEC_ECU_UART_PORT3:
__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber].i32TotalElements = pxUartHandle->u16QbufSize;
__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber].pu8Buffer = pxUartHandle->u8Qbuffer;
break;
case IVEC_ECU_UART_PORT4:
__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber].i32TotalElements = pxUartHandle->u16QbufSize;
__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber].pu8Buffer = pxUartHandle->u8Qbuffer;
break;
default:
__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber].pu8Buffer = NULL;
break;
}
__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber].i32QueueType = FIXED_ELEMENT_SIZE_QUEUE;
l_i32Ret = u8CMPLX_FifoQueueInit((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber]);
}
if (l_i32Ret == 0)
{
l_eFuncStatus = commonECU_INIT_FAIL;
goto exit;
}
IVEC_ECU_LOG(LOG_STRING, "Initializing UART");
pxUartHandle->__xUartHandle.pvUartRecvCallback = __prv_EcuCanOverUartMsgCallback;
pxUartHandle->__xUartHandle.xUartConfig.eUartBaudrate = pxUartHandle->u32BaudRate;
pxUartHandle->__xUartHandle.eUartPortNumber = pxUartHandle->eUartPortNumber;
pxUartHandle->__xUartHandle.xUartConfig.eUartFlowCtrl = IVEC_MCAL_UART_FC_NONE;
pxUartHandle->__xUartHandle.xUartConfig.eUartDataBit = IVEC_MCAL_UART_DATA_BIT_8;
pxUartHandle->__xUartHandle.xUartConfig.eUartStopBit = IVEC_MCAL_UART_STOP_BIT_1;
pxUartHandle->__xUartHandle.xUartConfig.eUartParityBit = IVEC_MCAL_UART_PARITY_NONE;
l_i32Ret = xMCAL_UartInit(&pxUartHandle->__xUartHandle);
if (l_i32Ret != 0)
{
l_eFuncStatus = commonECU_INIT_FAIL;
goto exit;
}
exit:
IVEC_ECU_FUNC_EXIT(LOG_STRING, 0);
return l_eFuncStatus;
}
/**
* @brief Deinitializes the UART interface.
*
* This function deinitializes the UART interface by flushing the associated FIFO
* queue and calling the `xMCAL_UartDeInit` function. If the UART port number is invalid
* or the UART handle is NULL, it returns an initialization failure status.
*
* @param[in] pxUartHandle Pointer to the UART handle structure to be deinitialized.
*
* @return IVEC_EcuCommonErr_e Status of the deinitialization:
* - `commonECU_SUCCESS`: Deinitialization was successful.
* - `commonECU_INIT_FAIL`: UART port is invalid or initialization failed.
* - `commonECU_DEINIT_FAIL`: UART deinitialization failed.
* - `commonECU_ALREADY_DEINIT`: UART handle is NULL, indicating it's already deinitialized.
*
* @details
* - The function first validates the UART handle and port number.
* - It then calls `xMCAL_UartDeInit` to deinitialize the UART hardware.
* - If the deinitialization fails, it returns `commonECU_DEINIT_FAIL`.
* - If successful, it flushes the UART response queue.
*/
IVEC_EcuCommonErr_e xECU_UartDeinit(IVEC_EcuUartHandle_s* pxUartHandle)
{
if (pxUartHandle == NULL || pxUartHandle->eUartPortNumber >= IVEC_ECU_UART_PORT_MAX)
{
return commonECU_INIT_FAIL;
}
IVEC_ECU_FUNC_ENTRY(LOG_STRING);
uint8_t l_i32Ret;
IVEC_EcuCommonErr_e l_eFuncStatus = commonECU_SUCCESS;
if (pxUartHandle == NULL)
{
l_eFuncStatus = commonECU_ALREADY_DEINIT;
goto exit;
}
IVEC_ECU_LOG(LOG_STRING, "Deinitializing UART");
l_i32Ret = xMCAL_UartDeInit(&pxUartHandle->__xUartHandle);
if (l_i32Ret != IVEC_MCAL_STATUS_SUCCESS)
{
l_eFuncStatus = commonECU_DEINIT_FAIL;
goto exit;
}
if (pxUartHandle->eUartPortNumber < IVEC_ECU_UART_PORT_MAX)
{
vCMPLX_FifoQueueFlush((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber]);
}
exit:
IVEC_ECU_FUNC_EXIT(LOG_STRING, 0);
return l_eFuncStatus;
}
void vECU_UartFlush(IVEC_EcuUartHandle_s* pxUartHandle)
{
if (pxUartHandle->eUartPortNumber < IVEC_ECU_UART_PORT_MAX)
{
vCMPLX_FifoQueueFlush((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber]);
}
}
/**
* @brief Reinitializes the UART interface.
*
* This function first deinitializes the UART interface using `xECU_UartDeinit`,
* and then reinitializes it with the new configuration using `xECU_UartInit`.
*
* @param[in] pxUartHandle Pointer to the UART handle structure to be reinitialized.
*
* @return IVEC_EcuCommonErr_e Status of the reinitialization:
* - `commonECU_SUCCESS`: Reinitialization was successful.
* - `commonECU_INIT_FAIL`: UART initialization failed.
* - `commonECU_DEINIT_FAIL`: UART deinitialization failed.
*
* @details
* - The function first deinitializes the UART by calling `xECU_UartDeinit`.
* - If the deinitialization is successful, it then calls `xECU_UartInit` to reinitialize the UART.
* - If any step fails, the function returns an appropriate error status.
*/
IVEC_EcuCommonErr_e xECU_UartReinit(IVEC_EcuUartHandle_s* pxUartHandle)
{
if (pxUartHandle == NULL || pxUartHandle->eUartPortNumber >= IVEC_ECU_UART_PORT_MAX)
{
return commonECU_INIT_FAIL;
}
IVEC_EcuCommonErr_e l_eFuncStatus = commonECU_SUCCESS;
uint8_t l_i32Ret;
// Deinitialize UART
l_i32Ret = xECU_UartDeinit(pxUartHandle);
if (l_i32Ret != IVEC_MCAL_STATUS_SUCCESS)
{
l_eFuncStatus = commonECU_DEINIT_FAIL;
goto exit;
}
// Reinitialize UART with the new speed
l_i32Ret = xECU_UartInit(pxUartHandle);
if (l_i32Ret != IVEC_MCAL_STATUS_SUCCESS)
{
l_eFuncStatus = commonECU_INIT_FAIL;
}
exit:
return l_eFuncStatus;
}
/**
* @brief Transmits data over UART.
*
* This function is a placeholder and currently does not transmit data.
* It returns a failure status as the implementation is not provided.
*
* @param[in] pxUartHandle Pointer to the UART handle structure.
* @param[in] pu8Buffer Pointer to the data buffer to be transmitted.
* @param[in] len Length of the data to be transmitted.
*
* @return IVEC_EcuCommonErr_e Status of the transmission:
* - `commonECU_FAIL`: Transmission is not implemented.
*/
IVEC_EcuCommonErr_e xECU_UartTransmit(IVEC_EcuUartHandle_s* pxUartHandle, uint8_t* pu8Buffer, uint16_t u16Len)
{
return commonECU_FAIL;
}
/**
* @brief Flushes the UART response queue.
*
* This function clears the response queue associated with the specified UART port.
*
* @param[in] pxUartHandle Pointer to the UART handle structure.
*
* @return IVEC_EcuCommonErr_e Status of the flush operation:
* - `commonECU_SUCCESS`: Queue was flushed successfully.
* - `commonECU_FAIL`: The UART handle is invalid or the port number is out of range.
*
* @details
* - The function checks if the UART handle is valid and if the port number is within the allowed range.
* - It then flushes the FIFO queue associated with the UART response queue for the specified port.
*/
IVEC_EcuCommonErr_e xECU_UartFlush(IVEC_EcuUartHandle_s* pxUartHandle)
{
if (pxUartHandle == NULL || pxUartHandle->eUartPortNumber >= IVEC_ECU_UART_PORT_MAX)
{
return commonECU_FAIL;
}
vCMPLX_FifoQueueFlush((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber]);
return commonECU_SUCCESS;
}
/**
* @brief Retrieves data from the UART response queue.
*
* This function retrieves data from the UART response queue within a specified timeout period.
* If the data is available, it copies the data into the provided buffer. If data is not available
* within the timeout, it returns an error.
*
* @param[in] pxUartHandle Pointer to the UART handle structure.
* @param[out] pu8Buffer Pointer to the buffer where the received data will be stored.
* @param[in] len Length of the data to be received.
* @param[in] timeout Timeout period in milliseconds.
*
* @return IVEC_EcuCommonErr_e Status of the data retrieval:
* - `commonECU_SUCCESS`: Data was retrieved successfully.
* - `commonECU_INVALID_PARAM`: Invalid UART handle or port number.
* - `commonECU_READ_FAIL`: Data could not be read within the timeout.
*
* @details
* - The function validates the UART handle and port number.
* - It checks the FIFO queue for available data and retrieves it into the provided buffer.
* - If data is not available within the timeout period, it returns `commonECU_READ_FAIL`.
* - Interrupts are disabled during the dequeue operation to ensure data integrity.
*/
IVEC_EcuCommonErr_e xECU_UartGetData(IVEC_EcuUartHandle_s* pxUartHandle, uint8_t* pu8Buffer, uint16_t u16Len, uint16_t u16Timeout)
{
IVEC_ECU_FUNC_ENTRY(LOG_STRING);
IVEC_EcuCommonErr_e l_eFuncStatus = commonECU_SUCCESS;
if (pxUartHandle == NULL || pxUartHandle->eUartPortNumber >= IVEC_ECU_UART_PORT_MAX)
{
l_eFuncStatus = commonECU_INVALID_PARAM;
goto exit;
}
uint16_t l_u16Len = 0;
uint32_t u32CommTimestamp = i32MCAL_getTicks();
while(((i32MCAL_getTicks() - u32CommTimestamp) <= u16Timeout+1) && (l_u16Len < u16Len))
{
l_u16Len = i32CMPLX_FifoCounts((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber]);
}
if (l_u16Len < u16Len)
{
l_eFuncStatus = commonECU_READ_FAIL;
goto exit;
}
else
{
int i32Len = 0;
__disable_irq();//disabling interrupt to avoid enqueing while dequeing
for(int u32Index=0;u32Index<u16Len;u32Index++)
{
u8CMPLX_FifoDequeue((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber], &pu8Buffer[u32Index], &i32Len, 0);
}
__enable_irq();
}
exit:
IVEC_ECU_FUNC_EXIT(LOG_STRING, 0);
return l_eFuncStatus;
}
/**
* @brief Reads and validates CAN data length over UART.
*
* This function reads data from the UART, checks packet synchronization, calculates
* the packet length, and verifies the checksum. It handles various conditions and
* returns the packet length or failure code.
*
* @param[in] pxUartHandle Pointer to the UART handle for communication.
* @param[out] pu8Buf Buffer to store the received data.
* @param[out] u32Id Pointer to store the extracted CAN ID.
*
* @return The packet length on success, or a failure code:
* - `commonECU_READ_FAIL` if the read operation or checksum validation fails.
* - `ecuUART_PACKET_FAIL_i8` if the packet synchronization is lost.
*/
IVEC_ECU_UartPacketRetCode_e xECU_UartReadCANDataLenOverUART(IVEC_EcuUartHandle_s* pxUartHandle, uint8_t* pu8Buf, uint32_t* u32Id)
{
int PktLen = commonECU_READ_FAIL;
if ((xECU_UartGetData(pxUartHandle, (uint8_t*)&pu8Buf[0], 1, 0) == commonECU_SUCCESS))
{
if (pu8Buf[0] == 0xB5)
{
if (xECU_UartGetData(pxUartHandle, (uint8_t*)&pu8Buf[1], 1, 5) == commonECU_SUCCESS) {
if (pu8Buf[1] != 0x62) {
PktLen = commonECU_READ_FAIL;
goto EXIT; // 0x62 not found, OUT OF SYNC
}
}
else
{
PktLen = commonECU_READ_FAIL;
goto EXIT;
}
if (xECU_UartGetData(pxUartHandle, (uint8_t*)&pu8Buf[2], 5, DATA_PACKET_TIMEOUT_MS) != commonECU_SUCCESS) {
PktLen = commonECU_READ_FAIL;
goto EXIT;
}
*(u32Id) = (uint32_t)((pu8Buf[6] << 24) | (pu8Buf[5] << 16) | (pu8Buf[4] << 8) | (pu8Buf[3]));
uint8_t l_u8TempLen = pu8Buf[2];
PktLen = ecuUART_PKT_HEADER_FOOTER_u8 + l_u8TempLen;
if (xECU_UartGetData(pxUartHandle, (uint8_t*)&pu8Buf[ecuUART_PKT_HEADER_u8], (uint32_t)(PktLen - ecuUART_PKT_HEADER_u8), DATA_PACKET_TIMEOUT_MS) != commonECU_SUCCESS)
{
PktLen = commonECU_READ_FAIL;
goto EXIT;
}
uint8_t l_u8CheckSum[2];
_prv_EcuCalculateChecksum(pu8Buf, PktLen, l_u8CheckSum);
/* TODO: (Python Script) Sometimes fails due to bad checksum */
if ((l_u8CheckSum[0] == pu8Buf[PktLen - 2]) && (l_u8CheckSum[1] == pu8Buf[PktLen - 1])) {
PktLen -= ecuUART_PKT_HEADER_FOOTER_u8;
}
else
{
IVEC_ECU_LOG(LOG_STRING, "Packet Checksum Failed\n");
PktLen = commonECU_READ_FAIL;
}
}
else
{
// COM_FlushBuffer();
PktLen = ecuUART_PACKET_FAIL_i8;
}
}
EXIT:
return PktLen;
}
/**
* @brief Reads CAN data over UART and returns the packet length.
*
* This function first validates the UART handle and checks the packet
* length over UART by calling `xECU_UartReadCANDataLenOverUART`.
* It returns the result based on the outcome of that function.
*
* @param[in] pxUartHandle Pointer to the UART handle for communication.
* @param[out] pu8Buf Buffer to store the received data.
* @param[out] u32Id Pointer to store the extracted CAN ID.
*
* @return The result of reading the CAN data over UART.
* - `ecuUART_PACKET_FAIL_i8` if the UART handle is invalid or the
* packet read fails.
*/
IVEC_ECU_UartPacketRetCode_e xECU_UartReadCANDataOverUART(IVEC_EcuUartHandle_s* pxUartHandle, uint8_t* pu8Buf, uint32_t* u32Id)
{
if (pxUartHandle == NULL || pxUartHandle->eUartPortNumber >= IVEC_ECU_UART_PORT_MAX)
{
return ecuUART_PACKET_FAIL_i8;
}
IVEC_ECU_UartPacketRetCode_e l_eRetCode = ecuUART_PACKET_FAIL_i8;
l_eRetCode = xECU_UartReadCANDataLenOverUART(pxUartHandle, pu8Buf, u32Id);
return l_eRetCode;
}
/**
* @brief Writes data to UART.
*
* This function writes a buffer of data to the UART, returning a success
* or failure status based on the outcome of the write operation.
*
* @param[in] pxUartHandle Pointer to the UART handle for communication.
* @param[in] pu8Buffer Pointer to the buffer containing the data to send.
* @param[in] len Length of the data to send.
*
* @return Status of the write operation:
* - `commonECU_SUCCESS` if successful.
* - `commonECU_INVALID_PARAM` if the UART handle is invalid.
* - `commonECU_WRITE_FAIL` if the write operation fails.
*/
IVEC_EcuCommonErr_e IVEC_ECUUartWrite(IVEC_EcuUartHandle_s* pxUartHandle, uint8_t* pu8Buffer, uint16_t len)
{
IVEC_EcuCommonErr_e l_eFuncStatus = commonECU_WRITE_FAIL;
uint8_t l_i32Ret;
if (pxUartHandle == NULL)
{
l_eFuncStatus = commonECU_INVALID_PARAM;
}
l_i32Ret = xMCAL_UartWrite(&pxUartHandle->__xUartHandle, pu8Buffer, len);
if (l_i32Ret == IVEC_CORE_STATUS_SUCCESS)
{
l_eFuncStatus = commonECU_SUCCESS;
}
return l_eFuncStatus;
}
/**
* @brief Formats and prepares a UART packet for transmission.
*
* This function formats a packet with a sync character, data length, CAN ID,
* and checksum, and then sends it via UART using `IVEC_ECU_Uart_Write`.
*
* @param[in] pxUartHandle Pointer to the UART handle for communication.
* @param[in] pucData Pointer to the data buffer to format.
* @param[in] ucDlc Data length code (DLC) for the packet.
* @param[in] u32Id CAN ID to be included in the packet.
*
* @return Status of the packet formatting:
* - `IVEC_ECU_UART_PACKET_SUCCESS` if successful.
* - `ecuUART_PACKET_FAIL_i8` if the packet formatting or write fails.
*/
IVEC_ECU_UartPacketRetCode_e xECU_UartFormatPacket(IVEC_EcuUartHandle_s* pxUartHandle, uint8_t* pu8Data, uint8_t u8Dlc, uint32_t u32Id)
{
pu8Data[0] = 0xb5; // SYNC_CHAR[0]
pu8Data[1] = 0x62; // SYNC_CHAR[1]
pu8Data[2] = u8Dlc;
memcpy(&pu8Data[3], &u32Id, sizeof(uint32_t));
unsigned char l_u8CheckSum[2] = { 0 };
_prv_EcuCalculateChecksum(pu8Data, (u8Dlc + ecuUART_PKT_HEADER_FOOTER_u8), l_u8CheckSum);
pu8Data[(u8Dlc + ecuUART_PKT_HEADER_FOOTER_u8) - 2] = l_u8CheckSum[0];
pu8Data[(u8Dlc + ecuUART_PKT_HEADER_FOOTER_u8) - 1] = l_u8CheckSum[1];
if (IVEC_ECUUartWrite(pxUartHandle, pu8Data, (u8Dlc + ecuUART_PKT_HEADER_FOOTER_u8)) != commonECU_SUCCESS) {
return ecuUART_PACKET_FAIL_i8;
}
return ecuUART_PACKET_SUCCESS_u8;
}
/**
* @brief Initiates UART data transmission.
*
* This function prepares a data packet with the given CAN ID and data,
* formats the packet, and sends it via UART.
*
* @param[in] pxUartHandle Pointer to the UART handle for communication.
* @param[in] id CAN ID for the packet.
* @param[in] pucData Pointer to the data to send.
* @param[in] ucLen Length of the data to send.
*
* @return Status of the transmission:
* - `0` on success.
* - `-1` on failure.
*/
int32_t iECU_UartInitiateTransmit(IVEC_EcuUartHandle_s* pxUartHandle, uint32_t u32Id, uint8_t* pu8Data, uint8_t u8Len)
{
if (pxUartHandle == NULL || pxUartHandle->eUartPortNumber >= IVEC_ECU_UART_PORT_MAX)
{
return commonECU_INIT_FAIL;
}
uint8_t l_u8Buf[ecuUART_MAX_PACKET_LENGTH_u8] = {0};
memcpy(&l_u8Buf[ecuUART_PKT_HEADER_u8], pu8Data, u8Len);
return (xECU_UartFormatPacket(pxUartHandle, l_u8Buf, u8Len, u32Id) == ecuUART_PACKET_SUCCESS_u8) ? 0 : -1;
}
uint32_t xECU_data_length(IVEC_EcuUartHandle_s* pxUartHandle)
{
uint32_t length = i32CMPLX_FifoCounts((CmplxFifoQueueHandle_s*)&__gprv_xUartResponseQueue[pxUartHandle->eUartPortNumber]);
return(length);
}
Reference in New Issue View Git Blame Copy Permalink