From 1c6fff8d24e48d186668aa086ecc0285f2652f10 Mon Sep 17 00:00:00 2001 From: Rakshita Date: Fri, 17 Jan 2025 18:00:45 +0530 Subject: [PATCH] refactor: Standardized naming conventions and improved CAN functionality - Updated naming conventions in MCAL, ECU layers for UART and CAN, RTE, utils, and main modules. - Applied CAN filters directly in the initialization function for better reliability. - Restricted CAN reinitialization to bus-off errors only. - Enhanced RX interrupt handling for CAN to improve performance and stability. - Made updates to the CAN TX function for better data transmission. - Updated TX functionality to replace buffer usage with queue-based implementation. --- Core/Include/ivec_mcal_i2c.h | 12 +- Core/Include/ivec_mcal_mcan.h | 47 +- Core/Include/ivec_mcal_spi.h | 6 +- Core/Include/ivec_mcal_uart.h | 134 +- Core/Source/ivec_mcal_i2c.c | 66 +- Core/Source/ivec_mcal_mcan.c | 1687 +++++--------------- Core/Source/ivec_mcal_spi.c | 20 +- Core/Source/ivec_mcal_uart.c | 674 ++++---- ivec_ECU/ivec_ecu_can/inc/ivec_ecu_can.h | 89 +- ivec_ECU/ivec_ecu_can/src/ivec_ecu_can.c | 202 ++- ivec_ECU/ivec_ecu_uart/inc/ivec_ecu_uart.h | 64 +- ivec_ECU/ivec_ecu_uart/src/ivec_ecu_uart.c | 641 ++------ ivec_RTE/inc/ivec_rte.h | 12 +- ivec_RTE/src/ivec_rte.c | 422 ++--- main.c | 19 +- utils/utils.c | 312 ++-- utils/utils.h | 150 +- 17 files changed, 1494 insertions(+), 3063 deletions(-) diff --git a/Core/Include/ivec_mcal_i2c.h b/Core/Include/ivec_mcal_i2c.h index dead3cb..2784cf2 100644 --- a/Core/Include/ivec_mcal_i2c.h +++ b/Core/Include/ivec_mcal_i2c.h @@ -17,11 +17,11 @@ #include "../utils/utils.h" #include "string.h" -xCoreStatus_t xMCAL_I2C_init(I2C_Regs *I2C_inst, xI2C_baud_t baud); -xCoreStatus_t xMCU_i2cWriteMcal(I2C_Regs *I2C_inst,uint8_t u8addr ,uint8_t *u8TxPacket, int len); -xCoreStatus_t xMCU_i2cReadMcal(I2C_Regs *I2C_inst, uint8_t u8addr, int len); -xCoreStatus_t xMCU_i2cDevReadyMcal(I2C_Regs *I2C_inst,uint8_t u8addr); -xCoreStatus_t xMcal_I2C_getData(I2C_Regs *I2C_inst, uint8_t *u8RxData, uint8_t len); -xCoreStatus_t xMCAL_I2C_deinit(I2C_Regs *I2C_inst); +IVEC_CoreStatus_e xMCAL_I2C_init(I2C_Regs *I2C_inst, IVEC_I2cBaud_e baud); +IVEC_CoreStatus_e xMCU_i2cWriteMcal(I2C_Regs *I2C_inst,uint8_t u8addr ,uint8_t *u8TxPacket, int len); +IVEC_CoreStatus_e xMCU_i2cReadMcal(I2C_Regs *I2C_inst, uint8_t u8addr, int len); +IVEC_CoreStatus_e xMCU_i2cDevReadyMcal(I2C_Regs *I2C_inst,uint8_t u8addr); +IVEC_CoreStatus_e xMcal_I2C_getData(I2C_Regs *I2C_inst, uint8_t *u8RxData, uint8_t len); +IVEC_CoreStatus_e xMCAL_I2C_deinit(I2C_Regs *I2C_inst); #endif /* CORE_INCLUDE_IVEC_MCAL_I2C_H_ */ diff --git a/Core/Include/ivec_mcal_mcan.h b/Core/Include/ivec_mcal_mcan.h index fe582f1..ea9e580 100644 --- a/Core/Include/ivec_mcal_mcan.h +++ b/Core/Include/ivec_mcal_mcan.h @@ -1,23 +1,40 @@ -#ifndef CORE_INCLUDE_IVEC_MCAL_MCAN_H_ -#define CORE_INCLUDE_IVEC_MCAL_MCAN_H_ +#ifndef CORE_INCLUDE_IVEc_MCAL_MCAN_H_ +#define CORE_INCLUDE_IVEc_MCAL_MCAN_H_ #include "..\utils\utils.h" - #include "ti_msp_dl_config.h" +/* Enum for CAN ID Types */ typedef enum { - STD_ID = 0x00, EXT_ID = 0x01, ERROR = 0x02 -} xCanIdType_t; + IVEC_MCAL_CAN_ID_STD = 0x00, /* Standard ID */ + IVEC_MCAL_CAN_ID_EXT = 0x01, /* Extended ID */ + IVEC_MCAL_CAN_ID_ERROR = 0x02 /* Error ID */ +} xMCAL_CanIdType_e; +/* Function Prototypes for MCAN MCAL Layer */ -IVEC_McalStatus_e xMCAL_MCANInit(MCAN_Regs* const mcan, xCAN_baud_t BAUD); -IVEC_McalStatus_e xMCAL_MCANDeInit(MCAN_Regs* const mcan); -//IVEC_McalStatus_e xMCAL_MCANTx(MCAN_Regs *MCAN, uint32_t u32ID ,uint16_t *TxData, uint32_t BufNum, uint32_t Bytes); -IVEC_McalStatus_e xMCAL_MCANTx(MCAN_Regs *MCAN, uint32_t u32ID ,uint16_t *TxData, uint32_t BufNum, uint32_t Bytes); -IVEC_McalStatus_e xMCAL_MCANTxBlocking(MCAN_Regs *MCAN, uint32_t u32ID ,uint16_t *TxData, uint32_t BufNum, int Bytes); -IVEC_McalStatus_e xMCAL_MCANRx(MCAN_Regs *MCAN,uint32_t *ID ,uint8_t *RxData, int DLC); -IVEC_McalStatus_e xMCAL_getMCAN_ErrorStatus(char *ErrorStatus); -IVEC_McalStatus_e xMCAL_getMCAN_InterruptLine1Status(uint32_t *Interrupt_Status); -IVEC_McalStatus_e xMCAL_resetMCAN(MCAN_Regs* const mcan, xCAN_baud_t BAUD); +/* Initialize the MCAN module */ +IVEC_McalStatus_e vMCAL_MCAN_Init(MCAN_Regs* pMCAN, IVEC_CanBaud_e eBaudRate); -#endif /* CORE_INCLUDE_IVEC_MCAL_MCAN_H_ */ +/* Deinitialize the MCAN module */ +IVEC_McalStatus_e vMCAL_MCAN_DeInit(MCAN_Regs* const pMCAN); + +/* Transmit data via MCAN */ +IVEC_McalStatus_e vMCAL_MCAN_Tx(MCAN_Regs* const pMCAN, uint32_t u32Id, uint16_t* pu16TxData, uint32_t u32BufNum, uint32_t u32Bytes); + +/* Transmit data via MCAN in blocking mode */ +IVEC_McalStatus_e vMCAL_MCAN_TxBlocking(MCAN_Regs* const pMCAN, uint32_t u32Id, uint16_t* pu16TxData, uint32_t u32BufNum, int iBytes); + +/* Receive data via MCAN */ +IVEC_McalStatus_e vMCAL_MCAN_Rx(MCAN_Regs* const pMCAN, uint32_t* pu32Id, uint8_t* pu8RxData, int iDLC); + +/* Get the error status of the MCAN module */ +IVEC_McalStatus_e vMCAL_MCAN_GetErrorStatus(char* pcErrorStatus); + +/* Get interrupt status of MCAN Interrupt Line 1 */ +IVEC_McalStatus_e vMCAL_MCAN_GetInterruptLine1Status(uint32_t* pu32InterruptStatus); + +/* Reset the MCAN module */ +IVEC_McalStatus_e vMCAL_MCAN_Reset(MCAN_Regs* const pMCAN, IVEC_CanBaud_e eBaudRate); + +#endif /* CORE_INCLUDE_IVEc_MCAL_MCAN_H_ */ diff --git a/Core/Include/ivec_mcal_spi.h b/Core/Include/ivec_mcal_spi.h index bd6df69..fffda84 100644 --- a/Core/Include/ivec_mcal_spi.h +++ b/Core/Include/ivec_mcal_spi.h @@ -17,8 +17,8 @@ #include "ti_msp_dl_config.h" #include "../utils/utils.h" -xCoreStatus_t xMCAL_SPI_init(SPI_Regs *SPI_inst, xSPI_CS_t xCS ); -xCoreStatus_t xMCAL_SPI_TxData(SPI_Regs *SPI_inst, uint8_t *u8SPI_TxData, uint8_t * u8SPI_RxData,uint8_t size); -xCoreStatus_t xMCAL_SPI_deinit(SPI_Regs *SPI_inst); +IVEC_CoreStatus_e xMCAL_SPI_init(SPI_Regs *SPI_inst, IVEC_SpiCs_e xCS ); +IVEC_CoreStatus_e xMCAL_SPI_TxData(SPI_Regs *SPI_inst, uint8_t *u8SPI_TxData, uint8_t * u8SPI_RxData,uint8_t size); +IVEC_CoreStatus_e xMCAL_SPI_deinit(SPI_Regs *SPI_inst); #endif /* CORE_INCLUDE_IVEC_MCAL_SPI_H_ */ diff --git a/Core/Include/ivec_mcal_uart.h b/Core/Include/ivec_mcal_uart.h index e2e6e79..1b3a750 100644 --- a/Core/Include/ivec_mcal_uart.h +++ b/Core/Include/ivec_mcal_uart.h @@ -1,106 +1,104 @@ #ifndef CORE_INCLUDE_IVEC_MCAL_UART_H_ #define CORE_INCLUDE_IVEC_MCAL_UART_H_ -//#include "ivec_mcal_uart.h" #include "ti_msp_dl_config.h" #include "../utils/utils.h" #include -//#ifndef IVEC_MCAL_UART_H -//#define IVEC_MCAL_UART_H #include "ivec_mcal_common.h" -//#include "ql_uart.h" typedef enum { - mcalUART_BAUD_AUTO = 0, - mcalUART_BAUD_2400 = 2400, - mcalUART_BAUD_4800 = 4800, - mcalUART_BAUD_9600 = 9600, - mcalUART_BAUD_14400 = 14400, - mcalUART_BAUD_19200 = 19200, - mcalUART_BAUD_28800 = 28800, - mcalUART_BAUD_33600 = 33600, - mcalUART_BAUD_38400 = 38400, - mcalUART_BAUD_57600 = 57600, - mcalUART_BAUD_115200 = 115200, - mcalUART_BAUD_230400 = 230400, - mcalUART_BAUD_460800 = 460800, - mcalUART_BAUD_921600 = 921600, - mcalUART_BAUD_1000000 = 1000000, - mcalUART_BAUD_1843200 = 1843200, - mcalUART_BAUD_2000000 = 2000000, //only support uart2/3 - mcalUART_BAUD_2100000 = 2100000, - mcalUART_BAUD_3686400 = 3686400, //only support uart2/3 - mcalUART_BAUD_4000000 = 4000000, //only support uart2/3 - mcalUART_BAUD_4468750 = 4468750 //only support uart2/3 -}McalUartBaudRate_e; + eMcalUartBaudAuto = 0, + eMcalUartBaud2400 = 2400, + eMcalUartBaud4800 = 4800, + eMcalUartBaud9600 = 9600, + eMcalUartBaud14400 = 14400, + eMcalUartBaud19200 = 19200, + eMcalUartBaud28800 = 28800, + eMcalUartBaud33600 = 33600, + eMcalUartBaud38400 = 38400, + eMcalUartBaud57600 = 57600, + eMcalUartBaud115200 = 115200, + eMcalUartBaud230400 = 230400, + eMcalUartBaud460800 = 460800, + eMcalUartBaud921600 = 921600, + eMcalUartBaud1000000 = 1000000, + eMcalUartBaud1843200 = 1843200, + eMcalUartBaud2000000 = 2000000, + eMcalUartBaud2100000 = 2100000, + eMcalUartBaud3686400 = 3686400, + eMcalUartBaud4000000 = 4000000, + eMcalUartBaud4468750 = 4468750 +} eMcalUartBaudRate; typedef enum { - mcalUART_DATABIT_7 = 7, - mcalUART_DATABIT_8 = 8, //8910 ARM UART hardware only support 8bit Data -}McalUartDataBit_e; + eMcalUartDataBit7 = 7, + eMcalUartDataBit8 = 8 +} eMcalUartDataBit; typedef enum { - mcalUART_STOP_1 = 1, - mcalUART_STOP_2 = 2, -}McalUartStopBit_e; + eMcalUartStopBit1 = 1, + eMcalUartStopBit2 = 2 +} eMcalUartStopBit; typedef enum { - mcalUART_PARITY_NONE, - mcalUART_PARITY_ODD, - mcalUART_PARITY_EVEN, -}McalUartParityBit_e; + eMcalUartParityNone, + eMcalUartParityOdd, + eMcalUartParityEven +} eMcalUartParityBit; typedef enum { - mcalUART_FC_NONE = 0, - mcalUARTFC_HW, -}McalUartFlowCtrl_e; + eMcalUartFcNone = 0, + eMcalUartFcHw +} eMcalUartFlowCtrl; typedef struct { - McalUartBaudRate_e eUartBaudrate; - McalUartDataBit_e eUartDataBit; - McalUartStopBit_e eUartStopBit; - McalUartParityBit_e eUartParityBit; - McalUartFlowCtrl_e eUartFlowCtrl; -}McalUartConfig_s; + eMcalUartBaudRate eUartBaudrate; + eMcalUartDataBit eUartDataBit; + eMcalUartStopBit eUartStopBit; + eMcalUartParityBit eUartParityBit; + eMcalUartFlowCtrl eUartFlowCtrl; +} xMcalUartConfig; typedef enum { - mcalUART_PORT1 = 0, - mcalUART_PORT2, - mcalUART_PORT3, - mcalUART_PORT_MAX -}McalUartPortNumber_e; -#define IVEC_MCAL_GNSS_UART mcalUART_PORT3 + eMcalUartPort1 = 0, + eMcalUartPort2, + eMcalUartPort3, + eMcalUartPortMax +} eMcalUartPortNumber; + +#define IVEC_MCAL_GNSS_UART eMcalUartPort3 + typedef enum { - IVEC_MCAL_UART_EVENT_RX_ARRIVED = 1,//(1 << 0), ///< Received new data - IVEC_MCAL_UART_EVENT_RX_OVERFLOW =2 ,//(1 << 1), ///< Rx fifo overflowed - IVEC_MCAL_UART_EVENT_TX_COMPLETE = 3//(1 << 2) ///< All data had been sent -}IVEC_McalUartEvents_e; + eIvecMcalUartEventRxArrived = 1, ///< Received new data + eIvecMcalUartEventRxOverflow = 2, ///< Rx FIFO overflowed + eIvecMcalUartEventTxComplete = 3 ///< All data had been sent +} eIvecMcalUartEvents; typedef struct { - McalUartPortNumber_e eUartPortNumber; - McalUartConfig_s xUartConfig; - char* buffer; - uint16_t u16len; - void (*pvUartRecvCallback)(McalUartPortNumber_e, IVEC_McalUartEvents_e , char *,uint32_t); -}McalUartHandle_s; + eMcalUartPortNumber eUartPortNumber; + xMcalUartConfig xUartConfig; + char* pcBuffer; + uint16_t u16Length; + void (*pvUartRecvCallback)(eMcalUartPortNumber, eIvecMcalUartEvents, char*, uint32_t); +} xMcalUartHandle; #define IVEC_MCAL_UART_MAX_PORT 3 -IVEC_McalCommonErr_e xMCAL_UartDeInit(McalUartHandle_s* pxHandleUart); -IVEC_McalCommonErr_e xMCAL_UartRead(McalUartHandle_s* pxHandleUart, unsigned char* pucData, unsigned int u32DataLength); -IVEC_McalCommonErr_e xMCAL_UartWrite(McalUartHandle_s* pxHandleUart, unsigned char* pucData, unsigned int u32DataLength); -IVEC_McalCommonErr_e __prvMCAL_UartPinInit(McalUartHandle_s* pxHandleUart); -IVEC_McalCommonErr_e xMCAL_UartInit(McalUartHandle_s* pxHandleUart); +/* Function Prototypes */ +IVEC_McalCommonErr_e xMCAL_UartInit(xMcalUartHandle* pxUartHandle); +IVEC_McalCommonErr_e xMCAL_UartDeInit(xMcalUartHandle* pxUartHandle); +IVEC_McalCommonErr_e xMCAL_UartRead(xMcalUartHandle* pxUartHandle, uint8_t* pu8Data, uint32_t u32DataLength); +IVEC_McalCommonErr_e xMCAL_UartWrite(xMcalUartHandle* pxUartHandle, uint8_t* pu8Data, uint32_t u32DataLength); +IVEC_McalCommonErr_e _prvMCAL_UartPinInit(xMcalUartHandle* pxUartHandle); - -#endif /* IVEC_MCAL_UART_H */ +#endif /* CORE_INCLUDE_IVEC_MCAL_UART_H_ */ diff --git a/Core/Source/ivec_mcal_i2c.c b/Core/Source/ivec_mcal_i2c.c index 72be8f3..bccdc3c 100644 --- a/Core/Source/ivec_mcal_i2c.c +++ b/Core/Source/ivec_mcal_i2c.c @@ -39,7 +39,7 @@ static const DL_I2C_ClockConfig gI2C_0ClockConfig = { static volatile uint8_t u8GlobalPacket[8]; -static volatile xI2cControllerStatus_t xStatus_i2c = I2C_STATUS_IDLE; +static volatile IVEC_I2cControllerStatus_e xStatus_i2c = IVEC_I2C_STATUS_IDLE; /*____________________________________________________________________________________________________________________________________________________________________________________________*/ @@ -52,14 +52,14 @@ void _prv_vI2C_Callback() switch (DL_I2C_getPendingInterrupt(I2C0)) { case DL_I2C_IIDX_CONTROLLER_RX_DONE: - xStatus_i2c = I2C_STATUS_RX_COMPLETE; + xStatus_i2c = IVEC_I2C_STATUS_RX_COMPLETE; break; case DL_I2C_IIDX_CONTROLLER_TX_DONE: DL_I2C_disableInterrupt(I2C0, DL_I2C_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER); - xStatus_i2c = I2C_STATUS_TX_COMPLETE; + xStatus_i2c = IVEC_I2C_STATUS_TX_COMPLETE; break; case DL_I2C_IIDX_CONTROLLER_RXFIFO_TRIGGER: - xStatus_i2c = I2C_STATUS_RX_INPROGRESS; + xStatus_i2c = IVEC_I2C_STATUS_RX_INPROGRESS; /* Receive all bytes from target */ while (DL_I2C_isControllerRXFIFOEmpty(I2C0) != true) { if (i32bufferIdx0 #include "string.h" -volatile bool b_MCAN_InitFlag = 0; /*!< CAN initialization flag */ -volatile uint8_t u8_MCAN_StatusFlag = IVEC_MCAL_STATUS_ERROR; -volatile bool b_ServiceInt=true; -volatile uint32_t u32InterruptLine1Status; -volatile char u8ErrorInterruptStatus[50]; -volatile DL_MCAN_RxFIFOStatus rxFS; -volatile DL_MCAN_RxBufElement TempRxMsg; -volatile uint8_t TempRxBuffer[8]; -volatile uint32_t TempRxID; -volatile uint32_t id; -volatile DL_MCAN_ProtocolStatus HeaderStat; -volatile uint32_t l_canTransmitTimeout; -volatile uint8_t u8CallBack_buff[8]={0}; -volatile IVEC_McalStatus_e l_statusFlag = IVEC_MCAL_STATUS_SUCCESS; -extern g_u16CanSpeed; -/*REQUIRED MCAN CONFIGS*/ -#define MCAN_FILTER_SIZE 0u +/* MCAN Initialization Flag */ +volatile bool bMCAL_MCAN_InitFlag = false; + +/* MCAN Status Flag */ +volatile uint8_t u8MCAL_MCAN_StatusFlag = IVEC_MCAL_STATUS_ERROR; + +/* Service Interrupt Flag */ +volatile bool bMCAL_ServiceInterrupt = true; + +/* MCAN Protocol Status Header */ +volatile DL_MCAN_ProtocolStatus xMCAL_HeaderStat; + +extern IVEC_CanBaud_e g_eCanSpeed; + +/* MCAN Interrupt Line 1 Status */ +volatile uint32_t u32MCAL_InterruptLine1Status; + +/* MCAN Error Interrupt Status */ +volatile char cMCAL_ErrorInterruptStatus[50]; + +volatile uint32_t can_interrupt = 0; + +#define ivMCAL_MAX_FILTERS 10 +extern int32_t g_i32FilterCount; +extern int32_t g_i32MaskCount; +extern uint32_t g_u32MaskValues[ivMCAL_MAX_FILTERS]; +extern uint32_t g_u32FilterValues[ivMCAL_MAX_FILTERS]; +volatile DL_MCAN_RxBufElement xMCAL_TempRxMsgInFunction; -__attribute__((weak)) void mcu_FDCAN_RxFifo_Callback(uint32_t Identifier, uint8_t *data, uint16_t DataLength) +__attribute__((weak)) void vMCU_FDCAN_RxFifo_Callback(uint32_t Identifier, uint8_t *data, uint16_t DataLength) { } @@ -51,8 +62,8 @@ static DL_MCAN_InitParams gMCAN0InitParams= { .efbi = false, .pxhddisable = false, .darEnable = false, - .wkupReqEnable = false, - .autoWkupEnable = false, + .wkupReqEnable = true, + .autoWkupEnable = true, .emulationEnable = true, .tdcEnable = true, .wdcPreload = 255, @@ -76,57 +87,55 @@ static DL_MCAN_ConfigParams gMCAN0ConfigParams={ .filterConfig.anfe = 0, .filterConfig.anfs = 0, }; - -static DL_MCAN_MsgRAMConfigParams gMCAN0MsgRAMConfigParams ={ +static DL_MCAN_MsgRAMConfigParams gMCAN0MsgRAMConfigParams = { /* Standard ID Filter List Start Address. */ - .flssa = 1, + .flssa = 0x0, /* List Size: Standard ID. */ - .lss = MCAN_FILTER_SIZE, + .lss = 10, /* Extended ID Filter List Start Address. */ - .flesa = 48 , + .flesa = 10 , /* List Size: Extended ID. */ - .lse = 0 , + .lse = 10 , /* Tx Buffers Start Address. */ - .txStartAddr = 10 , + .txStartAddr = 40 + 80 , /* Number of Dedicated Transmit Buffers. */ - .txBufNum = 10 , - .txFIFOSize = 10, + .txBufNum = 0 , + .txFIFOSize = 3, /* Tx Buffer Element Size. */ - .txBufMode = 0, - .txBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, + .txBufMode = 0, + .txBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, /* Tx Event FIFO Start Address. */ - .txEventFIFOStartAddr = 640 , + .txEventFIFOStartAddr = 0 , /* Event FIFO Size. */ - .txEventFIFOSize = 10 , + .txEventFIFOSize = 0 , /* Level for Tx Event FIFO watermark interrupt. */ .txEventFIFOWaterMark = 0, /* Rx FIFO0 Start Address. */ - .rxFIFO0startAddr = 170 , + .rxFIFO0startAddr = 40 + 80 + 36 , /* Number of Rx FIFO elements. */ - .rxFIFO0size = 10 , + .rxFIFO0size = 3 , /* Rx FIFO0 Watermark. */ - .rxFIFO0waterMark = 0, - .rxFIFO0OpMode = 0, + .rxFIFO0waterMark = 0, + .rxFIFO0OpMode = 0, /* Rx FIFO1 Start Address. */ - .rxFIFO1startAddr = 190 , + .rxFIFO1startAddr = 40 + 80 + 36 + 36 , /* Number of Rx FIFO elements. */ - .rxFIFO1size = 10 , + .rxFIFO1size = 3 , /* Level for Rx FIFO 1 watermark interrupt. */ - .rxFIFO1waterMark = 10, + .rxFIFO1waterMark = 0, /* FIFO blocking mode. */ - .rxFIFO1OpMode = 0, + .rxFIFO1OpMode = 0, /* Rx Buffer Start Address. */ - .rxBufStartAddr = 208 , + .rxBufStartAddr = 0 , /* Rx Buffer Element Size. */ - .rxBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, + .rxBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, /* Rx FIFO0 Element Size. */ - .rxFIFO0ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, + .rxFIFO0ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, /* Rx FIFO1 Element Size. */ - .rxFIFO1ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, + .rxFIFO1ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, }; - static DL_MCAN_BitTimingParams gMCAN0BitTimes_500 = { /* Arbitration Baud Rate Pre-scaler. */ .nomRatePrescalar = 0, @@ -146,24 +155,6 @@ static DL_MCAN_BitTimingParams gMCAN0BitTimes_500 = { .dataSynchJumpWidth = 0, }; -//static DL_MCAN_BitTimingParams gMCAN0BitTimes_250 = { -// /* Arbitration Baud Rate Pre-scaler. */ -// .nomRatePrescalar = 0, -// /* Arbitration Time segment before sample point. */ -// .nomTimeSeg1 = 138, -// /* Arbitration Time segment after sample point. */ -// .nomTimeSeg2 = 19, -// /* Arbitration (Re)Synchronization Jump Width Range. */ -// .nomSynchJumpWidth = 19, -// /* Data Baud Rate Pre-scaler. */ -// .dataRatePrescalar = 0, -// /* Data Time segment before sample point. */ -// .dataTimeSeg1 = 0, -// /* Data Time segment after sample point. */ -// .dataTimeSeg2 = 0, -// /* Data (Re)Synchronization Jump Width. */ -// .dataSynchJumpWidth = 0, -//}; static const DL_MCAN_BitTimingParams gMCAN0BitTimes_250 = { /* Arbitration Baud Rate Pre-scaler. */ .nomRatePrescalar = 0, @@ -183,63 +174,6 @@ static const DL_MCAN_BitTimingParams gMCAN0BitTimes_250 = { .dataSynchJumpWidth = 0, }; -static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem1 = { - .sfec = 001, - .sft = 0x00, - .sfid1 = 0, - .sfid2 = 256, -}; - -static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem2 = { - .sfec = 0x1, - .sft = 0x00, - .sfid1 = 1536, - .sfid2 = 2046, -}; - -static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem3 = { - .sfec = 0x1, - .sft = 0x00, - .sfid1 = 0x1A4, - .sfid2 = 0x1A4, -}; - -static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem4 = { - .sfec = 0x1, - .sft = 0x00, - .sfid1 = 0x521, - .sfid2 = 0x521, -}; - -static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem5 = { - .sfec = 0x1, - .sft = 0x00, - .sfid1 = 0x16, - .sfid2 = 0x16, -}; - -static const DL_MCAN_ExtMsgIDFilterElement gMCAN0ExtFiltelem1 = { - .efec = 0x1, - .eft = 0x0, - .efid1 = 2047, - .efid2 = 536870911, -}; - - -static const DL_MCAN_ExtMsgIDFilterElement gMCAN0ExtFiltelem2 = { - .efec = 0x1, - .eft = 0x0, - .efid1 = 2047, - .efid2 = 536870911, -}; - -static const DL_MCAN_ExtMsgIDFilterElement gMCAN0ExtFiltelem3 = { - .efec = 0x1, - .eft = 0x0, - .efid1 = 0x1CEBFF23, - .efid2 = 0x1CEBFF23, -}; - volatile DL_MCAN_TxBufElement txMsg = { .id = ((uint32_t)(0x00)) << 18U, .rtr = 0U, @@ -253,8 +187,6 @@ volatile DL_MCAN_TxBufElement txMsg = { .data = {0}, }; - - /*____________________________________________________________________________________________________________________________________________________________________________________________*/ @@ -266,89 +198,162 @@ volatile DL_MCAN_TxBufElement txMsg = { * @brief Static Function to store RX data in a static buffer * @retval void */ -static void _prv_vGetRxMsg(DL_MCAN_RxBufElement *rxMsg,uint32_t *ID,uint8_t *RxData,int DLC) +static void _prv_vMCAL_MCAN_StoreRxData(const DL_MCAN_RxBufElement* pRxMsg, uint32_t* pu32Id, uint8_t* pu8RxData, int iDLC) { - - for (int i =0 ; i < DLC ; i++) - - { - RxData[i] = (rxMsg->data[i] & 0xFF); + /* Extract data from the RX message into the buffer */ + for (int i = 0; i < iDLC; i++) { + pu8RxData[i] = (pRxMsg->data[i] & 0xFF); } } void __prv_CANInterruptProcess(uint32_t u32InterruptStatus) { - uint32_t IntrStatus = u32InterruptStatus; - DL_MCAN_getProtocolStatus(CANFD0, &HeaderStat); + can_interrupt = u32InterruptStatus; + uint32_t u32IntrStatus = u32InterruptStatus; + if (u32IntrStatus & (DL_MCAN_INTERRUPT_RF1F | DL_MCAN_INTERRUPT_RF0N | DL_MCAN_INTERRUPT_RF0F | DL_MCAN_INTERRUPT_RF1N)) { - if (IntrStatus & DL_MCAN_INTERRUPT_TC){ - b_ServiceInt = true; - u8_MCAN_StatusFlag = IVEC_MCAL_STATUS_SUCCESS; - } + volatile DL_MCAN_RxFIFOStatus xMCAL_RxFIFOStatus; - if( IntrStatus & DL_MCAN_INTERRUPT_BO) - DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); - if(IntrStatus & (DL_MCAN_INTERRUPT_RF0N | DL_MCAN_INTERRUPT_RF1N)){ + if (u32IntrStatus & (DL_MCAN_INTERRUPT_RF0F | DL_MCAN_INTERRUPT_RF0N)) + xMCAL_RxFIFOStatus.num = DL_MCAN_RX_FIFO_NUM_0; + else + xMCAL_RxFIFOStatus.num = DL_MCAN_RX_FIFO_NUM_1; + DL_MCAN_getRxFIFOStatus(CANFD0, &xMCAL_RxFIFOStatus); - while (false == b_ServiceInt); + while ((xMCAL_RxFIFOStatus.fillLvl) != 0) + { + volatile DL_MCAN_RxBufElement xMCAL_TempRxMsg; - b_ServiceInt = false; - rxFS.fillLvl = 0; - rxFS.num = (IntrStatus & DL_MCAN_INTERRUPT_RF0N) ? DL_MCAN_RX_FIFO_NUM_0 : DL_MCAN_RX_FIFO_NUM_1; + DL_MCAN_readMsgRam(CANFD0, DL_MCAN_MEM_TYPE_FIFO, 0, xMCAL_RxFIFOStatus.num, &xMCAL_TempRxMsg); + DL_MCAN_writeRxFIFOAck(CANFD0, xMCAL_RxFIFOStatus.num, xMCAL_RxFIFOStatus.getIdx); - while ((rxFS.fillLvl) == 0) - { - DL_MCAN_getRxFIFOStatus(CANFD0, &rxFS); - } + if (!xMCAL_TempRxMsg.xtd) + xMCAL_TempRxMsg.id = (uint32_t)(xMCAL_TempRxMsg.id >> 18); - DL_MCAN_readMsgRam(CANFD0, DL_MCAN_MEM_TYPE_FIFO, 0, rxFS.num, &TempRxMsg); - DL_MCAN_writeRxFIFOAck(CANFD0, rxFS.num, rxFS.getIdx); - - b_ServiceInt = true; - if(HeaderStat.busOffStatus==1) - { - DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); - } - - if( !TempRxMsg.xtd ) - TempRxMsg.id = (uint32_t)(TempRxMsg.id >> 18); - uint8_t l_pu8DataArr[8] = {0}; - for( int ijk = 0; ijk < 8; ijk++ ) - l_pu8DataArr[ijk] = TempRxMsg.data[ijk] & 0xFF; - - mcu_FDCAN_RxFifo_Callback(TempRxMsg.id, &l_pu8DataArr[0], TempRxMsg.dlc); - } + /* Extract data payload */ + uint8_t au8DataArr[8] = {0}; + for (int i = 0; i < 8; i++) { + au8DataArr[i] = xMCAL_TempRxMsg.data[i] & 0xFF; + } + vMCAL_CanReceiveFifoCallback(xMCAL_TempRxMsg.id, &xMCAL_TempRxMsg.data[0], xMCAL_TempRxMsg.dlc); + DL_MCAN_getRxFIFOStatus(CANFD0, &xMCAL_RxFIFOStatus); + } + } + if(u32IntrStatus & (DL_MCAN_INTR_SRC_MSG_RAM_ACCESS_FAILURE|DL_MCAN_INTR_SRC_TIMEOUT|DL_MCAN_INTR_SRC_ERR_LOG_OVRFLW|DL_MCAN_INTR_SRC_ERR_PASSIVE|DL_MCAN_INTR_SRC_ERR_PASSIVE|DL_MCAN_INTR_SRC_WARNING_STATUS|DL_MCAN_INTR_SRC_BUS_OFF_STATUS|DL_MCAN_INTR_SRC_WATCHDOG|DL_MCAN_INTR_SRC_PROTOCOL_ERR_ARB|DL_MCAN_INTR_SRC_PROTOCOL_ERR_DATA|DL_MCAN_INTR_SRC_RES_ADDR_ACCESS) ) { + can_interrupt = u32InterruptStatus; + } } +//void vMCAL_MCAN_InterruptProcess(uint32_t u32InterruptStatus) +//{ +// uint32_t u32IntrStatus = u32InterruptStatus; +// +//// /* Retrieve protocol status */ +//// DL_MCAN_getProtocolStatus(CANFD0, &xMCAL_HeaderStat); +//// +//// /* Handle Transmission Complete Interrupt */ +//// if (u32IntrStatus & DL_MCAN_INTERRUPT_TC) { +//// bMCAL_ServiceInterrupt = true; +//// u8MCAL_MCAN_StatusFlag = IVEC_MCAL_STATUS_SUCCESS; +//// } +//// +//// /* Handle Bus Off Interrupt */ +//// if (u32IntrStatus & DL_MCAN_INTERRUPT_BO) { +//// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); +//// } +// +// /* Handle Receive FIFO New Message Interrupt */ +// if (u32IntrStatus & (DL_MCAN_INTERRUPT_RF0N | DL_MCAN_INTERRUPT_RF1N)) { +// while (!bMCAL_ServiceInterrupt); +// +// bMCAL_ServiceInterrupt = false; +// +// /* MCAN RX FIFO Status */ +// volatile DL_MCAN_RxFIFOStatus xMCAL_RxFIFOStatus; +// +// /* Determine which FIFO triggered the interrupt */ +// xMCAL_RxFIFOStatus.fillLvl = 0; +// xMCAL_RxFIFOStatus.num = (u32IntrStatus & DL_MCAN_INTERRUPT_RF0N) +// ? DL_MCAN_RX_FIFO_NUM_0 +// : DL_MCAN_RX_FIFO_NUM_1; +// +// /* Wait until the FIFO has data */ +// while (xMCAL_RxFIFOStatus.fillLvl == 0) { +// DL_MCAN_getRxFIFOStatus(CANFD0, &xMCAL_RxFIFOStatus); +// } +// +// /* Read the message from the FIFO */ +// DL_MCAN_readMsgRam(CANFD0, DL_MCAN_MEM_TYPE_FIFO, 0, +// xMCAL_RxFIFOStatus.num, &xMCAL_TempRxMsg); +// +// /* Acknowledge the message */ +// DL_MCAN_writeRxFIFOAck(CANFD0, xMCAL_RxFIFOStatus.num, +// xMCAL_RxFIFOStatus.getIdx); +// +// bMCAL_ServiceInterrupt = true; +// +// /* Handle Bus Off Recovery */ +// if (xMCAL_HeaderStat.busOffStatus == 1) { +// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); +// } +// +// /* Process Standard or Extended ID */ +// if (!xMCAL_TempRxMsg.xtd) { +// xMCAL_TempRxMsg.id = (uint32_t)(xMCAL_TempRxMsg.id >> 18); +// } +// +// /* Extract data payload */ +// uint8_t au8DataArr[8] = {0}; +// for (int i = 0; i < 8; i++) { +// au8DataArr[i] = xMCAL_TempRxMsg.data[i] & 0xFF; +// } +// +// /* Call the RX FIFO callback function */ +// vMCU_FDCAN_RxFifo_Callback(xMCAL_TempRxMsg.id, au8DataArr, xMCAL_TempRxMsg.dlc); +// } +//} + /** * @brief Default Interrupt Handler for MCAN * */ + void CANFD0_IRQHandler(void) { - switch (DL_MCAN_getPendingInterrupt(CANFD0)) { + /* Get the pending interrupt source */ + switch (DL_MCAN_getPendingInterrupt(CANFD0)) + { case DL_MCAN_IIDX_LINE1: { - uint32_t IntrStatus = DL_MCAN_getIntrStatus(CANFD0); - __prv_CANInterruptProcess(IntrStatus); - DL_MCAN_clearIntrStatus(MCAN0_INST, IntrStatus, - DL_MCAN_INTR_SRC_MCAN_LINE_1); + /* Get interrupt status for Line 1 */ + uint32_t u32IntrStatus = DL_MCAN_getIntrStatus(CANFD0); + /* Process the interrupt */ + __prv_CANInterruptProcess(u32IntrStatus); + + /* Clear the interrupt status for Line 1 */ + DL_MCAN_clearIntrStatus(MCAN0_INST, u32IntrStatus, DL_MCAN_INTR_SRC_MCAN_LINE_1); + break; } - break; case DL_MCAN_IIDX_LINE0: { - uint32_t IntrStatus = DL_MCAN_getIntrStatus(CANFD0); - __prv_CANInterruptProcess(IntrStatus); - DL_MCAN_clearIntrStatus(MCAN0_INST, IntrStatus, - DL_MCAN_INTR_SRC_MCAN_LINE_0); + /* Get interrupt status for Line 0 */ + uint32_t u32IntrStatus = DL_MCAN_getIntrStatus(CANFD0); + + /* Process the interrupt */ + __prv_CANInterruptProcess(u32IntrStatus); + + /* Clear the interrupt status for Line 0 */ + DL_MCAN_clearIntrStatus(MCAN0_INST, u32IntrStatus, DL_MCAN_INTR_SRC_MCAN_LINE_0); break; } default: { - uint32_t IntrStatus = DL_MCAN_getIntrStatus(CANFD0); - DL_MCAN_clearIntrStatus(MCAN0_INST, IntrStatus, - DL_MCAN_INTR_SRC_MCAN_EXT_TS); + /* Get interrupt status for external timestamp */ + uint32_t u32IntrStatus = DL_MCAN_getIntrStatus(CANFD0); + + /* Clear the interrupt status for external timestamp */ + DL_MCAN_clearIntrStatus(MCAN0_INST, u32IntrStatus, DL_MCAN_INTR_SRC_MCAN_EXT_TS); break; } } @@ -365,135 +370,136 @@ void CANFD0_IRQHandler(void) * @param BAUD Param to set Baud rate of MCAN * @retval IVEC_McalStatus_e */ -IVEC_McalStatus_e xMCAL_MCANInit(MCAN_Regs* MCAN, xCAN_baud_t BAUD) + +IVEC_McalStatus_e vMCAL_MCAN_Init(MCAN_Regs* pMCAN, IVEC_CanBaud_e eBaudRate) { - assert(MCAN == CANFD0); - assert(BAUD == BAUD_500 || BAUD == BAUD_250); - assert(b_MCAN_InitFlag == 0); + assert(pMCAN == CANFD0); + assert(eBaudRate == IVEC_CAN_BAUD_500 || eBaudRate == IVEC_CAN_BAUD_250); + assert(bMCAL_MCAN_InitFlag == 0); DL_MCAN_RevisionId revid_MCAN0; - DL_MCAN_enableModuleClock(MCAN); + DL_MCAN_enableModuleClock(pMCAN); - DL_MCAN_setClockConfig(MCAN, (DL_MCAN_ClockConfig *) &gMCAN0ClockConf); + DL_MCAN_setClockConfig(pMCAN, (DL_MCAN_ClockConfig *) &gMCAN0ClockConf); /* Get MCANSS Revision ID. */ - DL_MCAN_getRevisionId(MCAN, &revid_MCAN0); + DL_MCAN_getRevisionId(pMCAN, &revid_MCAN0); /* Wait for Memory initialization to be completed. */ - while(false == DL_MCAN_isMemInitDone(MCAN)); + while (false == DL_MCAN_isMemInitDone(pMCAN)); /* Put MCAN in SW initialization mode. */ - DL_MCAN_setOpMode(MCAN, DL_MCAN_OPERATION_MODE_SW_INIT); + DL_MCAN_setOpMode(pMCAN, DL_MCAN_OPERATION_MODE_SW_INIT); /* Wait till MCAN is not initialized. */ - while (DL_MCAN_OPERATION_MODE_SW_INIT != DL_MCAN_getOpMode(MCAN)); + while (DL_MCAN_OPERATION_MODE_SW_INIT != DL_MCAN_getOpMode(pMCAN)); /* Initialize MCAN module. */ - DL_MCAN_init(MCAN, (DL_MCAN_InitParams *) &gMCAN0InitParams); + DL_MCAN_init(pMCAN, (DL_MCAN_InitParams*)&gMCAN0InitParams); + gMCAN0ConfigParams.filterConfig.anfe = 0; + gMCAN0ConfigParams.filterConfig.anfs = 0; +// g_u32FilterValues[0]=1312; +// g_u32MaskValues[0]=2047; +// g_i32MaskCount=0; +// g_i32FilterCount=0; + for (int u32Index = 0; u32Index <= g_i32MaskCount; u32Index++) { + if ((g_u32FilterValues[u32Index] > 0x7FF) || (g_u32MaskValues[u32Index] > 0x7FF)) { + gMCAN0ConfigParams.filterConfig.anfe = 3; + } + else + { + gMCAN0ConfigParams.filterConfig.anfs = 3; + } + } /* Configure MCAN module. */ - DL_MCAN_config(MCAN, (DL_MCAN_ConfigParams*) &gMCAN0ConfigParams); + DL_MCAN_config(pMCAN, (DL_MCAN_ConfigParams*)&gMCAN0ConfigParams); /* Configure Bit timings. */ - if(BAUD==BAUD_500) + if (eBaudRate == IVEC_CAN_BAUD_500) { - DL_MCAN_setBitTime(MCAN, (DL_MCAN_BitTimingParams*) &gMCAN0BitTimes_500); + DL_MCAN_setBitTime(pMCAN, (DL_MCAN_BitTimingParams*)&gMCAN0BitTimes_500); } - else if(BAUD==BAUD_250) + else if (eBaudRate == IVEC_CAN_BAUD_250) { - DL_MCAN_setBitTime(MCAN, (DL_MCAN_BitTimingParams*) &gMCAN0BitTimes_250); + DL_MCAN_setBitTime(pMCAN, (DL_MCAN_BitTimingParams*)&gMCAN0BitTimes_250); } else { - DL_MCAN_setBitTime(MCAN, (DL_MCAN_BitTimingParams*) &gMCAN0BitTimes_500); + DL_MCAN_setBitTime(pMCAN, (DL_MCAN_BitTimingParams*)&gMCAN0BitTimes_500); } /* Configure Message RAM Sections */ - DL_MCAN_msgRAMConfig(MCAN, (DL_MCAN_MsgRAMConfigParams*) &gMCAN0MsgRAMConfigParams); + DL_MCAN_msgRAMConfig(pMCAN, (DL_MCAN_MsgRAMConfigParams*)&gMCAN0MsgRAMConfigParams); - /* Configure Standard ID filter element */ -// DL_MCAN_addStdMsgIDFilter(MCAN, 0U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem1); -// -// DL_MCAN_addStdMsgIDFilter(MCAN, 1U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem2); -// -// DL_MCAN_addStdMsgIDFilter(MCAN, 2U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem3); -// -// DL_MCAN_addStdMsgIDFilter(MCAN, 3U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem4); -// -// DL_MCAN_addStdMsgIDFilter(MCAN, 4U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem5); -// -// DL_MCAN_addExtMsgIDFilter(MCAN, 0U,(DL_MCAN_ExtMsgIDFilterElement *)&gMCAN0ExtFiltelem1); -//// -// DL_MCAN_addExtMsgIDFilter(MCAN, 1U,(DL_MCAN_ExtMsgIDFilterElement *)&gMCAN0ExtFiltelem2); -// -// DL_MCAN_addExtMsgIDFilter(MCAN, 2U,(DL_MCAN_ExtMsgIDFilterElement *)&gMCAN0ExtFiltelem3); + uint8_t l_u8ExtendedFilterCount = 0; + uint8_t l_u8StandardFilterCount = 0; + for (int u32Index = 0; u32Index <= g_i32MaskCount; u32Index++) { + if ((g_u32FilterValues[u32Index] > 0x7FF) || (g_u32MaskValues[u32Index] > 0x7FF)) { + // Extended ID filter + DL_MCAN_ExtMsgIDFilterElement extFilterElement; + extFilterElement.efid1 = g_u32FilterValues[u32Index]; + extFilterElement.efid2 = g_u32MaskValues[u32Index]; + extFilterElement.efec = 001; + extFilterElement.eft = 2; + DL_MCAN_addExtMsgIDFilter(pMCAN, l_u8ExtendedFilterCount, (DL_MCAN_StdMsgIDFilterElement*)&extFilterElement); + l_u8ExtendedFilterCount++; - /* Set Extended ID Mask. */ - DL_MCAN_setExtIDAndMask(MCAN, (0x1FFFFFFFU)); + } + else { + // Standard ID filter + DL_MCAN_StdMsgIDFilterElement stdFilterElement; + stdFilterElement.sfid1 = g_u32FilterValues[u32Index]; + stdFilterElement.sfid2 = g_u32MaskValues[u32Index]; + stdFilterElement.sfec = 001; + stdFilterElement.sft = 2; + DL_MCAN_addStdMsgIDFilter(pMCAN, l_u8StandardFilterCount, (DL_MCAN_StdMsgIDFilterElement*)&stdFilterElement); + l_u8StandardFilterCount++; + + } + } + DL_MCAN_setExtIDAndMask(pMCAN, (0x1FFFFFFFU)); /* Take MCAN out of the SW initialization mode */ - DL_MCAN_setOpMode(MCAN, DL_MCAN_OPERATION_MODE_NORMAL); + DL_MCAN_setOpMode(pMCAN, DL_MCAN_OPERATION_MODE_NORMAL); - while (DL_MCAN_OPERATION_MODE_NORMAL != DL_MCAN_getOpMode(MCAN)); + while (DL_MCAN_OPERATION_MODE_NORMAL != DL_MCAN_getOpMode(pMCAN)); /* Enable MCAN mopdule Interrupts */ - - DL_MCAN_enableIntr(MCAN, (DL_MCAN_INTERRUPT_BEU | \ - DL_MCAN_INTERRUPT_BO | \ - DL_MCAN_INTERRUPT_ELO | \ - DL_MCAN_INTERRUPT_EP | \ - DL_MCAN_INTERRUPT_EW | \ - DL_MCAN_INTERRUPT_PEA | \ - DL_MCAN_INTERRUPT_PED | \ - DL_MCAN_INTERRUPT_RF0N | \ - DL_MCAN_INTERRUPT_RF1N | \ - DL_MCAN_INTERRUPT_TC | \ - DL_MCAN_INTERRUPT_TOO), 1U); - - DL_MCAN_selectIntrLine(MCAN, (DL_MCAN_INTERRUPT_BEU | \ - DL_MCAN_INTERRUPT_BO | \ - DL_MCAN_INTERRUPT_ELO | \ - DL_MCAN_INTERRUPT_EP | \ - DL_MCAN_INTERRUPT_EW | \ - DL_MCAN_INTERRUPT_PEA | \ - DL_MCAN_INTERRUPT_PED | \ - DL_MCAN_INTERRUPT_RF0N | \ - DL_MCAN_INTERRUPT_RF1N | \ - DL_MCAN_INTERRUPT_TC | \ - DL_MCAN_INTERRUPT_TOO), DL_MCAN_INTR_LINE_NUM_1); - DL_MCAN_enableIntrLine(MCAN, DL_MCAN_INTR_LINE_NUM_1, 1U); + DL_MCAN_enableIntr(pMCAN, (MCAN_IR_RF0N_MASK | \ + MCAN_IR_RF0F_MASK | \ + MCAN_IR_RF1N_MASK | \ + MCAN_IR_RF1F_MASK | \ + MCAN_IR_TSW_MASK | \ + MCAN_IR_MRAF_MASK | \ + MCAN_IR_TOO_MASK | \ + MCAN_IR_DRX_MASK | \ + MCAN_IR_BEU_MASK | \ + MCAN_IR_ELO_MASK | \ + MCAN_IR_EP_MASK | \ + MCAN_IR_EW_MASK | \ + MCAN_IR_BO_MASK | \ + MCAN_IR_WDI_MASK | \ + MCAN_IR_ARA_MASK), 1); - DL_MCAN_selectIntrLine(MCAN, (DL_MCAN_INTERRUPT_BEU | \ - DL_MCAN_INTERRUPT_BO | \ - DL_MCAN_INTERRUPT_ELO | \ - DL_MCAN_INTERRUPT_EP | \ - DL_MCAN_INTERRUPT_EW | \ - DL_MCAN_INTERRUPT_PEA | \ - DL_MCAN_INTERRUPT_PED | \ - DL_MCAN_INTERRUPT_RF0N | \ - DL_MCAN_INTERRUPT_RF1N | \ - DL_MCAN_INTERRUPT_TC | \ - DL_MCAN_INTERRUPT_TOO), DL_MCAN_INTR_LINE_NUM_0); - DL_MCAN_enableIntrLine(MCAN, DL_MCAN_INTR_LINE_NUM_0, 1U); - + DL_MCAN_selectIntrLine(pMCAN, DL_MCAN_INTR_MASK_ALL, DL_MCAN_INTR_LINE_NUM_0); + DL_MCAN_enableIntrLine(pMCAN, DL_MCAN_INTR_LINE_NUM_0, 1U); /* Enable MSPM0 MCAN interrupt */ - DL_MCAN_clearInterruptStatus(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE0)); - DL_MCAN_enableInterrupt(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE0)); + DL_MCAN_clearInterruptStatus(pMCAN, (DL_MCAN_MSP_INTERRUPT_LINE0)); + DL_MCAN_enableInterrupt(pMCAN, (DL_MCAN_MSP_INTERRUPT_LINE0)); - DL_MCAN_clearInterruptStatus(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE1)); - DL_MCAN_enableInterrupt(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE1)); - NVIC_SetPriority(CANFD0_INT_IRQn, 1); + NVIC_SetPriority(CANFD0_INT_IRQn, 1); + NVIC_ClearPendingIRQ(CANFD0_INT_IRQn); NVIC_EnableIRQ(CANFD0_INT_IRQn); - b_MCAN_InitFlag = 1; + bMCAL_MCAN_InitFlag = 1; return IVEC_MCAL_STATUS_SUCCESS; - } @@ -502,133 +508,66 @@ IVEC_McalStatus_e xMCAL_MCANInit(MCAN_Regs* MCAN, xCAN_baud_t BAUD) * @param MCAN Pointer to the register overlay for the peripheral * @retval IVEC MCAL status */ -//IVEC_McalStatus_e xMCAL_MCANDeInit(MCAN_Regs* MCAN) -//{ -// assert(MCAN == CANFD0); -// assert(b_MCAN_InitFlag != 0); -// -// NVIC_DisableIRQ(CANFD0_INT_IRQn); -// DL_MCAN_disablePower(MCAN); -// b_MCAN_InitFlag = 0; -// -// return IVEC_MCAL_STATUS_SUCCESS; -// -//} -IVEC_McalStatus_e xMCAL_MCANDeInit(MCAN_Regs* MCAN) +IVEC_McalStatus_e vMCAL_MCAN_DeInit(MCAN_Regs* const pMCAN) { - assert(MCAN == CANFD0); - assert(b_MCAN_InitFlag != 0); // Ensure the module was initialized before deinitializing. + /* Assert that the MCAN module pointer is valid */ + assert(pMCAN == CANFD0); + assert(bMCAL_MCAN_InitFlag != 0); /* Ensure the module was initialized before deinitializing. */ - //DL_MCAN_reset(MCAN); + /* Reset the CAN module to initialization mode */ + DL_MCAN_setOpMode(pMCAN, DL_MCAN_OPERATION_MODE_SW_INIT); + /* Wait until the operation mode is set to initialization mode */ + while (DL_MCAN_OPERATION_MODE_SW_INIT != DL_MCAN_getOpMode(pMCAN)); - DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_SW_INIT); - while (DL_MCAN_OPERATION_MODE_SW_INIT != DL_MCAN_getOpMode(MCAN)); - NVIC_DisableIRQ(CANFD0_INT_IRQn); + /* Disable the CAN interrupt */ + NVIC_DisableIRQ(CANFD0_INT_IRQn); + /* Disable interrupts on CAN module */ + DL_MCAN_enableIntr(pMCAN, (DL_MCAN_INTERRUPT_BEU | \ + DL_MCAN_INTERRUPT_BO | \ + DL_MCAN_INTERRUPT_ELO | \ + DL_MCAN_INTERRUPT_EP | \ + DL_MCAN_INTERRUPT_EW | \ + DL_MCAN_INTERRUPT_PEA | \ + DL_MCAN_INTERRUPT_PED | \ + DL_MCAN_INTERRUPT_RF0N | \ + DL_MCAN_INTERRUPT_RF1N | \ + DL_MCAN_INTERRUPT_TC | \ + DL_MCAN_INTERRUPT_TOO), false); - DL_MCAN_enableIntr(MCAN, (DL_MCAN_INTERRUPT_BEU | \ - DL_MCAN_INTERRUPT_BO | \ - DL_MCAN_INTERRUPT_ELO | \ - DL_MCAN_INTERRUPT_EP | \ - DL_MCAN_INTERRUPT_EW | \ - DL_MCAN_INTERRUPT_PEA | \ - DL_MCAN_INTERRUPT_PED | \ - DL_MCAN_INTERRUPT_RF0N | \ - DL_MCAN_INTERRUPT_RF1N | \ - DL_MCAN_INTERRUPT_TC | \ - DL_MCAN_INTERRUPT_TOO), false); + /* Disable interrupt lines */ + DL_MCAN_enableIntrLine(pMCAN, DL_MCAN_INTR_LINE_NUM_0, false); + DL_MCAN_enableIntrLine(pMCAN, DL_MCAN_INTR_LINE_NUM_1, false); - DL_MCAN_enableIntrLine(CANFD0, DL_MCAN_INTR_LINE_NUM_0, false); - DL_MCAN_enableIntrLine(CANFD0, DL_MCAN_INTR_LINE_NUM_1, false); + /* Clear interrupt statuses for lines 0 and 1 */ + DL_MCAN_clearInterruptStatus(pMCAN, DL_MCAN_MSP_INTERRUPT_LINE0); + DL_MCAN_disableInterrupt(pMCAN, DL_MCAN_MSP_INTERRUPT_LINE0); + DL_MCAN_clearInterruptStatus(pMCAN, DL_MCAN_MSP_INTERRUPT_LINE1); + DL_MCAN_disableInterrupt(pMCAN, DL_MCAN_MSP_INTERRUPT_LINE1); - DL_MCAN_clearInterruptStatus(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE0)); - DL_MCAN_disableInterrupt(MCAN, DL_MCAN_MSP_INTERRUPT_LINE0); + /* Set the operation mode back to normal */ + DL_MCAN_setOpMode(pMCAN, DL_MCAN_OPERATION_MODE_NORMAL); - DL_MCAN_clearInterruptStatus(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE1)); - DL_MCAN_disableInterrupt(MCAN, DL_MCAN_MSP_INTERRUPT_LINE1); + /* Reset the initialization flag */ + bMCAL_MCAN_InitFlag = 0; - DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); + /* Disable the CAN module's GPIO peripheral function */ + DL_GPIO_initPeripheralOutputFunction(IOMUX_PINCM59, 0); + DL_GPIO_initPeripheralInputFunction(IOMUX_PINCM60, 0); - b_MCAN_InitFlag = 0; - DL_GPIO_initPeripheralOutputFunction(IOMUX_PINCM59, 0); - DL_GPIO_initPeripheralInputFunction(IOMUX_PINCM60, 0); - DL_MCAN_disableModuleClock(MCAN); - DL_MCAN_disablePower(MCAN); - delay_cycles(16); -// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_SW_INIT); + /* Disable the module clock and power */ + DL_MCAN_disableModuleClock(pMCAN); + DL_MCAN_disablePower(pMCAN); -// while (DL_MCAN_OPERATION_MODE_SW_INIT != DL_MCAN_getOpMode(MCAN)); -// -// DL_GPIO_disablePower(MCAN); -// -// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_SW_INIT); -// -// -// -// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); - - -// DL_MCAN_enableIntrLine(CANFD0, DL_MCAN_INTR_LINE_NUM_1, false); -// -// DL_MCAN_enableIntrLine(CANFD0, DL_MCAN_INTR_LINE_NUM_0, false); - - - - - // DL_MCAN_setOpMode(MCAN, DL_MCAN_OPERATION_MODE_SW_INIT); - - - - /* Wait till MCAN is in SW initialization mode */ -// while (DL_MCAN_OPERATION_MODE_SW_INIT != DL_MCAN_getOpMode(MCAN)); - - // Reset MCAN module - //DL_MCAN_reset(MCAN); - - /* Disable the MCAN clock */ -// DL_MCAN_disableModuleClock(MCAN); -// DL_MCAN_reset(MCAN); - - //DL_GPIO_disablePower(MCAN); - - /* Clear initialization flag */ -// b_MCAN_InitFlag = 0; + /* Wait for power down to complete */ + delay_cycles(16); return IVEC_MCAL_STATUS_SUCCESS; } -//IVEC_McalStatus_e xMCAL_MCANDeInit(MCAN_Regs* MCAN) -//{ -// assert(MCAN == CANFD0); -// assert(b_MCAN_InitFlag != 0); -// -// // Disable interrupts -// NVIC_DisableIRQ(CANFD0_INT_IRQn); -// DL_MCAN_disableInterrupt(MCAN, DL_MCAN_MSP_INTERRUPT_LINE0 | DL_MCAN_MSP_INTERRUPT_LINE1); -// // DL_MCAN_clearInterruptStatus(MCAN, DL_MCAN_MSP_INTERRUPT_LINE0 | DL_MCAN_MSP_INTERRUPT_LINE1); -// -// // Transition to SW initialization mode -// DL_MCAN_setOpMode(MCAN, DL_MCAN_OPERATION_MODE_SW_INIT); -// while (DL_MCAN_OPERATION_MODE_SW_INIT != DL_MCAN_getOpMode(MCAN)); -// -// -// // Disable clock and reset -// DL_MCAN_disableModuleClock(MCAN); -// DL_MCAN_reset(MCAN); -// -// // Power down -// DL_GPIO_disablePower(MCAN); -// -// // Clear initialization flag -// b_MCAN_InitFlag = 0; -// -// return IVEC_MCAL_STATUS_SUCCESS; -//} - - /** * @brief Function to Transmit CAN message * @param MCAN Pointer to the register overlay for the peripheral @@ -638,115 +577,59 @@ IVEC_McalStatus_e xMCAL_MCANDeInit(MCAN_Regs* MCAN) * @param Bytes Number of bytes to be transmitted * @retval IVEC_McalStatus_e */ -IVEC_McalStatus_e xMCAL_MCANTx(MCAN_Regs *MCAN, uint32_t u32ID, - uint16_t *TxData, uint32_t BufNum, - uint32_t Bytes) +IVEC_McalStatus_e vMCAL_MCAN_Tx(MCAN_Regs* const pMCAN, uint32_t u32Id, + uint16_t* pu16TxData, uint32_t u32BufNum, + uint32_t u32Bytes) { -// xMCAL_MCANTx(CANFD0,0x14FFFC23, timerTxData , 0, 8); + /* Ensure that the MCAN instance is CANFD0 */ + assert(pMCAN == CANFD0); - assert(MCAN == CANFD0); - assert(b_MCAN_InitFlag != 0); - assert(Bytes <= 8); + /* Ensure that the MCAN is initialized */ + assert(bMCAL_MCAN_InitFlag != 0); - if (u32ID > 0x7FF) + /* Validate the byte size */ + assert(u32Bytes <= 8); + + /* Set the message type (standard or extended ID) */ + if (u32Id > 0x7FF) { - txMsg.xtd = 1; - txMsg.id = u32ID; + txMsg.xtd = 1; /* Extended ID */ + txMsg.id = u32Id; /* Set the extended ID */ } else { - txMsg.xtd = 0; - txMsg.id = ((uint32_t) (u32ID)) << 18U; + txMsg.xtd = 0; /* Standard ID */ + txMsg.id = ((uint32_t)(u32Id)) << 18U; /* Adjust for standard ID format */ } - for (int i = 0; i < Bytes; i++) + /* Copy the data bytes to the message */ + for (int i = 0; i < u32Bytes; i++) { - txMsg.data[i] = TxData[i]; + txMsg.data[i] = pu16TxData[i]; } - txMsg.dlc = Bytes; + txMsg.dlc = u32Bytes; /* Set the Data Length Code (DLC) */ - __asm("nop"); + __asm("nop"); /* No operation for synchronization */ - DL_MCAN_writeMsgRam(MCAN, DL_MCAN_MEM_TYPE_BUF, BufNum, &txMsg); + volatile DL_MCAN_TxFIFOStatus sMcalTxFifoStatus_x = { 0 }; // Structure variable prefixed with 's' for structure type and 'x' for typedef suffix - if(DL_MCAN_TXBufAddReq(MCAN, BufNum) == -1) + DL_MCAN_getTxFIFOQueStatus(pMCAN, &sMcalTxFifoStatus_x); // Function name prefixed with layer (MCAL) and descriptive + + if (sMcalTxFifoStatus_x.freeLvl) // Variable renamed for clarity and prefixed with 'u32' for uint32_t { - return IVEC_MCAL_STATUS_ERROR; - } + DL_MCAN_writeMsgRam(pMCAN, DL_MCAN_MEM_TYPE_FIFO, u32BufNum, &txMsg); // Function and variable name updated - l_canTransmitTimeout = i32MCAL_getTicks(); - u8_MCAN_StatusFlag = IVEC_MCAL_STATUS_BUSY; - - while (1) - { - - if (u8_MCAN_StatusFlag == IVEC_MCAL_STATUS_SUCCESS) + if (DL_MCAN_TXBufAddReq(pMCAN, sMcalTxFifoStatus_x.putIdx) == IVEC_MCAL_STATUS_ERROR) // Function return type 'x' { - return u8_MCAN_StatusFlag; + return IVEC_MCAL_STATUS_ERROR; } - else if ((i32MCAL_getTicks() - l_canTransmitTimeout) > 2) - { - return IVEC_MCAL_STATUS_TIMEOUT; - } - u8_MCAN_StatusFlag = (DL_MCAN_getTxBufTransmissionStatus(MCAN) == 0x01) ? \ - IVEC_MCAL_STATUS_SUCCESS:IVEC_MCAL_STATUS_ERROR; } - b_ServiceInt = true; + + bMCAL_ServiceInterrupt = true; return IVEC_MCAL_STATUS_SUCCESS; } -//IVEC_McalStatus_e xMCAL_MCANTx(MCAN_Regs *MCAN, uint32_t u32ID ,uint16_t *TxData, uint32_t BufNum, uint32_t Bytes) -//{ -// // xMCAL_MCANTx(CANFD0,0x14FFFC23, timerTxData , 0, 8); -// -// assert(MCAN == CANFD0); -// assert(b_MCAN_InitFlag != 0); -// assert(Bytes<=8); -// -// if (u32ID>0x7FF){ -// txMsg.xtd = 1; -// txMsg.id = u32ID; -// } -// else{ -// txMsg.xtd = 0; -// txMsg.id = ((uint32_t)(u32ID)) << 18U; -// } -// -// for(int i=0;i 2){ -// return IVEC_MCAL_STATUS_TIMEOUT; -// } -// } -// if(HeaderStat.busOffStatus==1) -// { -// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); -// } -//// if (HeaderStat.lastErrCode == 3) { -//// xECU_CanReInit(CANFD0 , BAUD_500); -//// } -// -// b_ServiceInt = true; -// return IVEC_MCAL_STATUS_SUCCESS; -//} + /** * @brief Function to Receive CAN message @@ -757,894 +640,84 @@ IVEC_McalStatus_e xMCAL_MCANTx(MCAN_Regs *MCAN, uint32_t u32ID, * @param DLC length of received data * @retval IVEC_McalStatus_e */ -IVEC_McalStatus_e xMCAL_MCANRx(MCAN_Regs *MCAN,uint32_t *ID ,uint8_t *RxData, int DLC) +IVEC_McalStatus_e vMCAL_MCAN_Rx(MCAN_Regs *pMCAN, uint32_t *pu32ID, uint8_t *pu8RxData, int iDLC) { - assert(MCAN == CANFD0); - assert(b_MCAN_InitFlag != 0); + /* Assert that the CAN module is CANFD0 and that the MCAL initialization flag is set */ + assert(pMCAN == CANFD0); + assert(bMCAL_MCAN_InitFlag != 0); - if(HeaderStat.busOffStatus==1) + /* If the bus-off status is set, change to normal operation mode */ + if (xMCAL_HeaderStat.busOffStatus == 1) { DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); } + /* Temporary RX ID */ + volatile uint32_t u32MCAL_TempRxID; -// if((((TempRxID&0xFFF)>>1)==0x16)) -// { -// xMCAL_SoftReset(); -// } + /* Store the received ID */ + *pu32ID = u32MCAL_TempRxID; - *ID=TempRxID; - - for(int i=0;i -//#include "string.h" -// -//volatile bool b_MCAN_InitFlag = 0; /*!< CAN initialization flag */ -//volatile uint8_t u8_MCAN_StatusFlag = IVEC_MCAL_STATUS_ERROR; -//volatile bool b_ServiceInt=true; -//volatile uint32_t u32InterruptLine1Status; -//volatile char u8ErrorInterruptStatus[50]; -//volatile DL_MCAN_RxFIFOStatus rxFS; -//volatile DL_MCAN_RxBufElement TempRxMsg; -//volatile uint8_t TempRxBuffer[8]; -//volatile uint32_t TempRxID; -//volatile uint32_t id; -//volatile DL_MCAN_ProtocolStatus HeaderStat; -//volatile uint32_t l_canTransmitTimeout; -//volatile uint8_t u8CallBack_buff[8]={0}; -//volatile IVEC_McalStatus_e l_statusFlag = IVEC_MCAL_STATUS_SUCCESS; -//extern volatile uint8_t u8CANDataAct; -//#define MCAN_FILTER_SIZE 0u -///*REQUIRED MCAN CONFIGS*/ -//#define MCAN_FILTER_SIZE 0u -// -// -//__attribute__((weak)) void mcu_FDCAN_RxFifo_Callback(uint32_t Identifier, uint8_t *data, uint16_t DataLength) -//{ -// -//} -// -///*=======================================================================================PRIVATE_MEMBERS======================================================================================*/ -// -//static const DL_MCAN_ClockConfig gMCAN0ClockConf = { -// .clockSel = DL_MCAN_FCLK_HFCLK,////DL_MCAN_FCLK_SYSPLLCLK1,DL_MCAN_FCLK_HFCLK, -// .divider = DL_MCAN_FCLK_DIV_1, -//}; -// -//static DL_MCAN_InitParams gMCAN0InitParams= { -// -// /* Initialize MCAN Init parameters. */ -// .fdMode = false, -// .brsEnable = false, -// .txpEnable = false, -// .efbi = false, -// .pxhddisable = false, -// .darEnable = false, -// .wkupReqEnable = false, -// .autoWkupEnable = false, -// .emulationEnable = true, -// .tdcEnable = true, -// .wdcPreload = 255, -// -// /* Transmitter Delay Compensation parameters. */ -// .tdcConfig.tdcf = 10, -// .tdcConfig.tdco = 6, -//}; -// -//static DL_MCAN_ConfigParams gMCAN0ConfigParams={ -// /* Initialize MCAN Config parameters. */ -// .monEnable = false, -// .asmEnable = false, -// .tsPrescalar = 15, -// .tsSelect = 0, -// .timeoutSelect = DL_MCAN_TIMEOUT_SELECT_CONT, -// .timeoutPreload = 65535, -// .timeoutCntEnable = false, -// .filterConfig.rrfs = false, -// .filterConfig.rrfe = false, -// .filterConfig.anfe = 0, -// .filterConfig.anfs = 0, -//// .filterConfig.anfe = 3, -//// .filterConfig.anfs = 3, -//}; -// -// -////static DL_MCAN_MsgRAMConfigParams gMCAN0MsgRAMConfigParams ={ -//// -//// /* Standard ID Filter List Start Address. */ -//// .flssa = 0 , -//// /* List Size: Standard ID. */ -//// .lss = 0 , -//// /* Extended ID Filter List Start Address. */ -//// .flesa = 0 , -//// /* List Size: Extended ID. */ -//// .lse = 0 , -//// /* Tx Buffers Start Address. */ -//// .txStartAddr = 10 , -//// /* Number of Dedicated Transmit Buffers. */ -//// .txBufNum = 10 , -//// .txFIFOSize = 10, -//// /* Tx Buffer Element Size. */ -//// .txBufMode = 0, -//// .txBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, -//// /* Tx Event FIFO Start Address. */ -//// .txEventFIFOStartAddr = 640 , -//// /* Event FIFO Size. */ -//// .txEventFIFOSize = 10 , -//// /* Level for Tx Event FIFO watermark interrupt. */ -//// .txEventFIFOWaterMark = 0, -//// /* Rx FIFO0 Start Address. */ -//// .rxFIFO0startAddr = 170 , -//// /* Number of Rx FIFO elements. */ -//// .rxFIFO0size = 10 , -//// /* Rx FIFO0 Watermark. */ -//// .rxFIFO0waterMark = 0, -//// .rxFIFO0OpMode = 0, -//// /* Rx FIFO1 Start Address. */ -//// .rxFIFO1startAddr = 190 , -//// /* Number of Rx FIFO elements. */ -//// .rxFIFO1size = 10 , -//// /* Level for Rx FIFO 1 watermark interrupt. */ -//// .rxFIFO1waterMark = 10, -//// /* FIFO blocking mode. */ -//// .rxFIFO1OpMode = 0, -//// /* Rx Buffer Start Address. */ -//// .rxBufStartAddr = 208 , -//// /* Rx Buffer Element Size. */ -//// .rxBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, -//// /* Rx FIFO0 Element Size. */ -//// .rxFIFO0ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, -//// /* Rx FIFO1 Element Size. */ -//// .rxFIFO1ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, -////}; -// -//static DL_MCAN_MsgRAMConfigParams gMCAN0MsgRAMConfigParams ={ -// -// /* Standard ID Filter List Start Address. */ -// .flssa = 1, -// /* List Size: Standard ID. */ -// .lss = MCAN_FILTER_SIZE, -// /* Extended ID Filter List Start Address. */ -// .flesa = 48 , -// /* List Size: Extended ID. */ -// .lse = 0, -// /* Tx Buffers Start Address. */ -// .txStartAddr = 10 , -// /* Number of Dedicated Transmit Buffers. */ -// .txBufNum = 10 , -// .txFIFOSize = 10, -// /* Tx Buffer Element Size. */ -// .txBufMode = 0, -// .txBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, -// /* Tx Event FIFO Start Address. */ -// .txEventFIFOStartAddr = 640 , -// /* Event FIFO Size. */ -// .txEventFIFOSize = 10 , -// /* Level for Tx Event FIFO watermark interrupt. */ -// .txEventFIFOWaterMark = 0, -// /* Rx FIFO0 Start Address. */ -// .rxFIFO0startAddr = 170 , -// /* Number of Rx FIFO elements. */ -// .rxFIFO0size = 10 , -// /* Rx FIFO0 Watermark. */ -// .rxFIFO0waterMark = 0, -// .rxFIFO0OpMode = 0, -// /* Rx FIFO1 Start Address. */ -// .rxFIFO1startAddr = 190 , -// /* Number of Rx FIFO elements. */ -// .rxFIFO1size = 10 , -// /* Level for Rx FIFO 1 watermark interrupt. */ -// .rxFIFO1waterMark = 10, -// /* FIFO blocking mode. */ -// .rxFIFO1OpMode = 0, -// /* Rx Buffer Start Address. */ -// .rxBufStartAddr = 208 , -// /* Rx Buffer Element Size. */ -// .rxBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, -// /* Rx FIFO0 Element Size. */ -// .rxFIFO0ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, -// /* Rx FIFO1 Element Size. */ -// .rxFIFO1ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, -//}; -// -// -//static DL_MCAN_BitTimingParams gMCAN0BitTimes_500 = { -// /* Arbitration Baud Rate Pre-scaler. */ -// .nomRatePrescalar = 0, -// /* Arbitration Time segment before sample point. */ -// .nomTimeSeg1 = 41, -// /* Arbitration Time segment after sample point. */ -// .nomTimeSeg2 = 4, -// /* Arbitration (Re)Synchronization Jump Width Range. */ -// .nomSynchJumpWidth = 4, -// /* Data Baud Rate Pre-scaler. */ -// .dataRatePrescalar = 0, -// /* Data Time segment before sample point. */ -// .dataTimeSeg1 = 0, -// /* Data Time segment after sample point. */ -// .dataTimeSeg2 = 0, -// /* Data (Re)Synchronization Jump Width. */ -// .dataSynchJumpWidth = 0, -//}; -// -//static DL_MCAN_BitTimingParams gMCAN0BitTimes_250 = { -// /* Arbitration Baud Rate Pre-scaler. */ -// .nomRatePrescalar = 0, -// /* Arbitration Time segment before sample point. */ -// .nomTimeSeg1 = 138, -// /* Arbitration Time segment after sample point. */ -// .nomTimeSeg2 = 19, -// /* Arbitration (Re)Synchronization Jump Width Range. */ -// .nomSynchJumpWidth = 19, -// /* Data Baud Rate Pre-scaler. */ -// .dataRatePrescalar = 0, -// /* Data Time segment before sample point. */ -// .dataTimeSeg1 = 0, -// /* Data Time segment after sample point. */ -// .dataTimeSeg2 = 0, -// /* Data (Re)Synchronization Jump Width. */ -// .dataSynchJumpWidth = 0, -//}; -// -// -//static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem1 = { -// .sfec = 001, -// .sft = 0x00, -// .sfid1 = 0, -// .sfid2 = 1280, -//}; -// -////static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem1 = { -//// .sfec = 001, -//// .sft = 10, -//// .sfid1 = 0x3ff, -//// .sfid2 = 0x400, -////}; // apply mask pass only 200 and 201 id -// -//static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem2 = { -// .sfec = 0x1, -// .sft = 0x00, -// .sfid1 = 1536, -// .sfid2 = 2046, -//}; -// -//static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem3 = { -// .sfec = 0x1, -// .sft = 0x00, -// .sfid1 = 0x1A4, -// .sfid2 = 0x1A4, -//}; -// -//static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem4 = { -// .sfec = 0x1, -// .sft = 0x00, -// .sfid1 = 0x521, -// .sfid2 = 0x521, -//}; -// -//static const DL_MCAN_StdMsgIDFilterElement gMCAN0StdFiltelem5 = { -// .sfec = 0x1, -// .sft = 0x00, -// .sfid1 = 0x16, -// .sfid2 = 0x16, -//}; -// -//static const DL_MCAN_ExtMsgIDFilterElement gMCAN0ExtFiltelem1 = { -// .efec = 0x1, -// .eft = 0x0, -// .efid1 = 2047, -// .efid2 = 536870911, -//}; -// -// -//static const DL_MCAN_ExtMsgIDFilterElement gMCAN0ExtFiltelem2 = { -// .efec = 0x1, -// .eft = 0x0, -// .efid1 = 2047, -// .efid2 = 536870911, -//}; -// -//static const DL_MCAN_ExtMsgIDFilterElement gMCAN0ExtFiltelem3 = { -// .efec = 0x1, -// .eft = 0x0, -// .efid1 = 0x1CEBFF23, -// .efid2 = 0x1CEBFF23, -//}; -// -//volatile DL_MCAN_TxBufElement txMsg = { -// .id = ((uint32_t)(0x00)) << 18U, -// .rtr = 0U, -// .xtd = 0U, -// .esi = 0U, -// .dlc = 8U, -// .brs = 0U, -// .fdf = 0U, -// .efc = 1U, -// .mm = 0xAAU, -// .data = {0}, -//}; -// -// -// -///*____________________________________________________________________________________________________________________________________________________________________________________________*/ -// -// -///*============================================================================================================================================================================================= -// PRIVATE_DECLARATIONS -//==============================================================================================================================================================================================*/ -// -///** -// * @brief Static Function to store RX data in a static buffer -// * @retval void -// */ -//static void _prv_vGetRxMsg(DL_MCAN_RxBufElement *rxMsg,uint32_t *ID,uint8_t *RxData,int DLC) -//{ -// -// for (int i =0 ; i < DLC ; i++) -// -// { -// RxData[i] = (rxMsg->data[i] & 0xFF); -// } -//} -// -// -//void __prv_CANInterruptProcess(uint32_t u32InterruptStatus) -//{ -// uint32_t IntrStatus = u32InterruptStatus; -// DL_MCAN_getProtocolStatus(CANFD0, &HeaderStat); -// -// if (IntrStatus & DL_MCAN_INTERRUPT_TC){ -// b_ServiceInt = true; -// u8_MCAN_StatusFlag = IVEC_MCAL_STATUS_SUCCESS; -// } -// -// if( IntrStatus & DL_MCAN_INTERRUPT_BO) -// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); -// -// if(IntrStatus & (DL_MCAN_INTERRUPT_RF0N | DL_MCAN_INTERRUPT_RF1N)){ -// -// while (false == b_ServiceInt); -// -// b_ServiceInt = false; -// rxFS.fillLvl = 0; -// rxFS.num = (IntrStatus & DL_MCAN_INTERRUPT_RF0N) ? DL_MCAN_RX_FIFO_NUM_0 : DL_MCAN_RX_FIFO_NUM_1; -// -// while ((rxFS.fillLvl) == 0) -// { -// DL_MCAN_getRxFIFOStatus(CANFD0, &rxFS); -// } -// -// DL_MCAN_readMsgRam(CANFD0, DL_MCAN_MEM_TYPE_FIFO, 0, rxFS.num, &TempRxMsg); -// DL_MCAN_writeRxFIFOAck(CANFD0, rxFS.num, rxFS.getIdx); -// -// b_ServiceInt = true; -// if(HeaderStat.busOffStatus==1) -// { -// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); -// } -// if( !TempRxMsg.xtd ) -// TempRxMsg.id = (uint32_t)(TempRxMsg.id >> 18); -// uint8_t l_pu8DataArr[8] = {0}; -// for( int ijk = 0; ijk < 8; ijk++ ) -// l_pu8DataArr[ijk] = TempRxMsg.data[ijk] & 0xFF; -// -// mcu_FDCAN_RxFifo_Callback(TempRxMsg.id, &l_pu8DataArr[0], TempRxMsg.dlc); -// } -//} -// -///** -// * @brief Default Interrupt Handler for MCAN -// * -// */ -//void CANFD0_IRQHandler(void) -//{ -// switch (DL_MCAN_getPendingInterrupt(CANFD0)) { -// case DL_MCAN_IIDX_LINE1: -// { -// uint32_t IntrStatus = DL_MCAN_getIntrStatus(CANFD0); -// __prv_CANInterruptProcess(IntrStatus); -// DL_MCAN_clearIntrStatus(MCAN0_INST, IntrStatus, -// DL_MCAN_INTR_SRC_MCAN_LINE_1); -// } -// break; -// case DL_MCAN_IIDX_LINE0: -// { -// uint32_t IntrStatus = DL_MCAN_getIntrStatus(CANFD0); -// __prv_CANInterruptProcess(IntrStatus); -// DL_MCAN_clearIntrStatus(MCAN0_INST, IntrStatus, -// DL_MCAN_INTR_SRC_MCAN_LINE_0); -// break; -// } -// default: -// break; -// } -//} -// -///*============================================================================================================================================================================================= -// API -//==============================================================================================================================================================================================*/ -// -///** -// * @brief Function to initialize MCAN Peripheral -// * @note Interrupts are enabled in this function itself -// * @param MCAN Pointer to the register overlay for the peripheral -// * @param BAUD Param to set Baud rate of MCAN -// * @retval IVEC_McalStatus_e -// */ -//IVEC_McalStatus_e xMCAL_MCANInit(MCAN_Regs* MCAN, xCAN_baud_t BAUD) -//{ -// assert(MCAN == CANFD0); -// assert(BAUD == BAUD_500 || BAUD == BAUD_250); -// assert(b_MCAN_InitFlag == 0); -// -// DL_MCAN_RevisionId revid_MCAN0; -// -// DL_MCAN_enableModuleClock(MCAN); -// -// DL_MCAN_setClockConfig(MCAN, (DL_MCAN_ClockConfig *) &gMCAN0ClockConf); -// -// /* Get MCANSS Revision ID. */ -// DL_MCAN_getRevisionId(MCAN, &revid_MCAN0); -// -// /* Wait for Memory initialization to be completed. */ -// while(false == DL_MCAN_isMemInitDone(MCAN)); -// -// /* Put MCAN in SW initialization mode. */ -// -// DL_MCAN_setOpMode(MCAN, DL_MCAN_OPERATION_MODE_SW_INIT); -// -// /* Wait till MCAN is not initialized. */ -// while (DL_MCAN_OPERATION_MODE_SW_INIT != DL_MCAN_getOpMode(MCAN)); -// -// /* Initialize MCAN module. */ -// DL_MCAN_init(MCAN, (DL_MCAN_InitParams *) &gMCAN0InitParams); -// -// /* Configure MCAN module. */ -// DL_MCAN_config(MCAN, (DL_MCAN_ConfigParams*) &gMCAN0ConfigParams); -// -// /* Configure Bit timings. */ -// if(BAUD==BAUD_500) -// { -// -// DL_MCAN_setBitTime(MCAN, (DL_MCAN_BitTimingParams*) &gMCAN0BitTimes_500); -// } -// else if(BAUD==BAUD_250) -// { -// DL_MCAN_setBitTime(MCAN, (DL_MCAN_BitTimingParams*) &gMCAN0BitTimes_250); -// } -// else -// { -// DL_MCAN_setBitTime(MCAN, (DL_MCAN_BitTimingParams*) &gMCAN0BitTimes_500); -// } -// -// /* Configure Message RAM Sections */ -// DL_MCAN_msgRAMConfig(MCAN, (DL_MCAN_MsgRAMConfigParams*) &gMCAN0MsgRAMConfigParams); -// -// /* Configure Standard ID filter element */ -// //DL_MCAN_addStdMsgIDFilter(MCAN, 0U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem1); -//// -// ///DL_MCAN_addStdMsgIDFilter(MCAN, 1U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem2); -//// -//// DL_MCAN_addStdMsgIDFilter(MCAN, 2U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem3); -//// -//// DL_MCAN_addStdMsgIDFilter(MCAN, 3U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem4); -//// -//// DL_MCAN_addStdMsgIDFilter(MCAN, 4U, (DL_MCAN_StdMsgIDFilterElement *) &gMCAN0StdFiltelem5); -//// -// //DL_MCAN_addExtMsgIDFilter(MCAN, 0U,(DL_MCAN_ExtMsgIDFilterElement *)&gMCAN0ExtFiltelem1); -//// -// // DL_MCAN_addExtMsgIDFilter(MCAN, 1U,(DL_MCAN_ExtMsgIDFilterElement *)&gMCAN0ExtFiltelem2); -//// -//// DL_MCAN_addExtMsgIDFilter(MCAN, 2U,(DL_MCAN_ExtMsgIDFilterElement *)&gMCAN0ExtFiltelem3); -// -// -// /* Set Extended ID Mask. */ -// DL_MCAN_setExtIDAndMask(MCAN, (0x1FFFFFFFU)); -// -// /* Take MCAN out of the SW initialization mode */ -// DL_MCAN_setOpMode(MCAN, DL_MCAN_OPERATION_MODE_NORMAL); -// -// while (DL_MCAN_OPERATION_MODE_NORMAL != DL_MCAN_getOpMode(MCAN)); -// -// /* Enable MCAN mopdule Interrupts */ -// DL_MCAN_enableIntr(MCAN, (DL_MCAN_INTERRUPT_BEU | \ -// DL_MCAN_INTERRUPT_BO | \ -// DL_MCAN_INTERRUPT_ELO | \ -// DL_MCAN_INTERRUPT_EP | \ -// DL_MCAN_INTERRUPT_EW | \ -// DL_MCAN_INTERRUPT_PEA | \ -// DL_MCAN_INTERRUPT_PED | \ -// DL_MCAN_INTERRUPT_RF0N | \ -// DL_MCAN_INTERRUPT_RF1N | \ -// DL_MCAN_INTERRUPT_TC | \ -// DL_MCAN_INTERRUPT_TOO), 1U); -// -// DL_MCAN_selectIntrLine(MCAN, (DL_MCAN_INTERRUPT_BEU | \ -// DL_MCAN_INTERRUPT_BO | \ -// DL_MCAN_INTERRUPT_ELO | \ -// DL_MCAN_INTERRUPT_EP | \ -// DL_MCAN_INTERRUPT_EW | \ -// DL_MCAN_INTERRUPT_PEA | \ -// DL_MCAN_INTERRUPT_PED | \ -// DL_MCAN_INTERRUPT_RF0N | \ -// DL_MCAN_INTERRUPT_RF1N | \ -// DL_MCAN_INTERRUPT_TC | \ -// DL_MCAN_INTERRUPT_TOO), DL_MCAN_INTR_LINE_NUM_1); -// DL_MCAN_enableIntrLine(MCAN, DL_MCAN_INTR_LINE_NUM_1, 1U); -// -// DL_MCAN_selectIntrLine(MCAN, (DL_MCAN_INTERRUPT_BEU | \ -// DL_MCAN_INTERRUPT_BO | \ -// DL_MCAN_INTERRUPT_ELO | \ -// DL_MCAN_INTERRUPT_EP | \ -// DL_MCAN_INTERRUPT_EW | \ -// DL_MCAN_INTERRUPT_PEA | \ -// DL_MCAN_INTERRUPT_PED | \ -// DL_MCAN_INTERRUPT_RF0N | \ -// DL_MCAN_INTERRUPT_RF1N | \ -// DL_MCAN_INTERRUPT_TC | \ -// DL_MCAN_INTERRUPT_TOO), DL_MCAN_INTR_LINE_NUM_0); -// DL_MCAN_enableIntrLine(MCAN, DL_MCAN_INTR_LINE_NUM_0, 1U); -// -// /* Enable MSPM0 MCAN interrupt */ -// DL_MCAN_clearInterruptStatus(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE0)); -// DL_MCAN_enableInterrupt(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE0)); -// -// DL_MCAN_clearInterruptStatus(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE1)); -// DL_MCAN_enableInterrupt(MCAN,(DL_MCAN_MSP_INTERRUPT_LINE1)); -// NVIC_SetPriority(CANFD0_INT_IRQn, 1); -// NVIC_EnableIRQ(CANFD0_INT_IRQn); -// b_MCAN_InitFlag = 1; -// -// return IVEC_MCAL_STATUS_SUCCESS; -// -//} -// -// -///** -// * @brief Function to De-Initialize MCAN peripheral -// * @param MCAN Pointer to the register overlay for the peripheral -// * @retval IVEC MCAL status -// */ -////IVEC_McalStatus_e xMCAL_MCANDeInit(MCAN_Regs* MCAN) -////{ -//// assert(MCAN == CANFD0); -//// assert(b_MCAN_InitFlag != 0); -//// -//// NVIC_DisableIRQ(CANFD0_INT_IRQn); -//// DL_MCAN_disablePower(MCAN); -//// b_MCAN_InitFlag = 0; -//// -//// return IVEC_MCAL_STATUS_SUCCESS; -//// -////} -//IVEC_McalStatus_e xMCAL_MCANDeInit(MCAN_Regs* MCAN) -//{ -// assert(MCAN == CANFD0); -// assert(b_MCAN_InitFlag != 0); // Ensure the module was initialized before deinitializing. -// -// /* Disable MSPM0 MCAN interrupt */ -// NVIC_DisableIRQ(CANFD0_INT_IRQn); -// DL_MCAN_disableInterrupt(MCAN, DL_MCAN_MSP_INTERRUPT_LINE1); -// -// DL_MCAN_setOpMode(MCAN, DL_MCAN_OPERATION_MODE_SW_INIT); -// -// /* Wait till MCAN is in SW initialization mode */ -// while (DL_MCAN_OPERATION_MODE_SW_INIT != DL_MCAN_getOpMode(MCAN)); -// -// /* Disable the MCAN clock */ -// DL_MCAN_disableModuleClock(MCAN); -// -// /* Clear initialization flag */ -// b_MCAN_InitFlag = 0; -// -// return IVEC_MCAL_STATUS_SUCCESS; -//} -// -///** -// * @brief Function to Transmit CAN message -// * @param MCAN Pointer to the register overlay for the peripheral -// * @param ID Message ID for TxMsg Object. -// * @param TxData Array of Data to be transmitted -// * @param BufNum Tx Buffer Number -// * @param Bytes Number of bytes to be transmitted -// * @retval IVEC_McalStatus_e -// */ -//IVEC_McalStatus_e xMCAL_MCANTx(MCAN_Regs *MCAN, uint32_t u32ID ,uint16_t *TxData, uint32_t BufNum, uint32_t Bytes) -//{ -// // xMCAL_MCANTx(CANFD0,0x14FFFC23, timerTxData , 0, 8); -// -// assert(MCAN == CANFD0); -// assert(b_MCAN_InitFlag != 0); -// assert(Bytes<=8); -// -// if (u32ID>0x7FF){ -// txMsg.xtd = 1; -// txMsg.id = u32ID; -// } -// else{ -// txMsg.xtd = 0; -// txMsg.id = ((uint32_t)(u32ID)) << 18U; -// } -// -// for(int i=0;i 2){ -// return IVEC_MCAL_STATUS_TIMEOUT; -// } -// } -// if(HeaderStat.busOffStatus==1) -// { -// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); -// } -// -// -// b_ServiceInt = true; -// return IVEC_MCAL_STATUS_SUCCESS; -//} -// -///** -// * @brief Function to Receive CAN message -// * @param MCAN Pointer to the register overlay for the peripheral -// * @param RxMsg Message Object. -// * @param FifoNum Fifo Number to be used -// * @param RxData Array where received data is to be stored -// * @param DLC length of received data -// * @retval IVEC_McalStatus_e -// */ -//IVEC_McalStatus_e xMCAL_MCANRx(MCAN_Regs *MCAN,uint32_t *ID ,uint8_t *RxData, int DLC) -//{ -// assert(MCAN == CANFD0); -// assert(b_MCAN_InitFlag != 0); -// -// if(HeaderStat.busOffStatus==1) -// { -// DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); -// } -// -//// if((((TempRxID&0xFFF)>>1)==0x16)) -//// { -//// xMCAL_SoftReset(); -//// } -// -// *ID=TempRxID; -// -// for(int i=0;ipvUartRecvCallback != NULL) - g_pxUartHandles[i]->pvUartRecvCallback(GetUartPort(uart), IVEC_MCAL_UART_EVENT_RX_ARRIVED, (char*)buf, 1); + if (gpxMcalUartHandles[i]->pvUartRecvCallback != NULL) + { + gpxMcalUartHandles[i]->pvUartRecvCallback(_prvMCAL_GetUartPort(pxUartInstance),eIvecMcalUartEventRxArrived,(char*)pu8Buffer,1); + } break; } } } } -void _prv_vrxcallback(UART_Regs* pxUartInstance, uint32_t event) +void prv_vRxCallback(UART_Regs* pxUartInstance, uint32_t u32Event) { - switch (event) + switch (u32Event) { - case DL_UART_MAIN_IIDX_RX: - { - uint8_t l_pu8Buffer[64] = { 0 }; // Adjust size as needed - uint32_t bytesRead; + case DL_UART_MAIN_IIDX_RX: + { + uint8_t u8RxBuffer[64] = { 0 }; // Adjust size as needed + uint32_t u32BytesRead = 0; - // Drain the RX FIFO and store the data in buffer - bytesRead = DL_UART_drainRXFIFO(pxUartInstance, l_pu8Buffer, sizeof(l_pu8Buffer)); - DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_RX); - for (int ijk = 0; ijk < bytesRead; ijk++) - UART_ReadCallback(pxUartInstance, &l_pu8Buffer[ijk], true); - break; - } - case DL_UART_MAIN_IIDX_OVERRUN_ERROR: - DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_OVERRUN_ERROR); - __asm("nop"); - break; - case DL_UART_MAIN_IIDX_BREAK_ERROR: - DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_BREAK_ERROR); - __asm("nop"); - break; - case DL_UART_MAIN_IIDX_PARITY_ERROR: - DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_PARITY_ERROR); - __asm("nop"); - break; - case DL_UART_MAIN_IIDX_FRAMING_ERROR: - DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_FRAMING_ERROR); - __asm("nop"); - break; - case DL_UART_MAIN_IIDX_RX_TIMEOUT_ERROR: - DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_RX_TIMEOUT_ERROR); - __asm("nop"); - break; - case DL_UART_MAIN_IIDX_NOISE_ERROR: - DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_NOISE_ERROR); - __asm("nop"); - break; - default: - break; + // Drain the RX FIFO and store the data in buffer + u32BytesRead = DL_UART_drainRXFIFO(pxUartInstance, u8RxBuffer, sizeof(u8RxBuffer)); + + // Clear the RX interrupt flag + DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_RX); + + // Process each byte of received data + for (uint32_t u32Index = 0; u32Index < u32BytesRead; u32Index++) + { + vMCAL_UartReadCallback(pxUartInstance, &u8RxBuffer[u32Index], true); + } + break; + } + case DL_UART_MAIN_IIDX_OVERRUN_ERROR: + DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_OVERRUN_ERROR); + __asm("nop"); + break; + case DL_UART_MAIN_IIDX_BREAK_ERROR: + DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_BREAK_ERROR); + __asm("nop"); + break; + case DL_UART_MAIN_IIDX_PARITY_ERROR: + DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_PARITY_ERROR); + __asm("nop"); + break; + case DL_UART_MAIN_IIDX_FRAMING_ERROR: + DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_FRAMING_ERROR); + __asm("nop"); + break; + case DL_UART_MAIN_IIDX_RX_TIMEOUT_ERROR: + DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_RX_TIMEOUT_ERROR); + __asm("nop"); + break; + case DL_UART_MAIN_IIDX_NOISE_ERROR: + DL_UART_clearInterruptStatus(pxUartInstance, DL_UART_MAIN_IIDX_NOISE_ERROR); + __asm("nop"); + break; + default: + break; } } - void UART0_IRQHandler() { - _prv_vrxcallback(UART0, DL_UART_Main_getPendingInterrupt(UART0)); + prv_vRxCallback(UART0, DL_UART_Main_getPendingInterrupt(UART0)); } void UART1_IRQHandler() { - _prv_vrxcallback(UART1, DL_UART_Main_getPendingInterrupt(UART1)); + prv_vRxCallback(UART1, DL_UART_Main_getPendingInterrupt(UART1)); } void UART2_IRQHandler() { - _prv_vrxcallback(UART2, DL_UART_Main_getPendingInterrupt(UART2)); + prv_vRxCallback(UART2, DL_UART_Main_getPendingInterrupt(UART2)); } - -// Get the UART instance based on the enum -static UART_Regs* GetUartInstance(McalUartPortNumber_e eUartPortNumber) +/** + * @brief Get the UART instance based on the enum. + * + * @param eUartPortNumber UART port number enumeration. + * @return UART_Regs* Pointer to the UART registers. + */ +static UART_Regs* _prvMCAL_GetUartInstance(eMcalUartPortNumber eUartPortNumber) { switch (eUartPortNumber) { - case mcalUART_PORT1: - return UART0; - case mcalUART_PORT2: - return UART1; - case mcalUART_PORT3: - return UART2; - default: - return NULL; // Invalid UART port + case eMcalUartPort1: + return UART0; + case eMcalUartPort2: + return UART1; + case eMcalUartPort3: + return UART2; + default: + return NULL; // Invalid UART port } } -static McalUartPortNumber_e GetUartPort(UART_Regs* pxUartInstance) + +/** + * @brief Get the UART port based on the instance. + * + * @param pxUartInstance Pointer to the UART registers. + * @return eMcalUartPortNumber UART port number enumeration. + */ +static eMcalUartPortNumber _prvMCAL_GetUartPort(UART_Regs* pxUartInstance) { switch ((uint32_t)pxUartInstance) { case (uint32_t)UART0: - return mcalUART_PORT1; + return eMcalUartPort1; case (uint32_t)UART1: - return mcalUART_PORT2; + return eMcalUartPort2; case (uint32_t)UART2: - return mcalUART_PORT3; + return eMcalUartPort3; default: - return mcalUART_PORT_MAX; // Invalid UART port + return eMcalUartPortMax; // Invalid UART port } } -static xCoreStatus_t uart_deinit(McalUartHandle_s* pxUartHandle) +/** + * @brief Private function to deinitialize UART instance. + * + * @param pxUartHandle Pointer to \link xMcalUartHandle \endlink. + * @return IVEC_CoreStatus_e Status of the UART deinitialization. + */ +static IVEC_CoreStatus_e _prvMCAL_UartDeInitInstance(xMcalUartHandle* pxUartHandle) { // Get the UART instance based on the port number in the handle - UART_Regs* uart_inst = GetUartInstance(pxUartHandle->eUartPortNumber); + UART_Regs* pxUARTInstance = _prvMCAL_GetUartInstance(pxUartHandle->eUartPortNumber); // Check if the UART instance is valid - if (uart_inst == NULL) + if (pxUARTInstance == NULL) { - return STATUS_ERROR; + return IVEC_CORE_STATUS_ERROR; } // Disable UART instance - DL_UART_Main_disable(uart_inst); + DL_UART_Main_disable(pxUARTInstance); // Disable interrupts for the UART instance - DL_UART_Main_disableInterrupt(uart_inst, + DL_UART_Main_disableInterrupt(pxUARTInstance, DL_UART_MAIN_INTERRUPT_BREAK_ERROR | DL_UART_MAIN_INTERRUPT_FRAMING_ERROR | DL_UART_MAIN_INTERRUPT_NOISE_ERROR | @@ -147,19 +179,19 @@ static xCoreStatus_t uart_deinit(McalUartHandle_s* pxUartHandle) DL_UART_MAIN_INTERRUPT_RX_TIMEOUT_ERROR); // Clear and disable NVIC interrupt requests based on UART instance - if (uart_inst == UART0) + if (pxUARTInstance == UART0) { NVIC_DisableIRQ(UART0_INT_IRQn); NVIC_ClearPendingIRQ(UART0_INT_IRQn); // Reset the UART0 init flag if needed (b_UART0_init_flag = 0) } - else if (uart_inst == UART1) + else if (pxUARTInstance == UART1) { NVIC_DisableIRQ(UART1_INT_IRQn); NVIC_ClearPendingIRQ(UART1_INT_IRQn); // Reset the UART1 init flag if needed (b_UART1_init_flag = 0) } - else if (uart_inst == UART2) + else if (pxUARTInstance == UART2) { NVIC_DisableIRQ(UART2_INT_IRQn); NVIC_ClearPendingIRQ(UART2_INT_IRQn); @@ -167,318 +199,347 @@ static xCoreStatus_t uart_deinit(McalUartHandle_s* pxUartHandle) } // Optionally, reset the UART clock configuration if needed - DL_UART_Main_setClockConfig(uart_inst, NULL); + DL_UART_Main_setClockConfig(pxUARTInstance, NULL); - return STATUS_SUCCESS; + return IVEC_CORE_STATUS_SUCCESS; } /** - * @brief Function to De-init UART Peripheral. - * @warning Donot call if UART is not initilized earlier. - * @param pxUartHandle pointer to \link McalUartHandle_s \endlink - * @return \link IVEC_McalCommonErr_e \endlink returns a status based on the success or failure of the UART De-Init operation. + * @brief Function to deinitialize the UART peripheral. + * + * @param pxUartHandle Pointer to \link xMcalUartHandle \endlink. + * @return IVEC_McalCommonErr_e Returns a status based on the success or failure of the UART deinitialization operation. */ -IVEC_McalCommonErr_e xMCAL_UartDeInit(McalUartHandle_s* pxUartHandle) +IVEC_McalCommonErr_e xMCAL_UartDeInit(xMcalUartHandle* pxUartHandle) { - int l_i32Ret; + IVEC_CoreStatus_e xRetStatus; IVEC_MCAL_FUNC_ENTRY(LOG_STRING); - IVEC_McalCommonErr_e l_xFuncStatus = commonMCAL_SUCCESS; + IVEC_McalCommonErr_e eFuncStatus = commonMCAL_SUCCESS; + + // Check for null pointer if (pxUartHandle == NULL) { - l_xFuncStatus = commonMCAL_INVALID_PARAM; + eFuncStatus = commonMCAL_INVALID_PARAM; goto exit; } - l_i32Ret = uart_deinit(pxUartHandle); - IVEC_MCAL_LOG(LOG_STRING, "DeInitilising UART status %d", l_i32Ret); - if (l_i32Ret != STATUS_SUCCESS) + + // Call the private deinit function + xRetStatus = _prvMCAL_UartDeInitInstance(pxUartHandle); + IVEC_MCAL_LOG(LOG_STRING, "Deinitializing UART status: %d", xRetStatus); + + // Check the return status + if (xRetStatus != IVEC_CORE_STATUS_SUCCESS) { - l_xFuncStatus = commonMCAL_DEINIT_FAIL; + eFuncStatus = commonMCAL_DEINIT_FAIL; goto exit; } + exit: IVEC_MCAL_FUNC_EXIT(LOG_STRING); - return l_xFuncStatus; + return eFuncStatus; } + /////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// - - -static xCoreStatus_t uart_read(McalUartHandle_s* pxUartHandle, unsigned char* pucData) +/** + * @brief Internal function to read a single byte from UART. + * @param [in] pxUartHandle Pointer to \link McalUartHandle_t \endlink. + * @param [out] pucData Pointer to store the received byte. + * @return \link CoreStatus_t \endlink Returns CORE_STATUS_SUCCESS on success or CORE_STATUS_ERROR on failure. + */ +static IVEC_McalCommonErr_e prvIvecMcalUart_ReadByte(xMcalUartHandle* pxUartHandle, uint8_t* pucData) { - // Get the UART instance based on the port number in the handle - UART_Regs* uart_inst = GetUartInstance(pxUartHandle->eUartPortNumber); + /* Get the UART instance based on the port number in the handle */ + UART_Regs* pUartInstance = _prvMCAL_GetUartInstance(pxUartHandle->eUartPortNumber); - // Check if the UART instance is valid - if (uart_inst == NULL) + /* Check if the UART instance is valid */ + if (pUartInstance == NULL) { - return STATUS_ERROR; + return commonMCAL_FAIL; } - bool status = false; - uint32_t l_u32Tick = i32MCAL_getTicks(); - while (!DL_UART_Main_isRXFIFOEmpty(uart_inst) && ((i32MCAL_getTicks() - l_u32Tick) < 50)) { - *pucData = DL_UART_Main_receiveData(uart_inst); - status = true; - } + bool bDataReceived = false; + uint32_t u32StartTick = i32MCAL_GetTicks(); - //*pucData = DL_UART_receiveData(uart_inst); - - if (status == false) + /* Wait until data is received or timeout occurs */ + while (!DL_UART_isTXFIFOEmpty(pUartInstance) && + ((i32MCAL_GetTicks() - u32StartTick) < 50)) { - return STATUS_ERROR; + *pucData = DL_UART_Main_receiveData(pUartInstance); + bDataReceived = true; } - return STATUS_SUCCESS; + /* Return error if no data was received */ + if (!bDataReceived) + { + return commonMCAL_FAIL; + } + + return commonMCAL_SUCCESS; } /** - * @brief Function to Read data at from UART Port - * @pre UART should be initilized first. - * @param [in] pxUartHandle pointer to \link McalUartHandle_s \endlink - * @param [in] pucData pointer to unsigned char. Used to read data from UART. + * @brief Reads data from the UART port. + * @pre UART should be initialized before calling this function. + * @param [in] pxUartHandle Pointer to \link McalUartHandle_t \endlink. + * @param [out] pucData Pointer to buffer for storing received data. * @param [in] u32DataLength Length of the data to read. - * @return \link IVEC_McalCommonErr_e \endlink returns a status based on the success or failure of the UART Read operation. + * @return \link IvecMcalCommonErr_t \endlink Returns the status of the UART read operation. */ -IVEC_McalCommonErr_e xMCAL_UartRead(McalUartHandle_s* pxUartHandle, unsigned char* pucData, unsigned int u32DataLength) +IVEC_McalCommonErr_e xIvecMcalUart_Read(xMcalUartHandle* pxUartHandle, uint8_t* pucData, uint32_t u32DataLength) { - int l_i32Ret; + int32_t i32RetVal; + IVEC_McalCommonErr_e eFuncStatus = commonMCAL_SUCCESS; + IVEC_MCAL_FUNC_ENTRY(LOG_STRING); - IVEC_McalCommonErr_e l_xFuncStatus = commonMCAL_SUCCESS; + + /* Validate the UART handle */ if (pxUartHandle == NULL) { - l_xFuncStatus = commonMCAL_INVALID_PARAM; + eFuncStatus = commonMCAL_INVALID_PARAM; goto exit; } - l_i32Ret = uart_read(pxUartHandle, pucData); - IVEC_MCAL_LOG(LOG_STRING, "Reading UART status %d", l_i32Ret); - if (l_i32Ret == STATUS_ERROR) + + /* Attempt to read a single byte from UART */ + i32RetVal = prvIvecMcalUart_ReadByte(pxUartHandle, pucData); + + /* Log the read operation status */ + IVEC_MCAL_LOG(LOG_STRING, "UART read status: %d", i32RetVal); + + /* Check if the read operation failed */ + if (i32RetVal == commonMCAL_SUCCESS) { - l_xFuncStatus = commonMCAL_READ_FAIL; + eFuncStatus = commonMCAL_FAIL; goto exit; } + exit: IVEC_MCAL_FUNC_EXIT(LOG_STRING); - return l_xFuncStatus; + return eFuncStatus; } + + /////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////// -static xCoreStatus_t uart_transmit(McalUartHandle_s* pxUartHandle, uint8_t* u8txdata, uint32_t u32size) -{ - // Get the UART instance based on the port number in the handle - UART_Regs* uart_inst = GetUartInstance(pxUartHandle->eUartPortNumber); - // Check if the UART instance is valid - if (uart_inst == NULL || u32size == 0) - { - return STATUS_ERROR; - } - - uint32_t l_u32Tick = i32MCAL_getTicks(); - for (int j = 0; j < u32size; j++) - { - DL_UART_transmitData(uart_inst, u8txdata[j]); - while (DL_UART_isTXFIFOFull(uart_inst) && ((i32MCAL_getTicks() - l_u32Tick) < 100)); - } - - return STATUS_SUCCESS; - -} /** - * @brief Function to Write data at UART Port - * @pre UART should be initilized first. - * @param [in] pxUartHandle pointer to \link McalUartHandle_s \endlink - * @param [in] pucData pointer to unsigned char. Used to send data to UART. - * @param [in] u32DataLength Length of the Data that need to be write. - * @return \link IVEC_McalCommonErr_e \endlink returns a status based on the success or failure of the UART Write operation. + * @brief Static function to transmit data over UART. + * @param [in] pxUartHandle Pointer to UART handle structure. + * @param [in] pu8TxData Pointer to the data buffer to transmit. + * @param [in] u32Size Number of bytes to transmit. + * @return xCoreStatus_t Status of the transmission (STATUS_SUCCESS or STATUS_ERROR). */ -IVEC_McalCommonErr_e xMCAL_UartWrite(McalUartHandle_s* pxUartHandle, unsigned char* pucData, unsigned int u32DataLength) +static IVEC_CoreStatus_e _prvMCAL_UartTransmit(xMcalUartHandle* pxUartHandle, uint8_t* pu8TxData, uint32_t u32Size) { - int l_i32Ret; + /* Retrieve UART instance based on the port number */ + UART_Regs* pxUartInstance = _prvMCAL_GetUartInstance(pxUartHandle->eUartPortNumber); + + /* Validate the UART instance and data size */ + if (pxUartInstance == NULL || u32Size == 0) + { + return IVEC_CORE_STATUS_ERROR; + } + + /* Track transmission timeout */ + uint32_t u32TickStart = i32MCAL_GetTicks(); + for (uint32_t u32Index = 0; u32Index < u32Size; u32Index++) + { + /* Transmit data byte */ + DL_UART_transmitData(pxUartInstance, pu8TxData[u32Index]); + + /* Wait for TX FIFO to become available, with timeout */ + while (DL_UART_isTXFIFOFull(pxUartInstance) && + ((i32MCAL_GetTicks() - u32TickStart) < 100)); + } + + return IVEC_CORE_STATUS_SUCCESS; +} + +/** + * @brief Function to write data to the UART port. + * @pre UART must be initialized before calling this function. + * @param [in] pxUartHandle Pointer to UART handle structure. + * @param [in] pu8Data Pointer to the data buffer to send. + * @param [in] u32DataLength Length of the data to be sent. + * @return IVEC_McalCommonErr_e Status of the write operation. + */ +IVEC_McalCommonErr_e xMCAL_UartWrite(xMcalUartHandle* pxUartHandle, uint8_t* pu8Data, uint32_t u32DataLength) +{ + IVEC_McalCommonErr_e eFuncStatus = commonMCAL_SUCCESS; + int32_t i32Ret; + + /* Log function entry */ IVEC_MCAL_FUNC_ENTRY(LOG_STRING); - IVEC_McalCommonErr_e l_xFuncStatus = commonMCAL_SUCCESS; + + /* Validate input parameters */ if (pxUartHandle == NULL) { - l_xFuncStatus = commonMCAL_INVALID_PARAM; + eFuncStatus = commonMCAL_INVALID_PARAM; goto exit; } - l_i32Ret = uart_transmit(pxUartHandle, pucData, u32DataLength); - IVEC_MCAL_LOG(LOG_STRING, "Writing UART status %d", l_i32Ret); - if (l_i32Ret != STATUS_SUCCESS) + + /* Call static transmit function */ + i32Ret = _prvMCAL_UartTransmit(pxUartHandle, pu8Data, u32DataLength); + + /* Log transmit status */ + IVEC_MCAL_LOG(LOG_STRING, "UART write status: %d", i32Ret); + + /* Handle transmit errors */ + if (i32Ret != IVEC_CORE_STATUS_SUCCESS) { - l_xFuncStatus = commonMCAL_WRITE_FAIL; + eFuncStatus = commonMCAL_WRITE_FAIL; goto exit; } + exit: + /* Log function exit */ IVEC_MCAL_FUNC_EXIT(LOG_STRING); - return l_xFuncStatus; + return eFuncStatus; } -///////////////////////////////////////////////////////////////////////////////////// -///////////////////////////////////////////////////////////////////////////////////// -static xCoreStatus_t uart_init(McalUartHandle_s* pxUartHandle, McalUartBaudRate_e xBaud) -{ - if (pxUartHandle->eUartPortNumber== mcalUART_PORT2) + +///////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////// +static IVEC_CoreStatus_e prvMCAL_UART_InitInstance(xMcalUartHandle* pxUartHandle, eMcalUartBaudRate xBaud) +{ + if (pxUartHandle->eUartPortNumber == eMcalUartPort2) { DL_UART_Main_reset(UART1); DL_UART_Main_enablePower(UART1); DL_GPIO_initPeripheralOutputFunction(IOMUX_PINCM19, IOMUX_PINCM19_PF_UART1_TX); DL_GPIO_initPeripheralInputFunction(IOMUX_PINCM20, IOMUX_PINCM20_PF_UART1_RX); } - - else if (pxUartHandle->eUartPortNumber== mcalUART_PORT3) + else if (pxUartHandle->eUartPortNumber == eMcalUartPort3) { DL_UART_Main_reset(UART2); DL_UART_Main_enablePower(UART2); DL_GPIO_initPeripheralOutputFunction(IOMUX_PINCM32, IOMUX_PINCM32_PF_UART2_TX); DL_GPIO_initPeripheralInputFunction(IOMUX_PINCM33, IOMUX_PINCM33_PF_UART2_RX); - - } - // Get the UART instance based on the port number in the handle - UART_Regs* uart_inst = GetUartInstance(pxUartHandle->eUartPortNumber); + UART_Regs* pxUartInstance = _prvMCAL_GetUartInstance(pxUartHandle->eUartPortNumber); - // Check if the UART instance is valid - if (uart_inst == NULL) + if (pxUartInstance == NULL) { - return STATUS_ERROR; + return commonMCAL_FAIL; } - DL_UART_Config xprvUartConfig = { 0 }; - xprvUartConfig.direction = DL_UART_MAIN_DIRECTION_TX_RX; - xprvUartConfig.mode = DL_UART_MAIN_MODE_NORMAL; + DL_UART_Config xUartConfig = { 0 }; + xUartConfig.direction = DL_UART_MAIN_DIRECTION_TX_RX; + xUartConfig.mode = DL_UART_MAIN_MODE_NORMAL; - //xprvUartConfig.wordLength = pxUartHandle->xUartConfig.eUartDataBit; - uint8_t datalength = pxUartHandle->xUartConfig.eUartDataBit; - if (datalength == mcalUART_DATABIT_7) + uint8_t ucDataLength = pxUartHandle->xUartConfig.eUartDataBit; + if (ucDataLength == eMcalUartDataBit7) { - xprvUartConfig.wordLength = DL_UART_WORD_LENGTH_7_BITS; + xUartConfig.wordLength = DL_UART_WORD_LENGTH_7_BITS; } - else if (datalength == mcalUART_DATABIT_8) + else if (ucDataLength == eMcalUartDataBit8) { - xprvUartConfig.wordLength = DL_UART_WORD_LENGTH_8_BITS; + xUartConfig.wordLength = DL_UART_WORD_LENGTH_8_BITS; } - //xprvUartConfig.stopBits = pxUartHandle->xUartConfig.eUartStopBit; - uint8_t stopbit = pxUartHandle->xUartConfig.eUartStopBit; - if (stopbit == mcalUART_STOP_1) + uint8_t ucStopBit = pxUartHandle->xUartConfig.eUartStopBit; + if (ucStopBit == eMcalUartStopBit1) { - xprvUartConfig.stopBits = DL_UART_STOP_BITS_ONE; + xUartConfig.stopBits = DL_UART_STOP_BITS_ONE; } - else if (stopbit == mcalUART_STOP_2) + else if (ucStopBit == eMcalUartStopBit2) { - xprvUartConfig.stopBits = DL_UART_STOP_BITS_TWO; + xUartConfig.stopBits = DL_UART_STOP_BITS_TWO; } - //xprvUartConfig.parity = pxUartHandle->xUartConfig.eUartParityBit; - uint8_t paritybit = pxUartHandle->xUartConfig.eUartParityBit; - if (paritybit == mcalUART_PARITY_NONE) + uint8_t ucParityBit = pxUartHandle->xUartConfig.eUartParityBit; + if (ucParityBit == eMcalUartParityNone) { - xprvUartConfig.parity = DL_UART_PARITY_NONE; + xUartConfig.parity = DL_UART_PARITY_NONE; } - else if (paritybit == mcalUART_PARITY_ODD) + else if (ucParityBit == eMcalUartParityOdd) { - xprvUartConfig.parity = DL_UART_PARITY_ODD; + xUartConfig.parity = DL_UART_PARITY_ODD; } - else if (paritybit == mcalUART_PARITY_EVEN) + else if (ucParityBit == eMcalUartParityEven) { - xprvUartConfig.parity = DL_UART_PARITY_EVEN; + xUartConfig.parity = DL_UART_PARITY_EVEN; } - xprvUartConfig.flowControl = DL_UART_FLOW_CONTROL_NONE; + xUartConfig.flowControl = DL_UART_FLOW_CONTROL_NONE; + + DL_UART_ClockConfig xUartClockConfig = { 0 }; + xUartClockConfig.clockSel = DL_UART_CLOCK_BUSCLK; + xUartClockConfig.divideRatio = DL_UART_MAIN_CLOCK_DIVIDE_RATIO_1; + + DL_UART_Main_setClockConfig(pxUartInstance, (DL_UART_Main_ClockConfig*) &xUartClockConfig); + DL_UART_Main_init(pxUartInstance, (DL_UART_Main_Config*) &xUartConfig); + + DL_UART_Main_setOversampling(pxUartInstance, DL_UART_OVERSAMPLING_RATE_16X); - DL_UART_ClockConfig gUART_0ClockConfig = { 0 }; - gUART_0ClockConfig.clockSel = DL_UART_CLOCK_BUSCLK; - gUART_0ClockConfig.divideRatio = DL_UART_MAIN_CLOCK_DIVIDE_RATIO_1; - - DL_UART_Main_setClockConfig(uart_inst, (DL_UART_Main_ClockConfig*)&gUART_0ClockConfig); - DL_UART_Main_init(uart_inst, (DL_UART_Main_Config*)&xprvUartConfig); - - /* Configure baud rate by setting oversampling and baud rate divisors.*/ - DL_UART_Main_setOversampling(uart_inst, DL_UART_OVERSAMPLING_RATE_16X); - - if (xBaud == 115200) + if (xBaud == eMcalUartBaud115200) { - - /* - * Target baud rate: 115200 - * Actual baud rate: 115211.52 - */ - // DL_UART_Main_setBaudRateDivisor(uart_inst, 13, 1); - //DL_UART_Main_setBaudRateDivisor(uart_inst, 19, 20); - DL_UART_Main_setBaudRateDivisor(uart_inst, 19, 34); + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 19, 34); } - else if (xBaud == 9600) + else if (xBaud == eMcalUartBaud9600) { - DL_UART_Main_setBaudRateDivisor(uart_inst, 234, 24); + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 234, 24); + } + else if (xBaud == eMcalUartBaud2400) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 937, 32); + } + else if (xBaud == eMcalUartBaud4800) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 468, 48); + } + else if (xBaud == eMcalUartBaud14400) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 156, 16); + } + else if (xBaud == eMcalUartBaud19200) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 117, 12); + } + else if (xBaud == eMcalUartBaud28800) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 78, 8); + } + else if (xBaud == eMcalUartBaud33600) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 66, 62); + } + else if (xBaud == eMcalUartBaud38400) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 58, 38); + } + else if (xBaud == eMcalUartBaud57600) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 39, 4); + } + else if (xBaud == eMcalUartBaud230400) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 9, 49); + } + else if (xBaud == eMcalUartBaud460800) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 4, 57); + } + else if (xBaud == eMcalUartBaud921600) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 2, 28); + } + else if (xBaud == eMcalUartBaud1000000) + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 2, 16); + } + else + { + DL_UART_Main_setBaudRateDivisor(pxUartInstance, 13, 1); } - else if (xBaud == 2400) + if (pxUartInstance == UART0) { - DL_UART_Main_setBaudRateDivisor(uart_inst, 937, 32); - } - else if (xBaud == 4800) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 468, 48); - } - else if (xBaud == 14400) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 156, 16); - } - else if (xBaud == 19200) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 117, 12); - } - else if (xBaud == 28800) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 78, 8); - } - else if (xBaud == 33600) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 66, 62); - } - else if (xBaud == 38400) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 58, 38); - } - else if (xBaud == 57600) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 39, 4); - } - else if (xBaud == 230400) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 9, 49); - } - else if (xBaud == 460800) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 4, 57); - } - else if (xBaud == 921600) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 2, 28); - } - else if (xBaud == 1000000) - { - DL_UART_Main_setBaudRateDivisor(uart_inst, 2, 16); - } - else { - /* - * Target baud rate: 115200 - * Actual baud rate: 115211.52 - */ - DL_UART_Main_setBaudRateDivisor(uart_inst, 13, 1); - } - - /* Configure Interrupts */ - - if (uart_inst == UART0) - { - - - DL_UART_Main_enableInterrupt(uart_inst, + DL_UART_Main_enableInterrupt(pxUartInstance, DL_UART_MAIN_INTERRUPT_BREAK_ERROR | DL_UART_MAIN_INTERRUPT_FRAMING_ERROR | DL_UART_MAIN_INTERRUPT_NOISE_ERROR | @@ -491,17 +552,13 @@ static xCoreStatus_t uart_init(McalUartHandle_s* pxUartHandle, McalUartBaudRate_ DL_UART_Main_setRXFIFOThreshold(UART0, DL_UART_RX_FIFO_LEVEL_ONE_ENTRY); DL_UART_Main_setTXFIFOThreshold(UART0, DL_UART_TX_FIFO_LEVEL_1_2_EMPTY); - - DL_UART_Main_enable(uart_inst); - /*Clearing and Enabling Interrupt Requests*/ - + DL_UART_Main_enable(pxUartInstance); NVIC_ClearPendingIRQ(UART0_INT_IRQn); NVIC_EnableIRQ(UART0_INT_IRQn); - //b_UART0_init_flag=1; } - if (uart_inst == UART1) + else if (pxUartInstance == UART1) { - DL_UART_Main_enableInterrupt(uart_inst, + DL_UART_Main_enableInterrupt(pxUartInstance, DL_UART_MAIN_INTERRUPT_BREAK_ERROR | DL_UART_MAIN_INTERRUPT_FRAMING_ERROR | DL_UART_MAIN_INTERRUPT_NOISE_ERROR | @@ -514,18 +571,13 @@ static xCoreStatus_t uart_init(McalUartHandle_s* pxUartHandle, McalUartBaudRate_ DL_UART_Main_setRXFIFOThreshold(UART1, DL_UART_RX_FIFO_LEVEL_ONE_ENTRY); DL_UART_Main_setTXFIFOThreshold(UART1, DL_UART_TX_FIFO_LEVEL_1_2_EMPTY); - - DL_UART_Main_enable(uart_inst); - /*Clearing and Enabling Interrupt Requests*/ - + DL_UART_Main_enable(pxUartInstance); NVIC_ClearPendingIRQ(UART1_INT_IRQn); NVIC_EnableIRQ(UART1_INT_IRQn); - //b_UART1_init_flag=1; } - else if (uart_inst == UART2) + else if (pxUartInstance == UART2) { - - DL_UART_Main_enableInterrupt(uart_inst, + DL_UART_Main_enableInterrupt(pxUartInstance, DL_UART_MAIN_INTERRUPT_BREAK_ERROR | DL_UART_MAIN_INTERRUPT_FRAMING_ERROR | DL_UART_MAIN_INTERRUPT_NOISE_ERROR | @@ -534,22 +586,16 @@ static xCoreStatus_t uart_init(McalUartHandle_s* pxUartHandle, McalUartBaudRate_ DL_UART_MAIN_INTERRUPT_RX | DL_UART_MAIN_INTERRUPT_RX_TIMEOUT_ERROR); - DL_UART_Main_enableFIFOs(UART2); DL_UART_Main_setRXFIFOThreshold(UART2, DL_UART_RX_FIFO_LEVEL_ONE_ENTRY); DL_UART_Main_setTXFIFOThreshold(UART2, DL_UART_TX_FIFO_LEVEL_1_2_EMPTY); - // DL_UART_Main_setRXInterruptTimeout(UART2, 15); - - DL_UART_Main_enable(uart_inst); - /*Clearing and Enabling Interrupt Requests*/ - + DL_UART_Main_enable(pxUartInstance); NVIC_ClearPendingIRQ(UART2_INT_IRQn); NVIC_EnableIRQ(UART2_INT_IRQn); - } - return STATUS_SUCCESS;//TODO: FIX RETURN BUG + return commonMCAL_SUCCESS; } @@ -583,9 +629,9 @@ static void __prvMCAL_UartNotifyRecvCb(uint32 ind_type, ql_uart_port_number_e po * @param pxUartHandle pointer to \link McalUartHandle_s \endlink * @return Nothing */ -static void __prvMCAL_UartRegisterHandle(McalUartHandle_s* pxUartHandle) +static void prvMCAL_UartRegisterHandle(xMcalUartHandle* pxUartHandle) { - g_pxUartHandles[pxUartHandle->eUartPortNumber] = pxUartHandle; + gpxMcalUartHandles[pxUartHandle->eUartPortNumber] = pxUartHandle; } /** * @brief Function to Init UART peripheral @@ -593,7 +639,7 @@ static void __prvMCAL_UartRegisterHandle(McalUartHandle_s* pxUartHandle) * @param pxUartHandle pointer to \link McalUartHandle_s \endlink * @return \link IVEC_McalCommonErr_e \endlink returns a status based on the success or failure of the UART Init operation. */ -IVEC_McalCommonErr_e xMCAL_UartInit(McalUartHandle_s* pxUartHandle) +IVEC_McalCommonErr_e xMCAL_UartInit(xMcalUartHandle* pxUartHandle) { IVEC_MCAL_FUNC_ENTRY(LOG_STRING); @@ -603,11 +649,11 @@ IVEC_McalCommonErr_e xMCAL_UartInit(McalUartHandle_s* pxUartHandle) l_xFuncStatus = commonMCAL_INVALID_PARAM; goto exit; } - __prvMCAL_UartRegisterHandle(pxUartHandle); + prvMCAL_UartRegisterHandle(pxUartHandle); - int l_i32Ret = uart_init(pxUartHandle, pxUartHandle->xUartConfig.eUartBaudrate); - if (l_i32Ret != STATUS_SUCCESS) + int l_i32Ret = prvMCAL_UART_InitInstance(pxUartHandle, pxUartHandle->xUartConfig.eUartBaudrate); + if (l_i32Ret != IVEC_CORE_STATUS_SUCCESS) { l_xFuncStatus = commonMCAL_INIT_FAIL; goto exit; diff --git a/ivec_ECU/ivec_ecu_can/inc/ivec_ecu_can.h b/ivec_ECU/ivec_ecu_can/inc/ivec_ecu_can.h index 9493a30..3c58d50 100644 --- a/ivec_ECU/ivec_ecu_can/inc/ivec_ecu_can.h +++ b/ivec_ECU/ivec_ecu_can/inc/ivec_ecu_can.h @@ -1,4 +1,5 @@ -#define IVEC_ECU_CAN_H +#ifndef IVEC_ECU_CAN_H_ +#define IVEC_ECU_CAN_H_ #include "../Core/Include/ivec_mcal_mcan.h" #include "../ivec_ECU/ivec_ecu_common/inc/ivec_ecu_common.h" @@ -8,63 +9,63 @@ #include #include -#define QUEUE(name, buff) \ - volatile can_queue_t name = { \ - .front = 0, \ - .rear = 0, \ - .size = (sizeof(buff)/sizeof(buff[0])), \ - .element_size = sizeof(buff[0]), \ - .buffer = buff, \ - } +// Macro Definitions +#define IVEC_ECU_CAN_QUEUE(name, buff) \ + volatile IVEC_ECU_CANQueue_s name = { \ + .front = 0, \ + .rear = 0, \ + .size = (sizeof(buff) / sizeof(buff[0])), \ + .element_size = sizeof(buff[0]), \ + .buffer = buff, \ + } -#define FLUSH(name) do { \ - name.front = 0; \ - name.rear = 0; \ - memset(name.buffer, 0x00, name.size); \ - } while(0) +#define IVEC_ECU_CAN_FLUSH(name) do { \ + name.front = 0; \ + name.rear = 0; \ + memset(name.buffer, 0x00, name.size); \ +} while (0) -#define ENQUEUE(queue, data) do { \ - memcpy(&queue.buffer[queue.front++], &data, sizeof(data)); \ - queue.front %= queue.size; \ - } while(0) +#define IVEC_ECU_CAN_ENQUEUE(queue, data) do { \ + memcpy(&queue.buffer[queue.front++], &data, sizeof(data)); \ + queue.front %= queue.size; \ +} while (0) +#define IVEC_ECU_CAN_DEQUEUE(queue, data) do { \ + memcpy(&data, &queue.buffer[queue.rear++], sizeof(data)); \ + queue.rear %= queue.size; \ +} while (0) -#define DEQUEUE(queue, data) do { \ - memcpy(&data, &queue.buffer[queue.rear++], sizeof(data)); \ - queue.rear %= queue.size; \ - } while(0) +#define IVEC_ECU_CAN_IS_FULL(queue) ((queue.front - queue.rear) == (queue.size - 1) || \ + (queue.front - queue.rear) == -1) +#define IVEC_ECU_CAN_IS_EMPTY(queue) (queue.front == queue.rear) -#define IS_FULL(queue) ((queue.front - queue.rear) == (queue.size -1) || \ - (queue.front - queue.rear) == -1) - -#define IS_EMPTY(queue) (queue.front == queue.rear) - - -/*Private Variable*/ +/* Private Variable */ typedef struct { - uint32_t id; - uint8_t data[8]; - uint8_t length; + uint32_t ulId; + uint8_t ucData[8]; + uint8_t ucLength; uint8_t resv[3]; -} can_buff_t; +} IVEC_ECU_CANBuff_s; typedef struct { uint16_t front; uint16_t rear; uint16_t size; uint8_t element_size; - can_buff_t * buffer; -} can_queue_t; + IVEC_ECU_CANBuff_s *buffer; +} IVEC_ECU_CANQueue_s; +// Function Prototypes +void vMCU_FDCAN_RxFifo_Callback(uint32_t ulIdentifier, uint8_t *pucData, uint16_t usDataLength); +uint8_t vMCAL_StoreMsgFromISRToQueue(uint32_t ulId, uint8_t *pucData, uint8_t ucLen); +IVEC_EcuCommonErr_e vECU_CAN_Init(MCAN_Regs *pMCAN, IVEC_CanBaud_e eBaud); +IVEC_EcuCommonErr_e vECU_CAN_DeInit(MCAN_Regs *pMCAN); +IVEC_EcuCommonErr_e vECU_WriteDataOverCAN(uint8_t *pucBuf, uint32_t ulId, int iRetCode, uint32_t ulBufNum); +IVEC_EcuCommonErr_e vECU_CAN_GetData(IVEC_ECU_CANBuff_s *pxBuff); +IVEC_EcuCommonErr_e vECU_CAN_ReInit(MCAN_Regs *pMCAN, uint16_t usSpeed); +IVEC_EcuCommonErr_e vECU_CAN_GetStatus(MCAN_Regs *pMCAN, uint16_t usSpeed); -void mcu_FDCAN_RxFifo_Callback(uint32_t Identifier, uint8_t *data, uint16_t DataLength); -uint8_t store_msg_from_isr_to_queue(uint32_t id, uint8_t* data, uint8_t len); - -IVEC_EcuCommonErr_e xECU_CANInit(MCAN_Regs* MCAN, xCAN_baud_t BAUD); -IVEC_EcuCommonErr_e xECU_CANDeInit(MCAN_Regs* MCAN); -IVEC_EcuCommonErr_e xECU_WriteDataOverCAN(uint8_t* pucBuf, uint32_t ulId, int retCode, uint32_t BufNum); -IVEC_EcuCommonErr_e xECU_CANGetData(can_buff_t *xBuff); -IVEC_EcuCommonErr_e xECU_CanReInit(MCAN_Regs* MCAN,uint16_t speed); -IVEC_EcuCommonErr_e xECU_GetCanStatus(MCAN_Regs* MCAN, uint16_t speed); +#endif /* IVEC_ECU_CAN_H_ */ +// diff --git a/ivec_ECU/ivec_ecu_can/src/ivec_ecu_can.c b/ivec_ECU/ivec_ecu_can/src/ivec_ecu_can.c index 9e7057e..2c0b322 100644 --- a/ivec_ECU/ivec_ecu_can/src/ivec_ecu_can.c +++ b/ivec_ECU/ivec_ecu_can/src/ivec_ecu_can.c @@ -1,129 +1,161 @@ #include "../ivec_ECU/ivec_ecu_can/inc/ivec_ecu_can.h" #include "../ivec_ECU/ivec_ecu_uart/inc/ivec_ecu_uart.h" #include "../Core/Include/ivec_mcal_uart.h" -extern int maskCount; -extern int filterCount; -static can_buff_t g_canBuffer[1024] = {0}; /*All the CAN Id, Len and Data are stored in this array*/ -QUEUE(g_canQueue, g_canBuffer); +/* Static CAN buffer for storing CAN message data */ +static IVEC_ECU_CANBuff_s g_xCanBuffer[1024] = {0}; /* All the CAN ID, length, and data are stored in this array */ +/* Queue for CAN messages */ +IVEC_ECU_CAN_QUEUE(g_xCanQueue_x, g_xCanBuffer); -void mcu_FDCAN_RxFifo_Callback(uint32_t Identifier, uint8_t *data, uint16_t DataLength) +/* CAN Receive FIFO Callback function */ +void vMCAL_CanReceiveFifoCallback(uint32_t u32Identifier, uint8_t* pu8Data, uint16_t u16DataLength) { - if (!IS_FULL(g_canQueue)) { - store_msg_from_isr_to_queue(Identifier, data, DataLength); + /* Check if the CAN queue is full */ + if (!IVEC_ECU_CAN_IS_FULL(g_xCanQueue_x)) { + /* Store the received message in the queue from the interrupt */ + vMCAL_StoreMsgFromISRToQueue(u32Identifier, pu8Data, u16DataLength); } - } +/** + * @brief Stores a CAN message from ISR to a queue. + * + * @param ulId CAN ID of the message. + * @param pucData Pointer to the CAN data. + * @param ucLen Length of the CAN data. + * @return uint8_t Status (0 for success, non-zero for failure). + */ -uint8_t store_msg_from_isr_to_queue(uint32_t id, uint8_t* data, uint8_t len) +uint8_t vMCAL_StoreMsgFromISRToQueue(uint32_t ulId, uint8_t* pucData, uint8_t ucLen) { - can_buff_t buff = {0}; - buff.id = id; - buff.length = len; - memcpy(buff.data, data, len); - ENQUEUE(g_canQueue, buff); + IVEC_ECU_CANBuff_s xBuff = {0}; + xBuff.ulId = ulId; + xBuff.ucLength = ucLen; + memcpy(xBuff.ucData, pucData, ucLen); + IVEC_ECU_CAN_ENQUEUE(g_xCanQueue_x, xBuff); // Ensure `ENQUEUE` is defined properly. return 0; } -IVEC_EcuCommonErr_e xECU_WriteDataOverCAN(uint8_t* pucBuf, uint32_t ulId, int retCode, uint32_t BufNum) +/** + * @brief Sends data over CAN. + * + * @param pucBuf Pointer to the data buffer. + * @param ulId CAN ID to send the data. + * @param iRetCode Number of bytes to transmit. + * @param ulBufNum CAN buffer number. + * @return IVEC_EcuCommonErr_e Status of the transmission. + */ +// Function to write data over CAN +IVEC_EcuCommonErr_e vECU_WriteDataOverCAN(uint8_t* pucBuf, uint32_t u32Id, int iRetCode, uint32_t u32BufNum) { - IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_WRITE_FAIL; - uint8_t l_i32Ret; + IVEC_EcuCommonErr_e eFuncStatus = commonECU_WRITE_FAIL; + uint8_t u8RetCode; - uint16_t TxData[8] = {0}; // Define a buffer for the CAN payload data - for (int i = 0; i < retCode; i++) { - TxData[i] = (uint16_t)(pucBuf[i] ^ 0x0000); + uint16_t au16TxData[8] = {0}; // Define a buffer for the CAN payload data. + for (int i = 0; i < iRetCode; i++) { + au16TxData[i] = (uint16_t)(pucBuf[i] ^ 0x0000); } - int Bytes = retCode; - l_i32Ret = xMCAL_MCANTx(CANFD0, ulId, TxData, BufNum, Bytes); - if(l_i32Ret == IVEC_MCAL_STATUS_SUCCESS) - { - l_xFuncStatus = commonECU_SUCCESS; + + int iBytes = iRetCode; + u8RetCode = vMCAL_MCAN_Tx(CANFD0, u32Id, au16TxData, u32BufNum, iBytes); + + if (u8RetCode == IVEC_MCAL_STATUS_SUCCESS) { + eFuncStatus = commonECU_SUCCESS; } - return l_xFuncStatus; + + return eFuncStatus; } -IVEC_EcuCommonErr_e xECU_CANGetData(can_buff_t *pxBuff) +// Function to get data from the CAN buffer queue +IVEC_EcuCommonErr_e vECU_CAN_GetData(IVEC_ECU_CANBuff_s *pxBuff) { - IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_FAIL; - if (!IS_EMPTY(g_canQueue)) - { + IVEC_EcuCommonErr_e eFuncStatus = commonECU_FAIL; - can_buff_t xBuff = { 0x00 }; - DEQUEUE(g_canQueue, xBuff); - memcpy(pxBuff,&xBuff,sizeof(can_buff_t)); - l_xFuncStatus = commonECU_SUCCESS; + if (!IVEC_ECU_CAN_IS_EMPTY(g_xCanQueue_x)) { + IVEC_ECU_CANBuff_s xBuff = { 0x00 }; + IVEC_ECU_CAN_DEQUEUE(g_xCanQueue_x, xBuff); + memcpy(pxBuff, &xBuff, sizeof(IVEC_ECU_CANBuff_s)); + eFuncStatus = commonECU_SUCCESS; } - return l_xFuncStatus; + return eFuncStatus; } - -IVEC_EcuCommonErr_e xECU_CanReInit(MCAN_Regs* MCAN,uint16_t speed) +/* Function to reinitialize the CAN module */ +IVEC_EcuCommonErr_e vECU_CAN_ReInit(MCAN_Regs* pMCAN, uint16_t u16Speed) { - IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; - uint8_t l_i32Ret; - - if(maskCount >= 0) - { - vCanFilterReset(); + IVEC_EcuCommonErr_e l_eFuncStatus = commonECU_SUCCESS; + IVEC_McalStatus_e l_xMCALStatus; + /* Deinitialize the MCAN module */ + l_xMCALStatus = vMCAL_MCAN_DeInit(pMCAN); + if (l_xMCALStatus != IVEC_MCAL_STATUS_SUCCESS) { + l_eFuncStatus = commonECU_DEINIT_FAIL; + return l_eFuncStatus; } - l_i32Ret = xMCAL_MCANDeInit(MCAN); - if(l_i32Ret != IVEC_MCAL_STATUS_SUCCESS) - { - l_xFuncStatus = commonECU_DEINIT_FAIL; - } - - //DL_MCAN_reset(MCAN); - // DL_GPIO_enablePower(GPIOA); - // DL_GPIO_enablePower(GPIOB); - DL_MCAN_enablePower(MCAN); + /* Enable power to the MCAN module */ + DL_MCAN_enablePower(pMCAN); delay_cycles(POWER_STARTUP_DELAY); + /* Configure GPIO for CAN TX and RX */ DL_GPIO_initPeripheralOutputFunction(GPIO_MCAN0_IOMUX_CAN_TX, GPIO_MCAN0_IOMUX_CAN_TX_FUNC); DL_GPIO_initPeripheralInputFunction(GPIO_MCAN0_IOMUX_CAN_RX, GPIO_MCAN0_IOMUX_CAN_RX_FUNC); - l_i32Ret = xMCAL_MCANInit(MCAN,speed); - if(maskCount >= 0) - { - vCanConfigFilter(); - } - if(l_i32Ret != IVEC_MCAL_STATUS_SUCCESS) - { - l_xFuncStatus = commonECU_INIT_FAIL; - } - return l_xFuncStatus; + /* Reinitialize the MCAN module */ + l_xMCALStatus = vMCAL_MCAN_Init(pMCAN, u16Speed); + + /* Check if reinitialization was successful */ + if (l_xMCALStatus != IVEC_MCAL_STATUS_SUCCESS) { + l_eFuncStatus = commonECU_INIT_FAIL; + } + + return l_eFuncStatus; } -IVEC_EcuCommonErr_e xECU_CANInit(MCAN_Regs* MCAN, xCAN_baud_t BAUD) +/* Function to initialize the CAN module */ +IVEC_EcuCommonErr_e vECU_CAN_Init(MCAN_Regs *pMCAN, IVEC_CanBaud_e eBaud) { - IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; - uint8_t l_i32Ret; - l_i32Ret = xMCAL_MCANInit(MCAN,BAUD); - if(l_i32Ret != IVEC_MCAL_STATUS_SUCCESS) + IVEC_EcuCommonErr_e l_eFuncStatus = commonECU_SUCCESS; + IVEC_McalStatus_e eMcalStatus; + + /* Call MCAL initialization function */ + eMcalStatus = vMCAL_MCAN_Init(pMCAN, eBaud); + + /* Check if initialization was successful */ + if (eMcalStatus != IVEC_MCAL_STATUS_SUCCESS) { - l_xFuncStatus = commonECU_INIT_FAIL; + l_eFuncStatus = commonECU_INIT_FAIL; } - return l_xFuncStatus; -} -IVEC_EcuCommonErr_e xECU_CANDeInit(MCAN_Regs* MCAN) -{ - IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; - uint8_t l_i32Ret; - l_i32Ret = xMCAL_MCANDeInit(MCAN); - if(l_i32Ret != IVEC_MCAL_STATUS_SUCCESS) - { - l_xFuncStatus = commonECU_INIT_FAIL; - } - return l_xFuncStatus; + return l_eFuncStatus; } -IVEC_EcuCommonErr_e xECU_GetCanStatus(MCAN_Regs* MCAN, uint16_t speed) +/* Function to deinitialize the CAN module */ +IVEC_EcuCommonErr_e vECU_CAN_DeInit(MCAN_Regs *pMCAN) { - char l_ucErrorString[32] = {0}; - if( xMCAL_getMCAN_ErrorStatus(l_ucErrorString) == IVEC_MCAL_STATUS_ERROR ) + IVEC_EcuCommonErr_e l_eFuncStatus = commonECU_SUCCESS; + IVEC_McalStatus_e eMcalStatus; + + /* Call MCAL deinitialization function */ + eMcalStatus = vMCAL_MCAN_DeInit(pMCAN); + + /* Check if deinitialization was successful */ + if (eMcalStatus != IVEC_MCAL_STATUS_SUCCESS) { - xECU_CanReInit(MCAN, speed); + l_eFuncStatus = commonECU_INIT_FAIL; } + return l_eFuncStatus; +} + +/* Function to get the status of the CAN module */ +IVEC_EcuCommonErr_e vECU_CAN_GetStatus(MCAN_Regs* const pMCAN, uint16_t u16Speed) +{ + IVEC_EcuCommonErr_e l_eFuncStatus = commonECU_SUCCESS; + char cErrorString[32] = {0}; + + /* Retrieve the MCAN error status */ + if (vMCAL_MCAN_GetErrorStatus(cErrorString) == IVEC_MCAL_STATUS_ERROR) + { + /* Reinitialize CAN if an error is detected */ + l_eFuncStatus = vECU_CAN_ReInit(pMCAN, u16Speed); + } + return l_eFuncStatus; } diff --git a/ivec_ECU/ivec_ecu_uart/inc/ivec_ecu_uart.h b/ivec_ECU/ivec_ecu_uart/inc/ivec_ecu_uart.h index 3a05626..d41a2e6 100644 --- a/ivec_ECU/ivec_ecu_uart/inc/ivec_ecu_uart.h +++ b/ivec_ECU/ivec_ecu_uart/inc/ivec_ecu_uart.h @@ -1,10 +1,8 @@ #ifndef IVEC_ECU_UART_H #define IVEC_ECU_UART_H -//#include "ivec_mcal_uart.h" #include "../Core/Include/ivec_mcal_uart.h" #include "../ivec_ECU/ivec_ecu_common/inc/ivec_ecu_common.h" -//#include "ivec_ecu_common.h" #include "stdint.h" @@ -12,61 +10,59 @@ #include #include -#define MAX_PACKET_LENGTH 32/*! -//#include "ivec_mcal_uart.h" #define LOG_STRING "ivec-ecu-UART" -//#define CAN_UART_BUFFER_MAX_SIZE 4096 //#define NFC_UART_BUFFER_MAX_SIZE 256 -#define DATA_PACKET_TIMEOUT 300 +#define DATA_PACKET_TIMEOUT_MS 300 -volatile static CmplxFifoQueueHandle_s __gprv_MyEcuUARTResponseQueue[IVEC_MCAL_UART_MAX_PORT] = { 0 }; - -//static uint8_t __gprv_u8CANUartDataBuffer[CAN_UART_BUFFER_MAX_SIZE]; +volatile static CmplxFifoQueueHandle_s __gprv_EcuUartResponseQueue[IVEC_MCAL_UART_MAX_PORT] = { 0 }; //static uint8_t __gprv_u8NFCUartDataBuffer[NFC_UART_BUFFER_MAX_SIZE]; -int uartCount = 1; - -static void __prv_vEcu_CANOverUartMsgCallback(McalUartPortNumber_e eUartPort, IVEC_McalUartEvents_e eIndType, char* pucBuffer, uint32_t u32Size) +static void __prv_vEcu_CANOverUartMsgCallback(eMcalUartPortNumber uartPort, IVEC_ECU_UartEvent_e eventType, char* pucBuffer, uint32_t u32Size) { - switch (eUartPort) + switch (uartPort) { - case mcalUART_PORT2: - if (eIndType == IVEC_MCAL_UART_EVENT_RX_ARRIVED) { - u8CMPLX_FifoEnqueue((CmplxFifoQueueHandle_s*)&__gprv_MyEcuUARTResponseQueue[mcalUART_PORT2], pucBuffer, u32Size); - + case eMcalUartPort2: + if (eventType == IVEC_ECU_UART_EVENT_RX_ARRIVED) { + u8CMPLX_FifoEnqueue((CmplxFifoQueueHandle_s*)&__gprv_EcuUartResponseQueue[IVEC_ECU_UART_PORT2], pucBuffer, u32Size); } break; - case mcalUART_PORT3: - if (eIndType == IVEC_MCAL_UART_EVENT_RX_ARRIVED) { - u8CMPLX_FifoEnqueue((CmplxFifoQueueHandle_s*)&__gprv_MyEcuUARTResponseQueue[mcalUART_PORT3], pucBuffer, u32Size); - + case eMcalUartPort3: + if (eventType == IVEC_ECU_UART_EVENT_RX_ARRIVED) { + u8CMPLX_FifoEnqueue((CmplxFifoQueueHandle_s*)&__gprv_EcuUartResponseQueue[IVEC_ECU_UART_PORT3], pucBuffer, u32Size); } break; default: break; } - } -static void prvChecksumCalculate(uint8_t* pkt, int len, uint8_t* ck) { - uint8_t mck_a = 0, mck_b = 0; - /*Incremented to ignore Sync data*/ +static void IVEC_ECU_CalculateChecksum(uint8_t* pkt, int len, uint8_t* checksum) { + uint8_t checksum_a = 0, checksum_b = 0; + /* Incremented to ignore Sync data */ for (int i = 2; i < len - 2; i++) { - mck_a += pkt[i]; - mck_b += mck_a; + checksum_a += pkt[i]; + checksum_b += checksum_a; } - mck_a &= 0xFF; - mck_b &= 0xFF; - ck[0] = mck_a; - ck[1] = mck_b; + checksum_a &= 0xFF; + checksum_b &= 0xFF; + checksum[0] = checksum_a; + checksum[1] = checksum_b; } +//IVEC_EcuCommonErr_e -IVEC_EcuCommonErr_e xECU_UARTInit(EcuUartHandle_s* prvUartHandle, uint32_t speed) +IVEC_EcuCommonErr_e IVEC_ECU_Uart_Init(IVEC_ECU_UartHandle_s* prvUartHandle, uint32_t speed) { IVEC_ECU_FUNC_ENTRY(LOG_STRING); IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; uint8_t l_i32Ret = 0; - IVEC_ECU_LOG(LOG_STRING, "UART Initilising Queue"); + IVEC_ECU_LOG(LOG_STRING, "UART Initializing Queue"); if (prvUartHandle->eUartPortNumber < IVEC_MCAL_UART_MAX_PORT) { - __gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber].i32ElementSize = sizeof(uint8_t); + __gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber].i32ElementSize = sizeof(uint8_t); switch (prvUartHandle->eUartPortNumber) { - case mcalUART_PORT2: - __gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber].i32TotalElements = prvUartHandle->u16QbufSize; - __gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber].pu8Buffer = prvUartHandle->u8Qbuffer; + case IVEC_ECU_UART_PORT2: + __gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber].i32TotalElements = prvUartHandle->u16QbufSize; + __gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber].pu8Buffer = prvUartHandle->u8Qbuffer; break; - case mcalUART_PORT3: - __gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber].i32TotalElements = prvUartHandle->u16QbufSize; - __gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber].pu8Buffer = prvUartHandle->u8Qbuffer; + case IVEC_ECU_UART_PORT3: + __gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber].i32TotalElements = prvUartHandle->u16QbufSize; + __gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber].pu8Buffer = prvUartHandle->u8Qbuffer; break; default: - __gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber].pu8Buffer = NULL; + __gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber].pu8Buffer = NULL; break; } - __gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber].i32QueueType = FIXED_ELEMENT_SIZE_QUEUE; - l_i32Ret = u8CMPLX_FifoQueueInit((CmplxFifoQueueHandle_s*)&__gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber]); + __gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber].i32QueueType = FIXED_ELEMENT_SIZE_QUEUE; + l_i32Ret = u8CMPLX_FifoQueueInit((CmplxFifoQueueHandle_s*)&__gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber]); } if (l_i32Ret == 0) { - l_xFuncStatus = commonECU_FAIL; + l_xFuncStatus = commonECU_INIT_FAIL; goto exit; } - IVEC_ECU_LOG(LOG_STRING, "Initilising UART"); + + IVEC_ECU_LOG(LOG_STRING, "Initializing UART"); prvUartHandle->__xUartHandle.pvUartRecvCallback = __prv_vEcu_CANOverUartMsgCallback; prvUartHandle->__xUartHandle.xUartConfig.eUartBaudrate = speed; prvUartHandle->__xUartHandle.eUartPortNumber = prvUartHandle->eUartPortNumber; - prvUartHandle->__xUartHandle.xUartConfig.eUartFlowCtrl = mcalUART_FC_NONE; - prvUartHandle->__xUartHandle.xUartConfig.eUartDataBit = mcalUART_DATABIT_8; - prvUartHandle->__xUartHandle.xUartConfig.eUartStopBit = mcalUART_STOP_1; - prvUartHandle->__xUartHandle.xUartConfig.eUartParityBit = mcalUART_PARITY_NONE; + prvUartHandle->__xUartHandle.xUartConfig.eUartFlowCtrl = eMcalUartFcNone; + prvUartHandle->__xUartHandle.xUartConfig.eUartDataBit = eMcalUartDataBit8; + prvUartHandle->__xUartHandle.xUartConfig.eUartStopBit = eMcalUartStopBit1; + prvUartHandle->__xUartHandle.xUartConfig.eUartParityBit = eMcalUartParityNone; l_i32Ret = xMCAL_UartInit(&prvUartHandle->__xUartHandle); - if (l_i32Ret != 0) { l_xFuncStatus = commonECU_INIT_FAIL; goto exit; } - exit: IVEC_ECU_FUNC_EXIT(LOG_STRING, 0); return l_xFuncStatus; - } -IVEC_EcuCommonErr_e xECU_UARTDeInit(EcuUartHandle_s* prvUartHandle) + +IVEC_EcuCommonErr_e IVEC_ECU_Uart_Deinit(IVEC_ECU_UartHandle_s* prvUartHandle) { IVEC_ECU_FUNC_ENTRY(LOG_STRING); uint8_t l_i32Ret; IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; + if (prvUartHandle == NULL) { l_xFuncStatus = commonECU_ALREADY_DEINIT; goto exit; } - IVEC_ECU_LOG(LOG_STRING, "DeInitilising CAN"); + + IVEC_ECU_LOG(LOG_STRING, "Deinitializing UART"); l_i32Ret = xMCAL_UartDeInit(&prvUartHandle->__xUartHandle); - if (l_i32Ret != 0) + if (l_i32Ret != IVEC_MCAL_STATUS_SUCCESS) { - l_xFuncStatus = commonECU_DEINIT_FAIL; + l_xFuncStatus = commonECU_INIT_FAIL; goto exit; } + if (prvUartHandle->eUartPortNumber < IVEC_MCAL_UART_MAX_PORT) - vCMPLX_FifoQueueFlush((CmplxFifoQueueHandle_s*)&__gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber]); + { + vCMPLX_FifoQueueFlush((CmplxFifoQueueHandle_s*)&__gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber]); + } + exit: IVEC_ECU_FUNC_EXIT(LOG_STRING, 0); return l_xFuncStatus; } - -IVEC_EcuCommonErr_e xECU_UARTReInit(EcuUartHandle_s* prvUartHandle, uint32_t speed) +IVEC_EcuCommonErr_e IVEC_ECU_Uart_Reinit(IVEC_ECU_UartHandle_s* prvUartHandle, uint32_t speed) { IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; uint8_t l_i32Ret; - l_i32Ret = xECU_UARTDeInit(prvUartHandle); + + // Deinitialize UART + l_i32Ret = IVEC_ECU_Uart_Deinit(prvUartHandle); if (l_i32Ret != IVEC_MCAL_STATUS_SUCCESS) { l_xFuncStatus = commonECU_DEINIT_FAIL; + goto exit; } - l_i32Ret = xECU_UARTInit(prvUartHandle, speed); - + // Reinitialize UART with the new speed + l_i32Ret = IVEC_ECU_Uart_Init(prvUartHandle, speed); if (l_i32Ret != IVEC_MCAL_STATUS_SUCCESS) { l_xFuncStatus = commonECU_INIT_FAIL; } + +exit: return l_xFuncStatus; } - - -IVEC_EcuCommonErr_e xECU_UARTTransmit(EcuUartHandle_s* prvUartHandle, uint8_t* pucBuffer, uint16_t len) +IVEC_EcuCommonErr_e IVEC_ECU_Uart_Transmit(IVEC_ECU_UartHandle_s* prvUartHandle, uint8_t* pucBuffer, uint16_t len) { return commonECU_SUCCESS; } -IVEC_EcuCommonErr_e xECU_UARTFlush(McalUartHandle_s* prvUartHandle) + +IVEC_EcuCommonErr_e IVEC_ECU_UART_Flush(IVEC_ECU_UartHandle_s* prvUartHandle) { - if(prvUartHandle ==NULL || prvUartHandle->eUartPortNumber>=IVEC_MCAL_UART_MAX_PORT) - vCMPLX_FifoQueueFlush((CmplxFifoQueueHandle_s*)&__gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber]); + if (prvUartHandle == NULL || prvUartHandle->eUartPortNumber >= IVEC_MCAL_UART_MAX_PORT) + { + vCMPLX_FifoQueueFlush((CmplxFifoQueueHandle_s*)&__gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber]); + } return commonECU_SUCCESS; } -IVEC_EcuCommonErr_e xECU_UARTGetData(EcuUartHandle_s* prvUartHandle, uint8_t* pucBuffer, uint16_t len, uint16_t timeout) +IVEC_EcuCommonErr_e IVEC_ECU_Uart_GetData(IVEC_ECU_UartHandle_s* prvUartHandle, uint8_t* pucBuffer, uint16_t len, uint16_t timeout) { IVEC_ECU_FUNC_ENTRY(LOG_STRING); IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; - if (prvUartHandle == NULL || prvUartHandle->eUartPortNumber>=IVEC_MCAL_UART_MAX_PORT) + + // Validate parameters + if (prvUartHandle == NULL || prvUartHandle->eUartPortNumber >= IVEC_MCAL_UART_MAX_PORT) { l_xFuncStatus = commonECU_INVALID_PARAM; goto exit; @@ -186,17 +189,19 @@ IVEC_EcuCommonErr_e xECU_UARTGetData(EcuUartHandle_s* prvUartHandle, uint8_t* pu uint8_t ijk = 0; int l_u32Len = 0; - uint32_t u32CommTimestamp = i32MCAL_getTicks(); + uint32_t u32CommTimestamp = i32MCAL_GetTicks(); - while (((i32MCAL_getTicks() - u32CommTimestamp) <= timeout + 1) && (ijk < len)) + // Loop until timeout or buffer is filled + while (((i32MCAL_GetTicks() - u32CommTimestamp) <= timeout + 1) && (ijk < len)) { - - if (!u8CMPLX_FifoQueueEmpty((CmplxFifoQueueHandle_s*)&__gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber])) { - if (u8CMPLX_FifoDequeue((CmplxFifoQueueHandle_s*)&__gprv_MyEcuUARTResponseQueue[prvUartHandle->eUartPortNumber], &pucBuffer[ijk], &l_u32Len, 0) == 1) + if (!u8CMPLX_FifoQueueEmpty((CmplxFifoQueueHandle_s*)&__gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber])) + { + if (u8CMPLX_FifoDequeue((CmplxFifoQueueHandle_s*)&__gprv_EcuUartResponseQueue[prvUartHandle->eUartPortNumber], &pucBuffer[ijk], &l_u32Len, 0) == 1) ijk++; } } + // Check if all requested data was received if (ijk != len) { l_xFuncStatus = commonECU_READ_FAIL; @@ -209,72 +214,69 @@ exit: } - -PacketRetCode_t xECU_ReadCANDataLenOverUART(EcuUartHandle_s* prvUartHandle, uint8_t* pucBuf, uint32_t* ulId) +IVEC_ECU_UartPacketRetCode_e IVEC_ECU_Uart_ReadCANDataLenOverUART(IVEC_ECU_UartHandle_s* prvUartHandle, uint8_t* pucBuf, uint32_t* ulId) { - int PktLen = PACKET_FAIL; - if ((xECU_UARTGetData(prvUartHandle, (uint8_t*)&pucBuf[0], 1, 0) == commonECU_SUCCESS)) + int PktLen = commonECU_READ_FAIL; + if ((IVEC_ECU_Uart_GetData(prvUartHandle, (uint8_t*)&pucBuf[0], 1, 0) == commonECU_SUCCESS)) { if (pucBuf[0] == 0xB5) { - if (xECU_UARTGetData(prvUartHandle, (uint8_t*)&pucBuf[1], 1, 5) == commonECU_SUCCESS) { + if (IVEC_ECU_Uart_GetData(prvUartHandle, (uint8_t*)&pucBuf[1], 1, 5) == commonECU_SUCCESS) { if (pucBuf[1] != 0x62) { - PktLen = PACKET_FAIL; - goto EXIT; //0x62 not found [OUT OF SYNC] + PktLen = commonECU_READ_FAIL; + goto EXIT; // 0x62 not found, OUT OF SYNC } } else { - PktLen = PACKET_FAIL; + PktLen = commonECU_READ_FAIL; goto EXIT; } - if (xECU_UARTGetData(prvUartHandle, (uint8_t*)&pucBuf[2], 5, DATA_PACKET_TIMEOUT) != commonECU_SUCCESS) { - PktLen = PACKET_FAIL; + if (IVEC_ECU_Uart_GetData(prvUartHandle, (uint8_t*)&pucBuf[2], 5, DATA_PACKET_TIMEOUT_MS) != commonECU_SUCCESS) { + PktLen = commonECU_READ_FAIL; goto EXIT; } - *(ulId) = (uint32_t)((pucBuf[6] << 24) | (pucBuf[5] << 16) | (pucBuf[4] << 8) | (pucBuf[3] << 0)); + *(ulId) = (uint32_t)((pucBuf[6] << 24) | (pucBuf[5] << 16) | (pucBuf[4] << 8) | (pucBuf[3])); uint8_t l_ucTempLen = pucBuf[2]; - PktLen = PKT_HEADER_FOOTER + l_ucTempLen; - if (xECU_UARTGetData(prvUartHandle, (uint8_t*)&pucBuf[PKT_HEADER], (uint32_t)(PktLen - PKT_HEADER), DATA_PACKET_TIMEOUT) != commonECU_SUCCESS) + PktLen = IVEC_ECU_UART_PKT_HEADER_FOOTER + l_ucTempLen; + if (IVEC_ECU_Uart_GetData(prvUartHandle, (uint8_t*)&pucBuf[IVEC_ECU_UART_PKT_HEADER], (uint32_t)(PktLen - IVEC_ECU_UART_PKT_HEADER), DATA_PACKET_TIMEOUT_MS) != commonECU_SUCCESS) { - PktLen = PACKET_FAIL; + PktLen = commonECU_READ_FAIL; goto EXIT; } uint8_t checksum[2]; - prvChecksumCalculate(pucBuf, PktLen, checksum); + IVEC_ECU_CalculateChecksum(pucBuf, PktLen, checksum); - /*TODO: (Python Script)Some Times Fails due to Bad Checksum*/ + /* TODO: (Python Script) Sometimes fails due to bad checksum */ if ((checksum[0] == pucBuf[PktLen - 2]) && (checksum[1] == pucBuf[PktLen - 1])) { - PktLen -= PKT_HEADER_FOOTER; + PktLen -= IVEC_ECU_UART_PKT_HEADER_FOOTER; } else { IVEC_ECU_LOG(LOG_STRING, "Packet Checksum Failed\n"); - PktLen = PACKET_FAIL; + PktLen = commonECU_READ_FAIL; } } else { - // COM_FlushBuffer(); - PktLen = PACKET_FAIL; + // COM_FlushBuffer(); + PktLen = IVEC_ECU_UART_PACKET_FAIL; } } EXIT: return PktLen; } -PacketRetCode_t xECU_ReadCANDataOverUART(EcuUartHandle_s* prvUartHandle, uint8_t* pucBuf, uint32_t* ulId) +IVEC_ECU_UartPacketRetCode_e IVEC_ECU_Uart_ReadCANDataOverUART(IVEC_ECU_UartHandle_s* prvUartHandle, uint8_t* pucBuf, uint32_t* ulId) { - PacketRetCode_t retCode = PACKET_FAIL; - retCode = xECU_ReadCANDataLenOverUART(prvUartHandle, pucBuf, ulId); + IVEC_ECU_UartPacketRetCode_e retCode = IVEC_ECU_UART_PACKET_FAIL; + retCode = IVEC_ECU_Uart_ReadCANDataLenOverUART(prvUartHandle, pucBuf, ulId); return retCode; } - -IVEC_EcuCommonErr_e xECU_UartWrite(EcuUartHandle_s* prvUartHandle, uint8_t* pucBuffer, uint16_t len) +IVEC_EcuCommonErr_e IVEC_ECU_Uart_Write(IVEC_ECU_UartHandle_s* prvUartHandle, uint8_t* pucBuffer, uint16_t len) { - IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_WRITE_FAIL; uint8_t l_i32Ret; if (prvUartHandle == NULL) @@ -282,10 +284,9 @@ IVEC_EcuCommonErr_e xECU_UartWrite(EcuUartHandle_s* prvUartHandle, uint8_t* pucB l_xFuncStatus = commonECU_INVALID_PARAM; } - l_i32Ret = xMCAL_UartWrite(&prvUartHandle->__xUartHandle, pucBuffer, len); - if (l_i32Ret == commonMCAL_SUCCESS) + if (l_i32Ret == IVEC_CORE_STATUS_SUCCESS) { l_xFuncStatus = commonECU_SUCCESS; } @@ -293,437 +294,25 @@ IVEC_EcuCommonErr_e xECU_UartWrite(EcuUartHandle_s* prvUartHandle, uint8_t* pucB return l_xFuncStatus; } - -PacketRetCode_t xECU_FormatUartPacket(EcuUartHandle_s* prvUartHandle, uint8_t* pucData, uint8_t ucDlc, uint32_t ulId) +IVEC_ECU_UartPacketRetCode_e IVEC_ECU_Uart_FormatPacket(IVEC_ECU_UartHandle_s* prvUartHandle, uint8_t* pucData, uint8_t ucDlc, uint32_t ulId) { - pucData[0] = 0xb5; //SYNC_CHAR[0]; - pucData[1] = 0x62; //SYNC_CHAR[1]; + pucData[0] = 0xb5; // SYNC_CHAR[0] + pucData[1] = 0x62; // SYNC_CHAR[1] pucData[2] = ucDlc; memcpy(&pucData[3], &ulId, sizeof(uint32_t)); unsigned char checksum[2] = { 0 }; - prvChecksumCalculate(pucData, (ucDlc + PKT_HEADER_FOOTER), checksum); - pucData[(ucDlc + PKT_HEADER_FOOTER) - 2] = checksum[0]; - pucData[(ucDlc + PKT_HEADER_FOOTER) - 1] = checksum[1]; - if (xECU_UartWrite(prvUartHandle, pucData, (ucDlc + PKT_HEADER_FOOTER)) != commonECU_SUCCESS) { - - return PACKET_FAIL; + IVEC_ECU_CalculateChecksum(pucData, (ucDlc + IVEC_ECU_UART_PKT_HEADER_FOOTER), checksum); + pucData[(ucDlc + IVEC_ECU_UART_PKT_HEADER_FOOTER) - 2] = checksum[0]; + pucData[(ucDlc + IVEC_ECU_UART_PKT_HEADER_FOOTER) - 1] = checksum[1]; + if (IVEC_ECU_Uart_Write(prvUartHandle, pucData, (ucDlc + IVEC_ECU_UART_PKT_HEADER_FOOTER)) != commonECU_SUCCESS) { + return IVEC_ECU_UART_PACKET_FAIL; } - return PACKET_SUCCESS; + return IVEC_ECU_UART_PACKET_SUCCESS; } -int vECU_InitiateUartToCanTransmit(EcuUartHandle_s* prvUartHandle, uint32_t id, uint8_t* pucData, uint8_t ucLen) +int IVEC_ECU_Uart_InitiateTransmit(IVEC_ECU_UartHandle_s* prvUartHandle, uint32_t id, uint8_t* pucData, uint8_t ucLen) { - uint8_t pucBuf[MAX_PACKET_LENGTH] = { 0 }; - memcpy(&pucBuf[PKT_HEADER], pucData, ucLen); - return (xECU_FormatUartPacket(prvUartHandle, pucBuf, ucLen, id) == PACKET_SUCCESS) ? 0 : -1; + uint8_t pucBuf[IVEC_ECU_UART_MAX_PACKET_LENGTH] = { 0 }; + memcpy(&pucBuf[IVEC_ECU_UART_PKT_HEADER], pucData, ucLen); + return (IVEC_ECU_Uart_FormatPacket(prvUartHandle, pucBuf, ucLen, id) == IVEC_ECU_UART_PACKET_SUCCESS) ? 0 : -1; } - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -//#include "../ivec_ECU/ivec_ecu_uart/inc/ivec_ecu_uart.h" -//#include "ivec_cmplx_queue.h" -//#include "../Core/Include/ivec_mcal_uart.h" -////#include <..\Core\Include\ivec_mcal_timer.h> -////#include "ivec_mcal_uart.h" -// -//#define LOG_STRING "ivec-ecu-UART" -//#define CAN_UART_BUFFER_MAX_SIZE 4096 -//#define DATA_PACKET_TIMEOUT 300 -// -//CmplxFifoQueueHandle_s __gprv_MyEcuUARTResponseQueue = { 0 }; -// -//static uint8_t __gprv_u8CANUartDataBuffer[CAN_UART_BUFFER_MAX_SIZE]; -//static uint32_t __gprv_u32CanUartDataAvailable = 0; -// -//int uartCount = 1; -// -// -//static void __prv_vEcu_CANOverUartMsgCallback(IVEC_McalUartEvents_e eIndType, char* pucBuffer, uint32_t u32Size) -//{ -// if(eIndType == IVEC_MCAL_UART_EVENT_RX_ARRIVED){ -// if( u8CMPLX_FifoEnqueue(&__gprv_MyEcuUARTResponseQueue, pucBuffer, u32Size) ) -// __gprv_u32CanUartDataAvailable += u32Size; -// } -//} -// -//static void prvChecksumCalculate(uint8_t* pkt, int len, uint8_t *ck) { -// uint8_t mck_a = 0, mck_b = 0; -// /*Incremented to ignore Sync data*/ -// for (int i = 2; i < len - 2; i++) { -// mck_a += pkt[i]; -// mck_b += mck_a; -// } -// mck_a &= 0xFF; -// mck_b &= 0xFF; -// ck[0] = mck_a; -// ck[1] = mck_b; -//} -// -// -//IVEC_EcuCommonErr_e xECU_UARTInit(McalUartHandle_s* prvUartHandle, uint32_t speed) -//{ -// IVEC_ECU_FUNC_ENTRY(LOG_STRING); -// IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; -// uint8_t l_i32Ret; -// -// IVEC_ECU_LOG(LOG_STRING, "UART Initilising Queue"); -// __gprv_MyEcuUARTResponseQueue.i32ElementSize = sizeof(uint8_t); -// __gprv_MyEcuUARTResponseQueue.i32TotalElements = CAN_UART_BUFFER_MAX_SIZE; -// __gprv_MyEcuUARTResponseQueue.pu8Buffer = (uint8_t*)__gprv_u8CANUartDataBuffer; -// __gprv_MyEcuUARTResponseQueue.i32QueueType = FIXED_ELEMENT_SIZE_QUEUE; -// l_i32Ret = u8CMPLX_FifoQueueInit(&__gprv_MyEcuUARTResponseQueue); -// if (l_i32Ret == 0) -// { -// l_xFuncStatus = commonECU_FAIL; -// goto exit; -// } -// -// IVEC_ECU_LOG(LOG_STRING, "Initilising UART"); -// #if (UART_PIN_SELECTION == 1) -// prvUartHandle->eUartPortNumber = mcalUART_PORT3; -// -// #elif (UART_PIN_SELECTION == 2 ) -// prvUartHandle->eUartPortNumber = mcalUART_PORT2; -// #elif (UART_PIN_SELECTION == 3) -// if(uartCount == 1) -// { -// prvUartHandle->eUartPortNumber = mcalUART_PORT2; -// uartCount = 2; -// } -// else -// { -// prvUartHandle->eUartPortNumber = mcalUART_PORT3; -// uartCount = 1; -// } -// -// -// #endif -// -// prvUartHandle->pvUartRecvCallback = __prv_vEcu_CANOverUartMsgCallback; -// prvUartHandle->xUartConfig.eUartBaudrate = speed; -// prvUartHandle->xUartConfig.eUartFlowCtrl = mcalUART_FC_NONE; -// prvUartHandle->xUartConfig.eUartDataBit = mcalUART_DATABIT_8; -// prvUartHandle->xUartConfig.eUartStopBit = mcalUART_STOP_1; -// prvUartHandle->xUartConfig.eUartParityBit = mcalUART_PARITY_NONE; -// l_i32Ret = xMCAL_UartInit(prvUartHandle); -// -// -// if (l_i32Ret != 0) -// { -// l_xFuncStatus = commonECU_INIT_FAIL; -// goto exit; -// } -// -// -// exit: -// IVEC_ECU_FUNC_EXIT(LOG_STRING, 0); -// return l_xFuncStatus; -// -//} -// -// -//IVEC_EcuCommonErr_e xECU_UARTDeInit(McalUartHandle_s* prvUartHandle) -//{ -// IVEC_ECU_FUNC_ENTRY(LOG_STRING); -// uint8_t l_i32Ret; -// IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; -// if (prvUartHandle == NULL) -// { -// l_xFuncStatus = commonECU_ALREADY_DEINIT; -// goto exit; -// } -// IVEC_ECU_LOG(LOG_STRING, "DeInitilising CAN"); -// l_i32Ret = xMCAL_UartDeInit(prvUartHandle); -// if (l_i32Ret != 0) -// { -// l_xFuncStatus = commonECU_DEINIT_FAIL; -// goto exit; -// } -// memset((CmplxFifoQueueHandle_s*)&__gprv_MyEcuUARTResponseQueue, 0, sizeof(__gprv_MyEcuUARTResponseQueue)); -// exit: -// IVEC_ECU_FUNC_EXIT(LOG_STRING, 0); -// return l_xFuncStatus; -//} -// -// -//IVEC_EcuCommonErr_e xECU_UARTReInit(McalUartHandle_s *prvUartHandle, uint32_t speed) -//{ -// IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; -// uint8_t l_i32Ret; -// l_i32Ret = xECU_UARTDeInit(prvUartHandle); -// if(l_i32Ret != IVEC_MCAL_STATUS_SUCCESS) -// { -// l_xFuncStatus = commonECU_DEINIT_FAIL; -// } -// -// l_i32Ret = xECU_UARTInit(prvUartHandle, speed); -// -// if(l_i32Ret != IVEC_MCAL_STATUS_SUCCESS) -// { -// l_xFuncStatus = commonECU_INIT_FAIL; -// } -// return l_xFuncStatus; -//} -// -// -// -//IVEC_EcuCommonErr_e xECU_UARTTransmit(McalUartHandle_s *prvUartHandle, uint8_t* pucBuffer, uint16_t len) -//{ -// return commonECU_SUCCESS; -//} -// -// -//IVEC_EcuCommonErr_e xECU_UARTGetData(McalUartHandle_s *prvUartHandle, uint8_t* pucBuffer, uint16_t len, uint16_t timeout) -//{ -// IVEC_ECU_FUNC_ENTRY(LOG_STRING); -// -// IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_SUCCESS; -// if (prvUartHandle == NULL) -// { -// l_xFuncStatus = commonECU_INVALID_PARAM; -// goto exit; -// } -// -// uint8_t ijk = 0; -// int l_u32Len = 0; -// uint32_t u32CommTimestamp = i32MCAL_getTicks(); -// -// while(((i32MCAL_getTicks()-u32CommTimestamp) <= timeout+1) && (ijk < len)) -// { -// -// if(!u8CMPLX_FifoQueueEmpty(&__gprv_MyEcuUARTResponseQueue)){ -// if( u8CMPLX_FifoDequeue(&__gprv_MyEcuUARTResponseQueue, &pucBuffer[ijk], &l_u32Len, 0) == 1 ) -// ijk++; -// } -// } -// -// if (ijk != len) -// { -// l_xFuncStatus = commonECU_READ_FAIL; -// goto exit; -// } -// -// exit: -// IVEC_ECU_FUNC_EXIT(LOG_STRING, 0); -// return l_xFuncStatus; -//} -// -// -// -//PacketRetCode_t xECU_ReadCANDataLenOverUART(McalUartHandle_s *prvUartHandle, uint8_t* pucBuf, uint32_t *ulId) -//{ -// int PktLen = PACKET_FAIL; -// if ((xECU_UARTGetData(prvUartHandle, (uint8_t*) &pucBuf[0], 1, 0) == commonECU_SUCCESS)) -// { -// if (pucBuf[0] == 0xB5) -// { -// if (xECU_UARTGetData(prvUartHandle, (uint8_t*) &pucBuf[1], 1, 5) == commonECU_SUCCESS){ -// if (pucBuf[1] != 0x62){ -// PktLen = PACKET_FAIL; -// goto EXIT; //0x62 not found [OUT OF SYNC] -// } -// } -// else -// { -// PktLen = PACKET_FAIL; -// goto EXIT; -// } -// if (xECU_UARTGetData(prvUartHandle, (uint8_t*) &pucBuf[2], 5, DATA_PACKET_TIMEOUT) != commonECU_SUCCESS){ -// PktLen = PACKET_FAIL; -// goto EXIT; -// } -// -// *(ulId) = (uint32_t)((pucBuf[6] << 24) | (pucBuf[5] << 16) | (pucBuf[4] << 8) | (pucBuf[3] << 0)); -// uint8_t l_ucTempLen = pucBuf[2]; -// PktLen = PKT_HEADER_FOOTER + l_ucTempLen; -// if (xECU_UARTGetData(prvUartHandle, (uint8_t*) &pucBuf[PKT_HEADER], (uint32_t)(PktLen - PKT_HEADER), DATA_PACKET_TIMEOUT) != commonECU_SUCCESS) -// { -// PktLen = PACKET_FAIL; -// goto EXIT; -// } -// uint8_t checksum[2]; -// prvChecksumCalculate(pucBuf, PktLen, checksum); -// -// /*TODO: (Python Script)Some Times Fails due to Bad Checksum*/ -// if ((checksum[0] == pucBuf[PktLen - 2]) && (checksum[1] == pucBuf[PktLen - 1])) { -// PktLen -= PKT_HEADER_FOOTER; -// } else -// { -// IVEC_ECU_LOG(LOG_STRING, "Packet Checksum Failed\n"); -// PktLen = PACKET_FAIL; -// } -// } else -// { -//// COM_FlushBuffer(); -// PktLen = PACKET_FAIL; -// } -// } -//EXIT: -// return PktLen; -//} -// -//PacketRetCode_t xECU_ReadCANDataOverUART(McalUartHandle_s* prvUartHandle ,uint8_t* pucBuf, uint32_t *ulId) -//{ -// PacketRetCode_t retCode = PACKET_FAIL; -// retCode = xECU_ReadCANDataLenOverUART(prvUartHandle, pucBuf, ulId); -// return retCode; -//} -// -// -//IVEC_EcuCommonErr_e xECU_UartWrite(McalUartHandle_s* prvUartHandle, uint8_t* pucBuffer, uint16_t len) -//{ -// -// IVEC_EcuCommonErr_e l_xFuncStatus = commonECU_WRITE_FAIL; -// uint8_t l_i32Ret; -// if (prvUartHandle == NULL) -// { -// l_xFuncStatus = commonECU_INVALID_PARAM; -// } -// -// -// l_i32Ret = xMCAL_UartWrite(prvUartHandle, pucBuffer, len); -// -// if(l_i32Ret == commonMCAL_SUCCESS) -// { -// l_xFuncStatus = commonECU_SUCCESS; -// } -// -// return l_xFuncStatus; -//} -// -// -//PacketRetCode_t xECU_FormatUartPacket(McalUartHandle_s* prvUartHandle, uint8_t* pucData, uint8_t ucDlc, uint32_t ulId) -//{ -// pucData[0] = 0xb5; //SYNC_CHAR[0]; -// pucData[1] = 0x62; //SYNC_CHAR[1]; -// pucData[2] = ucDlc; -// memcpy(&pucData[3], &ulId, sizeof(uint32_t)); -// unsigned char checksum[2] = { 0 }; -// prvChecksumCalculate(pucData, (ucDlc+PKT_HEADER_FOOTER), checksum); -// pucData[(ucDlc + PKT_HEADER_FOOTER) - 2] = checksum[0]; -// pucData[(ucDlc + PKT_HEADER_FOOTER) - 1] = checksum[1]; -// if (xECU_UartWrite(prvUartHandle, pucData, (ucDlc + PKT_HEADER_FOOTER)) != commonECU_SUCCESS) { -// -// return PACKET_FAIL; -// } -// return PACKET_SUCCESS; -//} -// -//int vECU_InitiateUartToCanTransmit(McalUartHandle_s* prvUartHandle, uint32_t id, uint8_t *pucData, uint8_t ucLen) -//{ -// uint8_t pucBuf[MAX_PACKET_LENGTH] = {0}; -// memcpy(&pucBuf[PKT_HEADER], pucData, ucLen); -// return ( xECU_FormatUartPacket(prvUartHandle, pucBuf, ucLen, id) == PACKET_SUCCESS ) ? 0 : -1; -//} diff --git a/ivec_RTE/inc/ivec_rte.h b/ivec_RTE/inc/ivec_rte.h index a2784ba..b9aeaaf 100644 --- a/ivec_RTE/inc/ivec_rte.h +++ b/ivec_RTE/inc/ivec_rte.h @@ -12,13 +12,13 @@ #include "stdint.h" #include "ti_msp_dl_config.h" - +// Function Declarations void vRTE_MatlabInit(void); void vRTE_MatlabRun(void); -void vApp_Init(void); -void vApp_RunInit(void); -void vRTE_InitUARTCANEcho(void); -void vRTE_UARTDataProcess(void); -void vRTE_CANDataProcess(void); +void vRTE_AppInit(void); +void vRTE_AppRunInit(void); +void vRTE_InitUartCanEcho(void); +void vRTE_ProcessUartData(void); +void vRTE_ProcessCanData(void); #endif /* IVEC_RTE_INC_IVEC_RTE_H_ */ diff --git a/ivec_RTE/src/ivec_rte.c b/ivec_RTE/src/ivec_rte.c index d7d8594..3e7318c 100644 --- a/ivec_RTE/src/ivec_rte.c +++ b/ivec_RTE/src/ivec_rte.c @@ -14,115 +14,53 @@ #include "../../TM1650_SDK/inc/ivec_TM1650.h" -EcuUartHandle_s g_xUartHandle; -EcuUartHandle_s g_xUart2Handle; +#include "ivec_rte.h" -// UART_PIN_SELECTION values: -// 1 - Basil Battery Smart -// 2 - Basil -#define CONFIG_BASIL_BATTERY_SMART 1 -#define CONFIG_BASIL 2 +// UART Handles +IVEC_ECU_UartHandle_s g_xEcuUartHandle; +IVEC_ECU_UartHandle_s g_xEcuUart2Handle; -#define UART_PIN_SELECTION CONFIG_BASIL // Set the desired UART configuration here +// Configuration Macros +#define ivECU_CONFIG_BASIL_BATTERY_SMART 1 +#define ivECU_CONFIG_BASIL 2 +// UART Configuration +#define ivECU_UART_PIN_SELECTION ivECU_CONFIG_BASIL_BATTERY_SMART + +// Global Variables uint32_t g_u32UartSpeed = 0; -xCAN_baud_t g_u16CanSpeed = 0; -uint8_t g_pu8Buf[MAX_PACKET_LENGTH] = {0}; -volatile uint32_t g_u32CanId = 0x1fffffff; -#define CAN_UART_BUFFER_MAX_SIZE 4096 -volatile uint8_t __gprv_u8CANUartDataBuffer[CAN_UART_BUFFER_MAX_SIZE]; +IVEC_CanBaud_e g_eCanSpeed = 0; +uint8_t g_pu8UartBuffer[IVEC_ECU_UART_MAX_PACKET_LENGTH] = {0}; +volatile uint32_t g_u32CanId = 0x1FFFFFFF; -#define MAX_FILTERS 10 -uint32_t maskValues[MAX_FILTERS]; -uint32_t filterValues[MAX_FILTERS]; -bool isExtendedID[MAX_FILTERS]; +// CAN UART Buffer +#define ivECU_CAN_UART_BUFFER_MAX_SIZE 4096 +volatile uint8_t g_prvU8CanUartDataBuffer[ivECU_CAN_UART_BUFFER_MAX_SIZE]; -int maskCount = -1; -// Buffers to store parsed data - int filterCount = -1; -uint16_t extendedFilter = 0; -uint16_t standardFilter = 0; +// CAN Filters +#define ivECU_MAX_FILTERS 10 +uint32_t g_u32MaskValues[ivECU_MAX_FILTERS]; +uint32_t g_u32FilterValues[ivECU_MAX_FILTERS]; +bool g_bIsExtendedId[ivECU_MAX_FILTERS]; +// Filter Counters +int32_t g_i32MaskCount = -1; +int32_t g_i32FilterCount = -1; -static uint8_t __gprv_u8Idx = 0; -static uint8_t __gprv_u8Buf = 0; +// Filter Information +uint16_t g_u16ExtendedFilter = 0; +uint16_t g_u16StandardFilter = 0; +// Private Static Variables +static uint8_t _prvU8Index = 0; + +// External Variables extern ExtU_socTouchDisplay_T socTouchDisplay_U; extern ExtY_socTouchDisplay_T socTouchDisplay_Y; -extern volatile bool b_MCAN_InitFlag; /*!< CAN initialization flag */ - -//DL_MCAN_StdMsgIDFilterElement stdFilterElement; -#define MCAN_FILTER_SIZE 0u - -// New configuration instance to override filter settings dynamically -static DL_MCAN_ConfigParams gMCAN0ConfigParamsFiltered = { - .monEnable = false, - .asmEnable = false, - .tsPrescalar = 15, - .tsSelect = 0, - .timeoutSelect = DL_MCAN_TIMEOUT_SELECT_CONT, - .timeoutPreload = 65535, - .timeoutCntEnable = false, - // Dynamic filter settings based on need - .filterConfig.rrfs = false, - .filterConfig.rrfe = false, - .filterConfig.anfe = 3, // Accept extended ID filter elements - .filterConfig.anfs = 3, // Accept standard ID filter elements -}; - -// Adjust MsgRAMConfigParams as necessary for filter list sizes - -static DL_MCAN_MsgRAMConfigParams gMCAN0MsgRAMConfigParamsFiltered ={ - - /* Standard ID Filter List Start Address. */ - .flssa = 1, - /* List Size: Standard ID. */ - .lss = MCAN_FILTER_SIZE, - /* Extended ID Filter List Start Address. */ - .flesa = 48 , - /* List Size: Extended ID. */ - .lse = 0, - /* Tx Buffers Start Address. */ - .txStartAddr = 10 , - /* Number of Dedicated Transmit Buffers. */ - .txBufNum = 10 , - .txFIFOSize = 10, - /* Tx Buffer Element Size. */ - .txBufMode = 0, - .txBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, - /* Tx Event FIFO Start Address. */ - .txEventFIFOStartAddr = 640 , - /* Event FIFO Size. */ - .txEventFIFOSize = 10 , - /* Level for Tx Event FIFO watermark interrupt. */ - .txEventFIFOWaterMark = 0, - /* Rx FIFO0 Start Address. */ - .rxFIFO0startAddr = 170 , - /* Number of Rx FIFO elements. */ - .rxFIFO0size = 10 , - /* Rx FIFO0 Watermark. */ - .rxFIFO0waterMark = 0, - .rxFIFO0OpMode = 0, - /* Rx FIFO1 Start Address. */ - .rxFIFO1startAddr = 190 , - /* Number of Rx FIFO elements. */ - .rxFIFO1size = 10 , - /* Level for Rx FIFO 1 watermark interrupt. */ - .rxFIFO1waterMark = 10, - /* FIFO blocking mode. */ - .rxFIFO1OpMode = 0, - /* Rx Buffer Start Address. */ - .rxBufStartAddr = 208 , - /* Rx Buffer Element Size. */ - .rxBufElemSize = DL_MCAN_ELEM_SIZE_8BYTES, - /* Rx FIFO0 Element Size. */ - .rxFIFO0ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, - /* Rx FIFO1 Element Size. */ - .rxFIFO1ElemSize = DL_MCAN_ELEM_SIZE_8BYTES, -}; - - +extern volatile bool g_bMcalMcanInitFlag; /*!< CAN initialization flag */ +// CAN Filter Size +#define ivECU_MCAN_FILTER_SIZE 0U /** * @brief Function to use SDA pin of TM1650 @@ -130,12 +68,13 @@ static DL_MCAN_MsgRAMConfigParams gMCAN0MsgRAMConfigParamsFiltered ={ * @param state the value to write on SDA pin (0 or 1) * @returns none */ -void mcu_tempDataPin(uint8_t state) + +void vRTE_SetMcuTempDataPin(uint8_t u8State) { - if(state == 0){ + if(u8State == 0){ vMCAL_gpioWrite(TM1650_PORT, TM1650_SDA_PIN_PIN, 0); } - else if(state == 1){ + else if(u8State == 1){ vMCAL_gpioWrite(TM1650_PORT, TM1650_SDA_PIN_PIN, 1); } } @@ -146,11 +85,12 @@ void mcu_tempDataPin(uint8_t state) * @param state the value to write on SDA pin (0 or 1) * @returns none */ -void mcu_tempClkPin(uint8_t state){ - if(state == 0){ +void vRTE_McuSetTempClkPin(uint8_t u8State) +{ + if(u8State == 0){ vMCAL_gpioWrite(TM1650_PORT, TM1650_SCL_PIN_PIN, 0); } - else if(state == 1){ + else if(u8State == 1){ vMCAL_gpioWrite(TM1650_PORT, TM1650_SCL_PIN_PIN, 1); } } @@ -161,19 +101,19 @@ void mcu_tempClkPin(uint8_t state){ * @param none * @returns Value of GPIO (0 or 1) */ -uint8_t mcu_tempDataReadPin(void){ - uint8_t readBuff = 0; +static uint8_t _prvRteReadMcuTempPin(void) { + uint8_t l_u8ReadBuffer = 0; vMCAL_set_gpioDirection(TM1650_SDA_PIN_IOMUX,false); - readBuff = u32MCAL_gpioRead(TM1650_PORT, TM1650_SDA_PIN_PIN); + l_u8ReadBuffer = u32MCAL_gpioRead(TM1650_PORT, TM1650_SDA_PIN_PIN); vMCAL_set_gpioDirection(TM1650_SDA_PIN_IOMUX,true); - return readBuff; + return l_u8ReadBuffer; } void vRTE_MatlabInit(void) { u8MCAL_gpioInit(); - tm1650_Init(TM_1650_BRIGHT_8, TM_1650_Segment_8, TM_1650_Normal_Mode, TM_1650_Screen_ON, TM_1650_DIG_3, (void*)&mcu_tempDataPin , (void*)&mcu_tempClkPin , &mcu_tempDataReadPin); + tm1650_Init(TM_1650_BRIGHT_8, TM_1650_Segment_8, TM_1650_Normal_Mode, TM_1650_Screen_ON, TM_1650_DIG_3, (void*)&vRTE_SetMcuTempDataPin , (void*)&vRTE_McuSetTempClkPin , &_prvRteReadMcuTempPin); tm1650_displaySwitch(TM_1650_Screen_OFF); vMCAL_DelayTicks(500); tm1650_showDot(TM_1650_DIG_1,false); @@ -192,7 +132,7 @@ void vRTE_MatlabRun(void) socTouchDisplay_step(); memset(&socTouchDisplay_U.Input[0], 0, sizeof(CAN_MESSAGE_BUS)*MAX_CAN_MESSAGE_INSTANCE); - __gprv_u8Idx = 0; + _prvU8Index = 0; if( socTouchDisplay_Y.op_bDisplayStatus ) { @@ -238,279 +178,159 @@ void vRTE_MatlabRun(void) } } -void vApp_Init(void) +void vRTE_AppInit(void) { - #if UART_PIN_SELECTION == 1 + #if ivECU_UART_PIN_SELECTION == 1 vRTE_MatlabInit(); #endif - vRTE_InitUARTCANEcho(); + vRTE_InitUartCanEcho(); } -void vRTE_InitUARTCANEcho(void) +void vRTE_InitUartCanEcho(void) { - g_u32UartSpeed = mcalUART_BAUD_115200; - g_u16CanSpeed = BAUD_500; - g_xUartHandle.u8Qbuffer = __gprv_u8CANUartDataBuffer; - g_xUartHandle.u16QbufSize = CAN_UART_BUFFER_MAX_SIZE; + g_u32UartSpeed = eMcalUartBaud115200; + g_eCanSpeed = IVEC_CAN_BAUD_500; + g_xEcuUartHandle.u8Qbuffer = g_prvU8CanUartDataBuffer; + g_xEcuUartHandle.u16QbufSize = ivECU_CAN_UART_BUFFER_MAX_SIZE; - #if (UART_PIN_SELECTION == 1) - g_xUartHandle.eUartPortNumber = ecuUART_PORT3; - #elif (UART_PIN_SELECTION == 2) - g_xUartHandle.eUartPortNumber = ecuUART_PORT2; + #if (ivECU_UART_PIN_SELECTION == 1) + g_xEcuUartHandle.eUartPortNumber = IVEC_ECU_UART_PORT3; + #elif (ivECU_UART_PIN_SELECTION == 2) + g_xEcuUartHandle.eUartPortNumber = IVEC_ECU_UART_PORT2; #endif - xECU_UARTInit(&g_xUartHandle, g_u32UartSpeed); + IVEC_ECU_Uart_Init(&g_xEcuUartHandle, g_u32UartSpeed); - -// #if UART_PIN_SELECTION == 3 -// xECU_UARTInit(&g_xUart2Handle, g_u32UartSpeed); -// #endif - - xECU_CANInit(CANFD0,g_u16CanSpeed); + vECU_CAN_Init(CANFD0,g_eCanSpeed); } -void vApp_RunInit(void) +void vRTE_AppRunInit(void) { - vRTE_UARTDataProcess(); - vRTE_CANDataProcess(); + vRTE_ProcessUartData(); + vRTE_ProcessCanData(); } void vMCAL_TimerCallback(void) { - #if UART_PIN_SELECTION == 1 + #if ivECU_CONFIG_BASIL_BATTERY_SMART == 1 vRTE_MatlabRun(); #endif DL_TimerA_clearInterruptStatus(TIMER_1_INST, GPTIMER_CPU_INT_IMASK_Z_SET); } -void vCanFilterMaskSaveVal(uint8_t ucIdx, uint32_t mask, bool isExtended) +void vRTE_CanFilterMaskSaveVal(uint8_t u8Idx, uint32_t u32Mask, bool bIsExtended) { - maskCount = ucIdx; - maskValues[maskCount] = mask; + g_i32MaskCount = u8Idx; + g_u32MaskValues[g_i32MaskCount] = u32Mask; } - -void vCanFilterSaveVal(uint8_t ucIdx, uint32_t Filter, bool isExtended) +void vRTE_CanFilterSaveVal(uint8_t u8Idx, uint32_t u32Filter, bool bIsExtended) { - filterCount = ucIdx; + g_i32FilterCount = u8Idx; // Store filter value - filterValues[filterCount] = Filter; + g_u32FilterValues[g_i32FilterCount] = u32Filter; } - -void vCanFilterReset() { - uint32_t i; - - - DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_SW_INIT); - - // Reset all standard ID filters - for (i = 0; i < MAX_FILTERS; i++) { - DL_MCAN_StdMsgIDFilterElement stdFilterElement = {0}; - stdFilterElement.sfec = 001; // Disable filter element - stdFilterElement.sft = 11; // Disable filter type - DL_MCAN_addStdMsgIDFilter(CANFD0, i, &stdFilterElement); - } - - // Reset all extended ID filters - for (i = 0; i < MAX_FILTERS; i++) { - DL_MCAN_ExtMsgIDFilterElement extFilterElement = {0}; - extFilterElement.efec = 000; // Disable filter element - extFilterElement.eft = 11; // Disable filter type - DL_MCAN_addExtMsgIDFilter(CANFD0, i, &extFilterElement); - } - - /* Set Extended ID Mask. */ - DL_MCAN_setExtIDAndMask(CANFD0, (0x1FFFFFFFU)); - /* Take MCAN out of the SW initialization mode */ - DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); - - -} - -// Function to configure CAN filters -void vCanConfigFilter() { - - //xECU_CanReInit(CANFD0,g_u16CanSpeed); - - DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_SW_INIT); - - for (int i = 0; i <= maskCount; i++) - { - if((filterValues[i] > 0x7FF) || (maskValues[i] > 0x7FF)) - { - isExtendedID[i] = 1; - extendedFilter++; - } - else - { - isExtendedID[i] = 0; - standardFilter++; - } - } - - gMCAN0MsgRAMConfigParamsFiltered.lse = extendedFilter; //0; // Set dynamically based on actual filters - gMCAN0MsgRAMConfigParamsFiltered.lss = standardFilter; //1; // Set dynamically based on actual filters - DL_MCAN_config(CANFD0, (DL_MCAN_ConfigParams*) &gMCAN0ConfigParamsFiltered); - DL_MCAN_msgRAMConfig(CANFD0, (DL_MCAN_MsgRAMConfigParams*) &gMCAN0MsgRAMConfigParamsFiltered); - - uint8_t extendedFilterNumber = 0; - uint8_t stadardFilterNumber = 0; - - for (int i = 0; i <= maskCount; i++) { - if (isExtendedID[i]) { - // Extended ID filter - DL_MCAN_ExtMsgIDFilterElement extFilterElement; - extFilterElement.efid1 = filterValues[i]; - extFilterElement.efid2 = maskValues[i]; - extFilterElement.efec = 001; - extFilterElement.eft = 10; - DL_MCAN_addExtMsgIDFilter(CANFD0, extendedFilterNumber, &extFilterElement); -// filterValues[i] = 0; -// maskValues[i] = 0; - extendedFilterNumber++; - - } - else { - // Standard ID filter - DL_MCAN_StdMsgIDFilterElement stdFilterElement; - stdFilterElement.sfid1 = filterValues[i]; - stdFilterElement.sfid2 = maskValues[i]; - stdFilterElement.sfec = 001; - stdFilterElement.sft = 10; - DL_MCAN_addStdMsgIDFilter(CANFD0, stadardFilterNumber, &stdFilterElement); -// filterValues[i] = 0; -// maskValues[i] = 0; - stadardFilterNumber++; - - } - } - - /* Set Extended ID Mask. */ - DL_MCAN_setExtIDAndMask(CANFD0, (0x1FFFFFFFU)); - /* Take MCAN out of the SW initialization mode */ - DL_MCAN_setOpMode(CANFD0, DL_MCAN_OPERATION_MODE_NORMAL); - - - // Reset counters after applying filters -// maskCount = 0; -// filterCount = 0; - extendedFilter = 0; - standardFilter = 0; - -} - -void vRTE_UARTDataProcess(void) +void vRTE_ProcessUartData(void) { - PacketRetCode_t retCode = PACKET_FAIL; - uint32_t ulId = 0x1fffffff; + IVEC_ECU_UartPacketRetCode_e eRetCode = IVEC_ECU_UART_PACKET_FAIL; + uint32_t l_u32Id = 0x1fffffff; - retCode= xECU_ReadCANDataOverUART(&g_xUartHandle,g_pu8Buf,&ulId); - ulId &= 0x1fffffff; - if(retCode > -1) + eRetCode= IVEC_ECU_Uart_ReadCANDataOverUART(&g_xEcuUartHandle,g_pu8UartBuffer,&l_u32Id); + l_u32Id &= 0x1fffffff; + if(eRetCode > -1) { - if(retCode > 0 && ulId == 0x00) + if(eRetCode > 0 && l_u32Id == 0x00) { - uint32_t baudrate = 0; - uint8_t mode = g_pu8Buf[PKT_HEADER]; - memcpy(&baudrate, &g_pu8Buf[PKT_HEADER+1], (uint32_t)retCode); - vECU_InitiateUartToCanTransmit(&g_xUartHandle, 0x01, g_pu8Buf, 0); - if( mode == 0 ) + uint32_t l_u32Baudrate = 0; + uint8_t l_u8Mode = g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER]; + memcpy(&l_u32Baudrate, &g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER+1], (uint32_t)eRetCode); + IVEC_ECU_Uart_InitiateTransmit(&g_xEcuUartHandle, 0x01, g_pu8UartBuffer, 0); + if( l_u8Mode == 0 ) { - g_u32UartSpeed = baudrate; - xECU_UARTReInit(&g_xUartHandle, g_u32UartSpeed); + g_u32UartSpeed = l_u32Baudrate; + IVEC_ECU_Uart_Reinit(&g_xEcuUartHandle, g_u32UartSpeed); } - else if( mode == 1 ) + else if( l_u8Mode == 1 ) { - g_u16CanSpeed = (uint16_t)baudrate; - xECU_CanReInit(CANFD0, g_u16CanSpeed); + g_eCanSpeed = (uint16_t)l_u32Baudrate; + vECU_CAN_ReInit(CANFD0, g_eCanSpeed); } - else if( mode == 2 ) + else if( l_u8Mode == 2 ) { - if( g_pu8Buf[PKT_HEADER+1] != 0 ){//22(20+2) rx filter available send each id in a frame + if( g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER+1] != 0 ){//22(20+2) rx filter available send each id in a frame uint32_t filterId = 0; - memcpy(&filterId, &g_pu8Buf[PKT_HEADER+3], sizeof(uint32_t)); + memcpy(&filterId, &g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER+3], sizeof(uint32_t)); bool isExtended = 0; isExtended = (filterId > 0x7FF); // Standard IDs are <= 0x7FF - vCanFilterSaveVal((g_pu8Buf[PKT_HEADER+1] - 1), filterId, isExtended); - if( g_pu8Buf[PKT_HEADER+2] )//All filter received. Trigger Filter Settings + vRTE_CanFilterSaveVal((g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER+1] - 1), filterId, isExtended); + if( g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER+2] )//All filter received. Trigger Filter Settings { - //vCanFilterReset(); - xECU_CanReInit(CANFD0,g_u16CanSpeed); - - //vCanConfigFilter(); + vECU_CAN_ReInit(CANFD0,g_eCanSpeed); } else return; } else{ - -// memset(maskValues, 0, sizeof(maskValues)); -// memset(vCanFilterReset, 0, sizeof(vCanFilterReset)); - - //vCanFilterReset(); - xECU_CanReInit(CANFD0,g_u16CanSpeed); - //maskCount = -1; - - //vCanConfigFilter(); + vECU_CAN_ReInit(CANFD0,g_eCanSpeed); } } - else if ( mode == 3 ) + else if ( l_u8Mode == 3 ) { - if( (g_pu8Buf[PKT_HEADER+1] < 1) || (g_pu8Buf[PKT_HEADER+1] > 8) )//0-7 maximum received pkts + if( (g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER+1] < 1) || (g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER+1] > 8) )//0-7 maximum received pkts return; uint32_t maskId = 0; - memcpy(&maskId, &g_pu8Buf[PKT_HEADER+3], sizeof(uint32_t)); + memcpy(&maskId, &g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER+3], sizeof(uint32_t)); bool isExtended = 0; isExtended = (maskId > 0x7FF); // Standard IDs are <= 0x7FF - vCanFilterMaskSaveVal((g_pu8Buf[PKT_HEADER+1] - 1), maskId, isExtended); + vRTE_CanFilterMaskSaveVal((g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER+1] - 1), maskId, isExtended); } - else if (mode == 100) + else if (l_u8Mode == 100) { - g_u32CanId = baudrate; + g_u32CanId = l_u32Baudrate; return; } vMCAL_DelayTicks(100); - vECU_InitiateUartToCanTransmit(&g_xUartHandle, 0x01, g_pu8Buf, 0); + IVEC_ECU_Uart_InitiateTransmit(&g_xEcuUartHandle, 0x01, g_pu8UartBuffer, 0); } - if ( retCode == 0 && ulId == 0){ - vECU_InitiateUartToCanTransmit(&g_xUartHandle, 0x0, g_pu8Buf, 0); //interface okay response + if ( eRetCode == 0 && l_u32Id == 0){ + IVEC_ECU_Uart_InitiateTransmit(&g_xEcuUartHandle, 0x0, g_pu8UartBuffer, 0); //interface okay response } - if ( retCode >= 0 && (ulId > 0x00 && ulId < 0xffffffff) ) + if ( eRetCode >= 0 && (l_u32Id > 0x00 && l_u32Id < 0xffffffff) ) { - //__gprv_u8Buf = (__gprv_u8Buf + 1) % 2; - xECU_WriteDataOverCAN(&g_pu8Buf[PKT_HEADER], ulId, retCode, 0); + //_prvU8Buffer = (_prvU8Buffer + 1) % 2; + vECU_WriteDataOverCAN(&g_pu8UartBuffer[IVEC_ECU_UART_PKT_HEADER], l_u32Id, eRetCode, 0); } } } -void vRTE_CANDataProcess(void) +void vRTE_ProcessCanData(void) { - can_buff_t xBuff = { 0x00 }; + IVEC_ECU_CANBuff_s l_xCanBuff = { 0x00 }; volatile uint8_t l_u8TxBurstMessages = 0; - while( xECU_CANGetData(&xBuff) == commonECU_SUCCESS ) + while( vECU_CAN_GetData(&l_xCanBuff) == commonECU_SUCCESS ) { - if( (xBuff.id == 0x16) && (xBuff.data[0] = 'V') && \ - (xBuff.data[1] == 'E') && (xBuff.data[2] == 'C')) + if( (l_xCanBuff.ulId == 0x16) && (l_xCanBuff.ucData[0] = 'V') && \ + (l_xCanBuff.ucData[1] == 'E') && (l_xCanBuff.ucData[2] == 'C')) { - xMCAL_SoftReset(); + xMCAL_VrefInit(); } - vECU_InitiateUartToCanTransmit(&g_xUartHandle, (uint32_t)xBuff.id, (uint8_t*)&xBuff.data[0], (uint8_t)xBuff.length); - socTouchDisplay_U.Input[__gprv_u8Idx].ID = xBuff.id; - socTouchDisplay_U.Input[__gprv_u8Idx].Length = xBuff.length; - memcpy(&socTouchDisplay_U.Input[__gprv_u8Idx].Data[0], &xBuff.data[0], 8); - __gprv_u8Idx = (__gprv_u8Idx + 1) % MAX_CAN_MESSAGE_INSTANCE; + IVEC_ECU_Uart_InitiateTransmit(&g_xEcuUartHandle, (uint32_t)l_xCanBuff.ulId, (uint8_t*)&l_xCanBuff.ucData[0], (uint8_t)l_xCanBuff.ucLength); + socTouchDisplay_U.Input[_prvU8Index].ID = l_xCanBuff.ulId; + socTouchDisplay_U.Input[_prvU8Index].Length = l_xCanBuff.ucLength; + memcpy(&socTouchDisplay_U.Input[_prvU8Index].Data[0], &l_xCanBuff.ucData[0], 8); + _prvU8Index = (_prvU8Index + 1) % MAX_CAN_MESSAGE_INSTANCE; if(l_u8TxBurstMessages < 16) l_u8TxBurstMessages++; else break; } - xECU_GetCanStatus(CANFD0, g_u16CanSpeed); + vECU_CAN_GetStatus(CANFD0, g_eCanSpeed); } diff --git a/main.c b/main.c index 842e723..7eda061 100644 --- a/main.c +++ b/main.c @@ -19,9 +19,7 @@ //extern McalUartHandle_s g_xUartHandle; - - -static void __prv_TimerConfig(void) +static void vApp_TimerConfig(void) { SYSCFG_DL_TIMER_1_init(); DL_TimerA_startCounter(TIMER_1_INST); @@ -34,18 +32,19 @@ int main(void) { __enable_irq(); volatile DL_SYSCTL_RESET_CAUSE l_xResetCause = DL_SYSCTL_getResetCause(); - xMCAL_McuInit(); - xMCAL_SYSCTL_INIT(HFXT,STANDBY0); - xMCAL_SYSTICK_INIT(Period_1ms); - __prv_TimerConfig(); + vMCAL_McuInit(); + xMCAL_SysctlInit(IVEC_HFXT,IVEC_STANDBY0); + xMCAL_SystickInit(IVEC_SYSTICK_PERIOD_1MS); + vApp_TimerConfig(); + vRTE_AppInit(); + // Uncomment for UART-to-CAN transmission, if required + // vECU_InitiateUartToCanTransmit(&g_xUartHandle, 0x6, NULL, 0); - vApp_Init(); -// vECU_InitiateUartToCanTransmit(&g_xUartHandle, 0x6, NULL, 0); while(1) { - vApp_RunInit(); + vRTE_AppRunInit(); } } diff --git a/utils/utils.c b/utils/utils.c index 1893583..f90841f 100644 --- a/utils/utils.c +++ b/utils/utils.c @@ -6,15 +6,11 @@ #include #include "../Generated Codes/ti_msp_config.h" +static volatile uint32_t g_vrefInitFlag = 0; +volatile int g_i32TickCnt; +uint8_t g_systickInitFlag_u8 = 0; - -volatile uint32_t systic_Count; -volatile uint32_t systic_init_flag =0; -static volatile uint32_t g_u32VrefInitFalg = 0; -//#define tick_PIN_0_PIN (0x00004000) -//uint8_t tickmeasurement = 1; - -static const DL_VREF_Config gVREFConfig = { +static const DL_VREF_Config g_dlVrefConfig = { .vrefEnable = DL_VREF_ENABLE_DISABLE, .bufConfig = DL_VREF_BUFCONFIG_OUTPUT_2_5V, .shModeEnable = DL_VREF_SHMODE_DISABLE, @@ -22,259 +18,133 @@ static const DL_VREF_Config gVREFConfig = { .shCycleCount = DL_VREF_SH_MIN, }; -static const DL_VREF_ClockConfig gVREFClockConfig = { - .clockSel = DL_VREF_CLOCK_LFCLK, - .divideRatio = DL_VREF_CLOCK_DIVIDE_1, +static const DL_VREF_ClockConfig g_dlVrefClockConfig = { + .clockSel = DL_VREF_CLOCK_LFCLK, + .divideRatio = DL_VREF_CLOCK_DIVIDE_1, }; - -uint8_t u8SysTick_initFlag=0; - -//static const DL_SYSCTL_SYSPLLConfig gSYSPLLConfig = { -// .inputFreq = DL_SYSCTL_SYSPLL_INPUT_FREQ_16_32_MHZ, -// .rDivClk2x = 1, -// .rDivClk1 = 1, -// .rDivClk0 = 0, -// .enableCLK2x = DL_SYSCTL_SYSPLL_CLK2X_DISABLE, -// .enableCLK1 = DL_SYSCTL_SYSPLL_CLK1_ENABLE, -// .enableCLK0 = DL_SYSCTL_SYSPLL_CLK0_DISABLE, -// .sysPLLMCLK = DL_SYSCTL_SYSPLL_MCLK_CLK0, -// .sysPLLRef = DL_SYSCTL_SYSPLL_REF_SYSOSC, -// .qDiv = 9, -// .pDiv = DL_SYSCTL_SYSPLL_PDIV_2 -//}; - - - -//static const DL_SYSCTL_SYSPLLConfig gSYSPLLConfig = { -// .inputFreq = DL_SYSCTL_SYSPLL_INPUT_FREQ_8_16_MHZ, -// .rDivClk2x = 1, -// .rDivClk1 = 0, -// .rDivClk0 = 0, -// .enableCLK2x = DL_SYSCTL_SYSPLL_CLK2X_DISABLE, -// .enableCLK1 = DL_SYSCTL_SYSPLL_CLK1_ENABLE, -// .enableCLK0 = DL_SYSCTL_SYSPLL_CLK0_DISABLE, -// .sysPLLMCLK = DL_SYSCTL_SYSPLL_MCLK_CLK0, -// .sysPLLRef = DL_SYSCTL_SYSPLL_REF_SYSOSC, -// .qDiv = 9, -// .pDiv = DL_SYSCTL_SYSPLL_PDIV_4 -//}; -void mcuInit(void) +/* Systick Initialization */ +IVEC_CoreStatus_e xMCAL_SystickInit(IVEC_SystickPeriod_e eTick) { - SYSCFG_DL_initPower(); - - /* Module-Specific Initializations*/ -} - -xCoreStatus_t xMCAL_SYSTICK_INIT(xTicks_t tick) -{ -// if(u8SysTick_initFlag==1) -// { -// return STATUS_ERROR; -// } -// -// if(tick!=Period_1ms) -// { -// return STATUS_INIT_FAIL; -// } - - SysTick_Config(tick); - + SysTick_Config(eTick); NVIC_SetPriority(SysTick_IRQn, 0); - u8SysTick_initFlag=1; - - return STATUS_SUCCESS; + g_systickInitFlag_u8 = 1; + return IVEC_CORE_STATUS_SUCCESS; } -static const DL_SYSCTL_SYSPLLConfig gSYSPLLConfig = { - .inputFreq = DL_SYSCTL_SYSPLL_INPUT_FREQ_16_32_MHZ, - .rDivClk2x = 1, - .rDivClk1 = 0, - .rDivClk0 = 0, - .enableCLK2x = DL_SYSCTL_SYSPLL_CLK2X_DISABLE, - .enableCLK1 = DL_SYSCTL_SYSPLL_CLK1_DISABLE, - .enableCLK0 = DL_SYSCTL_SYSPLL_CLK0_ENABLE, - .sysPLLMCLK = DL_SYSCTL_SYSPLL_MCLK_CLK0, - .sysPLLRef = DL_SYSCTL_SYSPLL_REF_HFCLK, - .qDiv = 5, - .pDiv = DL_SYSCTL_SYSPLL_PDIV_1 +static const DL_SYSCTL_SYSPLLConfig g_dlSysPllConfig = { + .inputFreq = DL_SYSCTL_SYSPLL_INPUT_FREQ_16_32_MHZ, + .rDivClk2x = 1, + .rDivClk1 = 0, + .rDivClk0 = 0, + .enableCLK2x = DL_SYSCTL_SYSPLL_CLK2X_DISABLE, + .enableCLK1 = DL_SYSCTL_SYSPLL_CLK1_DISABLE, + .enableCLK0 = DL_SYSCTL_SYSPLL_CLK0_ENABLE, + .sysPLLMCLK = DL_SYSCTL_SYSPLL_MCLK_CLK0, + .sysPLLRef = DL_SYSCTL_SYSPLL_REF_HFCLK, + .qDiv = 5, + .pDiv = DL_SYSCTL_SYSPLL_PDIV_1, }; -xCoreStatus_t xMCAL_SYSCTL_INIT(uint8_t u8CLK_SRC,uint8_t u8LP_MODE) +/* System Control Initialization */ +IVEC_CoreStatus_e xMCAL_SysctlInit(uint8_t u8ClkSrc, uint8_t u8LowPowerMode) { + if ((u8LowPowerMode != IVEC_STANDBY0) && (u8LowPowerMode != IVEC_SLEEP0)) + return IVEC_CORE_STATUS_INIT_FAIL; - if((u8LP_MODE!=STANDBY0)&&(u8LP_MODE!=SLEEP0)) - return STATUS_INIT_FAIL; - if((u8CLK_SRC!=HFXT)&&(u8CLK_SRC!=SYSOSC)) - return STATUS_INIT_FAIL; + if ((u8ClkSrc != IVEC_HFXT) && (u8ClkSrc != IVEC_SYSOSC)) + return IVEC_CORE_STATUS_INIT_FAIL; - if(u8LP_MODE==STANDBY0) - { - //Low Power Mode is configured to be STANDBY0 - DL_SYSCTL_setPowerPolicySTANDBY0(); - DL_SYSCTL_setBORThreshold(DL_SYSCTL_BOR_THRESHOLD_LEVEL_0); - DL_SYSCTL_setFlashWaitState(DL_SYSCTL_FLASH_WAIT_STATE_2); - } - else if(u8LP_MODE==SLEEP0) - { - DL_SYSCTL_setBORThreshold(DL_SYSCTL_BOR_THRESHOLD_LEVEL_0); - DL_SYSCTL_setFlashWaitState(DL_SYSCTL_FLASH_WAIT_STATE_2); + if (u8LowPowerMode == IVEC_STANDBY0) + { + DL_SYSCTL_setPowerPolicySTANDBY0(); + DL_SYSCTL_setBORThreshold(DL_SYSCTL_BOR_THRESHOLD_LEVEL_0); + DL_SYSCTL_setFlashWaitState(DL_SYSCTL_FLASH_WAIT_STATE_2); + } + else if (u8LowPowerMode == IVEC_SLEEP0) + { + DL_SYSCTL_setBORThreshold(DL_SYSCTL_BOR_THRESHOLD_LEVEL_0); + DL_SYSCTL_setFlashWaitState(DL_SYSCTL_FLASH_WAIT_STATE_2); + } - } - - if(u8CLK_SRC==HFXT) - { - //Low Power Mode is configured to be SLEEP0 - // DL_SYSCTL_setBORThreshold(DL_SYSCTL_BOR_THRESHOLD_LEVEL_0); - // DL_SYSCTL_setSYSOSCFreq(DL_SYSCTL_SYSOSC_FREQ_BASE); - /* Set default configuration */ -// DL_SYSCTL_disableHFXT(); -// DL_SYSCTL_disableSYSPLL(); - -// DL_SYSCTL_setHFCLKSourceHFXTParams(DL_SYSCTL_HFXT_RANGE_16_32_MHZ,30, true); -// DL_SYSCTL_setULPCLKDivider(DL_SYSCTL_ULPCLK_DIV_1); - //DL_SYSCTL_setMCLKSource(SYSOSC, HSCLK, DL_SYSCTL_HSCLK_SOURCE_HFCLK); - - - //Low Power Mode is configured to be SLEEP0 - DL_SYSCTL_setBORThreshold(DL_SYSCTL_BOR_THRESHOLD_LEVEL_0); - DL_SYSCTL_setFlashWaitState(DL_SYSCTL_FLASH_WAIT_STATE_2); - - - DL_SYSCTL_setSYSOSCFreq(DL_SYSCTL_SYSOSC_FREQ_BASE); - /* Set default configuration */ - DL_SYSCTL_disableHFXT(); - DL_SYSCTL_disableSYSPLL(); - DL_SYSCTL_setHFCLKSourceHFXTParams(DL_SYSCTL_HFXT_RANGE_16_32_MHZ,10, true); - DL_SYSCTL_configSYSPLL((DL_SYSCTL_SYSPLLConfig *) &gSYSPLLConfig); - DL_SYSCTL_setULPCLKDivider(DL_SYSCTL_ULPCLK_DIV_2); - DL_SYSCTL_setMCLKSource(SYSOSC, HSCLK, DL_SYSCTL_HSCLK_SOURCE_SYSPLL); - } - else if(u8CLK_SRC==SYSOSC) - { - DL_SYSCTL_setSYSOSCFreq(DL_SYSCTL_SYSOSC_FREQ_BASE); - DL_SYSCTL_disableHFXT(); - DL_SYSCTL_disableSYSPLL(); - DL_SYSCTL_setHFCLKSourceHFXTParams(DL_SYSCTL_HFXT_RANGE_16_32_MHZ,50, true); - DL_SYSCTL_configSYSPLL((DL_SYSCTL_SYSPLLConfig *) &gSYSPLLConfig); - DL_SYSCTL_setHFCLKDividerForMFPCLK(DL_SYSCTL_HFCLK_MFPCLK_DIVIDER_6); - DL_SYSCTL_enableMFCLK(); - DL_SYSCTL_enableMFPCLK(); - DL_SYSCTL_setMFPCLKSource(DL_SYSCTL_MFPCLK_SOURCE_SYSOSC); - } - -// if(u8CLK_SRC==HFXT) -// { -// -// -// -// DL_SYSCTL_setSYSOSCFreq(DL_SYSCTL_SYSOSC_FREQ_BASE); -// /* Set default configuration */ -// DL_SYSCTL_disableHFXT(); -// DL_SYSCTL_disableSYSPLL(); -// DL_SYSCTL_setHFCLKSourceHFXTParams(DL_SYSCTL_HFXT_RANGE_16_32_MHZ,10, true); -// DL_SYSCTL_configSYSPLL((DL_SYSCTL_SYSPLLConfig *) &gSYSPLLConfig); -// DL_SYSCTL_setULPCLKDivider(DL_SYSCTL_ULPCLK_DIV_1); -// DL_SYSCTL_setHFCLKDividerForMFPCLK(DL_SYSCTL_HFCLK_MFPCLK_DIVIDER_6); -// DL_SYSCTL_enableMFCLK(); -// DL_SYSCTL_enableMFPCLK(); -// DL_SYSCTL_setMFPCLKSource(DL_SYSCTL_MFPCLK_SOURCE_HFCLK); -// DL_SYSCTL_setMCLKSource(SYSOSC, HSCLK, DL_SYSCTL_HSCLK_SOURCE_HFCLK); -//// DL_SYSCTL_setHFCLKSourceHFXTParams(DL_SYSCTL_HFXT_RANGE_16_32_MHZ,0, false); -//// DL_SYSCTL_setULPCLKDivider(DL_SYSCTL_ULPCLK_DIV_1); -//// DL_SYSCTL_setMCLKSource(SYSOSC, HSCLK, DL_SYSCTL_HSCLK_SOURCE_HFCLK); -// -// -// //DL_SYSCTL_setHFCLKSourceHFXTParams(DL_SYSCTL_HFXT_RANGE_32_48_MHZ,0, false); -//// DL_SYSCTL_setHFCLKSourceHFXTParams(DL_SYSCTL_HFXT_RANGE_16_32_MHZ,0, false); -//// DL_SYSCTL_setULPCLKDivider(DL_SYSCTL_ULPCLK_DIV_1); -//// DL_SYSCTL_setMCLKSource(SYSOSC, HSCLK, DL_SYSCTL_HSCLK_SOURCE_HFCLK); -// } -// -// else if(u8CLK_SRC==SYSOSC) -// { -//// DL_SYSCTL_setSYSOSCFreq(DL_SYSCTL_SYSOSC_FREQ_BASE); -//// /* Set default configuration */ -//// DL_SYSCTL_disableHFXT(); -//// DL_SYSCTL_disableSYSPLL(); -//// DL_SYSCTL_configSYSPLL((DL_SYSCTL_SYSPLLConfig *) &gSYSPLLConfig); -// DL_SYSCTL_setSYSOSCFreq(DL_SYSCTL_SYSOSC_FREQ_BASE); -// DL_SYSCTL_disableHFXT(); -// DL_SYSCTL_disableSYSPLL(); -// DL_SYSCTL_configSYSPLL((DL_SYSCTL_SYSPLLConfig *) &gSYSPLLConfig); -// DL_SYSCTL_setHFCLKDividerForMFPCLK(DL_SYSCTL_HFCLK_MFPCLK_DIVIDER_6); -// DL_SYSCTL_enableMFCLK(); -// DL_SYSCTL_enableMFPCLK(); -// DL_SYSCTL_setMFPCLKSource(DL_SYSCTL_MFPCLK_SOURCE_SYSOSC); -// } - - return STATUS_SUCCESS; + if (u8ClkSrc == IVEC_HFXT) + { + DL_SYSCTL_setBORThreshold(DL_SYSCTL_BOR_THRESHOLD_LEVEL_0); + DL_SYSCTL_setFlashWaitState(DL_SYSCTL_FLASH_WAIT_STATE_2); + DL_SYSCTL_setSYSOSCFreq(DL_SYSCTL_SYSOSC_FREQ_BASE); + DL_SYSCTL_disableHFXT(); + DL_SYSCTL_disableSYSPLL(); + DL_SYSCTL_setHFCLKSourceHFXTParams(DL_SYSCTL_HFXT_RANGE_16_32_MHZ, 10, true); + DL_SYSCTL_configSYSPLL((DL_SYSCTL_SYSPLLConfig *)&g_dlSysPllConfig); + DL_SYSCTL_setULPCLKDivider(DL_SYSCTL_ULPCLK_DIV_2); + DL_SYSCTL_setMCLKSource(SYSOSC, HSCLK, DL_SYSCTL_HSCLK_SOURCE_SYSPLL); + } + else if (u8ClkSrc == IVEC_SYSOSC) + { + DL_SYSCTL_setSYSOSCFreq(DL_SYSCTL_SYSOSC_FREQ_BASE); + DL_SYSCTL_disableHFXT(); + DL_SYSCTL_disableSYSPLL(); + DL_SYSCTL_setHFCLKSourceHFXTParams(DL_SYSCTL_HFXT_RANGE_16_32_MHZ, 50, true); + DL_SYSCTL_configSYSPLL((DL_SYSCTL_SYSPLLConfig *)&g_dlSysPllConfig); + DL_SYSCTL_setHFCLKDividerForMFPCLK(DL_SYSCTL_HFCLK_MFPCLK_DIVIDER_6); + DL_SYSCTL_enableMFCLK(); + DL_SYSCTL_enableMFPCLK(); + DL_SYSCTL_setMFPCLKSource(DL_SYSCTL_MFPCLK_SOURCE_SYSOSC); + } + return IVEC_CORE_STATUS_SUCCESS; } void SysTick_Handler(void) { - i32TickCnt++; -// if(tickmeasurement) -// { -// DL_GPIO_clearPins(GPIOB, tick_PIN_0_PIN); -// tickmeasurement = 0; -// } -// else -// { -// DL_GPIO_setPins(GPIOB, tick_PIN_0_PIN); -// tickmeasurement = 1; -// } - - + g_i32TickCnt++; } -int i32MCAL_getTicks() +int32_t i32MCAL_GetTicks() { - return i32TickCnt; + return g_i32TickCnt; } -void vMCAL_DelayTicks(int i32Delay_ms) +void vMCAL_DelayTicks(int32_t i32DelayMs) { - int curr_tick; - curr_tick=i32MCAL_getTicks(); + int32_t l_i32CurrTick = i32MCAL_GetTicks(); - while((i32MCAL_getTicks()-curr_tick) #include #include "ti_msp_dl_config.h" -//#define GPIO 0 -//#define UART 0 +/* Generic Status Codes */ typedef enum { - /* Generic error codes */ - IVEC_MCAL_STATUS_INIT_FAIL = -1, - IVEC_MCAL_STATUS_SUCCESS , /*!< Generic operation success status */ - IVEC_MCAL_STATUS_ERROR , /*!< Generic operation failure status */ - IVEC_MCAL_STATUS_BUSY , /*!< Generic operation busy status */ - IVEC_MCAL_STATUS_TIMEOUT , /*!< Generic operation timeout status */ - IVEC_MCAL_STATUS_UNSUPPORTED , /*!< Generic operation unsupported status */ - IVEC_MCAL_STATUS_TRUE , /*!< Generic operation true status */ - IVEC_MCAL_STATUS_FALSE , /*!< Generic operation false status */ -}IVEC_McalStatus_e; - -#define GPIO 5 -#define UART 1 -#define HFXT 2 -#define STANDBY0 3 -#define SYSOSC 4 -#define SLEEP0 6 - - - - -volatile int i32TickCnt; + IVEC_MCAL_STATUS_INIT_FAIL = -1, + IVEC_MCAL_STATUS_SUCCESS , /*!< Generic operation success status */ + IVEC_MCAL_STATUS_ERROR , /*!< Generic operation failure status */ + IVEC_MCAL_STATUS_BUSY , /*!< Generic operation busy status */ + IVEC_MCAL_STATUS_TIMEOUT , /*!< Generic operation timeout status */ + IVEC_MCAL_STATUS_UNSUPPORTED , /*!< Generic operation unsupported status */ + IVEC_MCAL_STATUS_TRUE , /*!< Generic operation true status */ + IVEC_MCAL_STATUS_FALSE , /*!< Generic operation false status */ +} IVEC_McalStatus_e; +/* Peripheral Identifiers */ +#define IVEC_GPIO 5 +#define IVEC_UART 1 +#define IVEC_HFXT 2 +#define IVEC_STANDBY0 3 +#define IVEC_SYSOSC 4 +#define IVEC_SLEEP0 6 +/* Core Status Codes */ typedef enum { - /* Generic error codes */ - STATUS_INIT_FAIL = 1, - STATUS_SUCCESS = 0, /*!< Generic operation success status */ - STATUS_ERROR = -1, /*!< Generic operation failure status */ - STATUS_BUSY = 2, /*!< Generic operation busy status */ - STATUS_TIMEOUT = 3, /*!< Generic operation timeout status */ - STATUS_UNSUPPORTED = 4, /*!< Generic operation unsupported status */ -}xCoreStatus_t; + IVEC_CORE_STATUS_INIT_FAIL = 1, + IVEC_CORE_STATUS_SUCCESS = 0, /*!< Generic operation success status */ + IVEC_CORE_STATUS_ERROR = -1, /*!< Generic operation failure status */ + IVEC_CORE_STATUS_BUSY = 2, /*!< Generic operation busy status */ + IVEC_CORE_STATUS_TIMEOUT = 3, /*!< Generic operation timeout status */ + IVEC_CORE_STATUS_UNSUPPORTED = 4, /*!< Generic operation unsupported status */ +} IVEC_CoreStatus_e; +/* UART Baud Rate Options */ typedef enum { - /*UART Baud Rate Options*/ - BAUD_115200 = 0, - BAUD_9600 = 1, -}xUart_baud_t; + IVEC_UART_BAUD_115200 = 0, + IVEC_UART_BAUD_9600 = 1, +} IVEC_UartBaud_e; +/* CAN Baud Rate Options */ typedef enum { - /*CAN Baud Rate Options*/ - BAUD_500 = 500, - BAUD_250 = 250, - BAUD_150 = 150, - BAUD_1000 = 1000, - BAUD_125 = 125, - -}xCAN_baud_t; + IVEC_CAN_BAUD_500 = 500, + IVEC_CAN_BAUD_250 = 250, + IVEC_CAN_BAUD_150 = 150, + IVEC_CAN_BAUD_1000 = 1000, + IVEC_CAN_BAUD_125 = 125, +} IVEC_CanBaud_e; +/* SPI Clock Speed Options */ typedef enum { - /*SPI Clock Speed Options*/ - CS_1Mhz = 0, -}xSPI_CS_t; + IVEC_SPI_CS_1MHZ = 0, +} IVEC_SpiCs_e; +/* SysTick Period Options */ typedef enum { - /*SysTick Period Options*/ - Period_1ms = 72000, /*!< sets period of SysTick to 1ms @48Mhz*/ -}xTicks_t; + IVEC_SYSTICK_PERIOD_1MS = 72000, /*!< Sets period of SysTick to 1ms @48Mhz */ +} IVEC_SystickPeriod_e; +/* I2C Baud Rate Options */ typedef enum { - /*SPI Clock Speed Options*/ - BAUD_100Khz = 0, - BAUD_400Khz, -}xI2C_baud_t; + IVEC_I2C_BAUD_100KHZ = 0, + IVEC_I2C_BAUD_400KHZ, +} IVEC_I2cBaud_e; -typedef enum { - I2C_STATUS_IDLE = 0, - I2C_STATUS_TX_STARTED, - I2C_STATUS_TX_INPROGRESS, - I2C_STATUS_TX_COMPLETE, - I2C_STATUS_RX_STARTED, - I2C_STATUS_RX_INPROGRESS, - I2C_STATUS_RX_COMPLETE, - I2C_STATUS_ERROR, -} xI2cControllerStatus_t; +/* I2C Controller Status */ +typedef enum +{ + IVEC_I2C_STATUS_IDLE = 0, + IVEC_I2C_STATUS_TX_STARTED, + IVEC_I2C_STATUS_TX_INPROGRESS, + IVEC_I2C_STATUS_TX_COMPLETE, + IVEC_I2C_STATUS_RX_STARTED, + IVEC_I2C_STATUS_RX_INPROGRESS, + IVEC_I2C_STATUS_RX_COMPLETE, + IVEC_I2C_STATUS_ERROR, +} IVEC_I2cControllerStatus_e; -void mcuInit(void); -xCoreStatus_t xMCAL_SYSCTL_INIT(uint8_t u8CLK_SRC,uint8_t u8LP_MODE); -xCoreStatus_t xMCAL_SYSTICK_INIT(xTicks_t tick); -//void delay (uint32_t us); -int i32MCAL_getTicks(); -void vMCAL_DelayTicks(int i32Delay_ms); - -void xMCAL_SoftReset(void); -void xMCAL_McuInit(void); -void delay (uint32_t us); +/* Function Declarations */ +void vMCAL_McuInit(void); +IVEC_CoreStatus_e xMCAL_SysctlInit(uint8_t u8ClkSrc, uint8_t u8LpMode); +IVEC_CoreStatus_e xMCAL_SystickInit(IVEC_SystickPeriod_e xTick); +int32_t i32MCAL_GetTicks(void); +void vMCAL_DelayTicks(int32_t i32DelayMs); +void vMCAL_SoftReset(void); +void vMCAL_DelayUs(uint32_t u32Us); IVEC_McalStatus_e xMCAL_VrefInit(void); - - -#endif /* UTILS_UTILS_H_ */ +#endif /* UTILS_IVEC_UTILS_H_ */