From fe7e93fa2a47478a89652393196b1be7f9d9fc82 Mon Sep 17 00:00:00 2001 From: cfif Date: Tue, 7 Oct 2025 15:12:11 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=BB=D0=B5?= =?UTF-8?q?=D0=BD=D0=B8=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Inc/CanSerialPortFrame.h | 92 ++++++--- Src/CanSerialPortFrame.c | 406 ++++++++++++++++++++++++++++----------- 2 files changed, 356 insertions(+), 142 deletions(-) diff --git a/Inc/CanSerialPortFrame.h b/Inc/CanSerialPortFrame.h index 04e25c4..9b11a2c 100644 --- a/Inc/CanSerialPortFrame.h +++ b/Inc/CanSerialPortFrame.h @@ -15,32 +15,33 @@ #include "fc7xxx_driver_flexcan.h" #include "fc7xxx_driver_pcc.h" +#include "fc7xxx_driver_dma.h" - - -typedef enum { - CAN_BAUD_RATE_1000K, - CAN_BAUD_RATE_500K, - CAN_BAUD_RATE_250K, - CAN_BAUD_RATE_125K -} eCanBaudRate; - -typedef enum { - CAN_STD_ID, - CAN_EXT_ID -} eCanTypeFrame; - -#define COUNT_QUEUE 2 - typedef struct { - uint16_t u16CanId; /**< FLEXCAN id */ - uint8_t u8DataLen; /**< data length */ - uint8_t aData[8]; /**< data buffer */ + uint32_t standard_id; /*!< specifies the 11 bits standard identifier + this parameter can be a value between 0 to 0x7FF. */ + uint32_t extended_id; /*!< specifies the 29 bits extended identifier. + this parameter can be a value between 0 to 0x1FFFFFFF. */ + + FLEXCAN_IdType id_type; /*!< specifies identifier type for the receive message.*/ + + FLEXCAN_DataType frame_type; /*!< specifies frame type for the receive message.*/ + + uint8_t dlc; /*!< specifies the frame data length that will be received. + this parameter can be a value between 0 to 8 */ + + uint8_t data[8]; /*!< contains the receive data. it ranges from 0 to 0xFF.*/ + + uint8_t filter_index; /*!< specifies the message stored in which filter + this parameter can be a value between 0 to 0xFF */ } can_rx_message_type; + +#define COUNT_QUEUE 2 + typedef struct { FLEXCAN_Type *can; @@ -49,18 +50,20 @@ typedef struct { uint32_t id; uint32_t id1; - eCanTypeFrame canTypeFrame; + FLEXCAN_IdType canTypeFrame; bool canFilterEnable; bool reInit; - eCanBaudRate canBaudRate; + FLEXCAN_BaudType canBaudRate; + + uint32_t g_u32RxDataIndex; FLEXCAN_RxMbFilterType aRxFiltList[COUNT_QUEUE]; FLEXCAN_RxMbFilterType pRxFilterFifoList[COUNT_QUEUE]; - osMessageQueueId_t rxDataQueue[COUNT_QUEUE]; - osMessageQueueId_t rxDataSnifferQueue[COUNT_QUEUE]; + osMessageQueueId_t rxDataQueue; + osMessageQueueId_t rxDataSnifferQueue; osMessageQueueId_t txAccessQueue; @@ -75,10 +78,11 @@ void vCanSerialPortFrameInit( FLEXCAN_Type *CANx, // FLEXCAN0 PCC_ClkSrcType canClock, // PCC_CLK_FLEXCAN0 uint8 CAN_INDEX, // CAN0 = 0 ... CAN3 = 3 + IRQn_Type IRQ_CAN, // FlexCAN0_IRQn ... FlexCAN3_IRQn + uint8 CAN_PRIORITY, - eCanBaudRate canBaudRate, - uint8_t irqSubPriority, - eCanTypeFrame canTypeFrame, + FLEXCAN_BaudType canBaudRate, + FLEXCAN_IdType canTypeFrame, uint32_t canId, FLEXCAN_ErrorInterruptCallBackType CAN_ErrorInterrupt_CallBack, FLEXCAN_RxInterruptCallBackType CAN_RxInterrupt_CallBack, @@ -87,11 +91,43 @@ void vCanSerialPortFrameInit( ); +void vCanSerialPortFrameDMAInit( + tCanSerialPortFrameFlagchip *env, + + FLEXCAN_Type *CANx, // FLEXCAN0 + PCC_ClkSrcType canClock, // PCC_CLK_FLEXCAN0 + uint8 CAN_INDEX, // CAN0 = 0 ... CAN3 = 3 + + IRQn_Type IRQ_CAN, // FlexCAN0_IRQn ... FlexCAN3_IRQn + uint8 CAN_PRIORITY, + + DMA_ChannelType RX_DMA_CHANNEL, + DMA_RequestSourceType RX_DMA_CHANNEL_REQ, // DMA_REQ_FLEXCAN0 + + uint8_t *DMA_BUF, + + IRQn_Type IRQ_DMA, + uint8_t IRQ_DMA_PRIORITY, + uint8_t IRQ_DMA_CHANNEL_PRIORITY, + + FLEXCAN_BaudType canBaudRate, + FLEXCAN_IdType canTypeFrame, + uint32_t canId, + FLEXCAN_ErrorInterruptCallBackType CAN_ErrorInterrupt_CallBack, + FLEXCAN_RxInterruptCallBackType CAN_RxInterrupt_CallBack, + FLEXCAN_RxInterruptCallBackType CAN_RxFifoInterrupt_CallBack, + FLEXCAN_TxInterruptCallBackType CAN_TxInterrupt_CallBack, + + DMA_TransferCompleteCallbackType DMA_TransferCompleteCallback, + DMA_TransferErrorCallbackType DMA_ErrorCallback +); + void CAN_RxInterrupt_CallBack_Handler(tCanSerialPortFrameFlagchip *env, uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg); +void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_t *pBuf); + void CanSerialPortFrameSetId(tCanSerialPortFrameFlagchip *env, uint32_t id); -void CanSerialPortFrameSetId1(tCanSerialPortFrameFlagchip *env, uint32_t id); -void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, eCanTypeFrame canTypeFrame); +void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, FLEXCAN_IdType canTypeFrame); tSerialPortFrameIO CanPortFrame_GetIo(tCanSerialPortFrameFlagchip *env); tSerialPortFrameIO CanPortFrame_GetSnifferIo(tCanSerialPortFrameFlagchip *env); diff --git a/Src/CanSerialPortFrame.c b/Src/CanSerialPortFrame.c index ce7634e..ca7613b 100644 --- a/Src/CanSerialPortFrame.c +++ b/Src/CanSerialPortFrame.c @@ -5,6 +5,7 @@ #include "CanSerialPortFrame.h" #include "memory.h" + #define CAN_USED_NUM 6U #define CAN_RECEIVE_MB_NUM 2 static FLEXCAN_RxMsgType s_aaRxDataBuf[CAN_USED_NUM][CAN_RECEIVE_MB_NUM]; @@ -33,28 +34,37 @@ static void BSP_CAN_INIT_CFG(FLEXCAN_InitType *pCfg) { pCfg->eDirect = FLEXCAN_DIR_DISABLE; } +static void BSP_CAN_INIT_MBConfig(FLEXCAN_MBConfigType *pMbCfg) { + pMbCfg->pRxFilterFifoList = NULL; + pMbCfg->u8RxFilterFifoCnt = 0; + pMbCfg->pRxFilterMBList = NULL; + pMbCfg->u8RxFilterMBCnt = 0; + pMbCfg->u8TxMsgCnt = 0; + pMbCfg->pRxBuf = NULL; +} + +static void BSP_DMA_INIT_CFG(DMA_InitType *pDmaCfg) { + pDmaCfg->eArbitrationAlgorithm = DMA_ARBITRATION_ALGORITHM_FIXED_PRIORITY; + pDmaCfg->bHaltOnError = false; +} + + void CanSerialPortFrameSetId(tCanSerialPortFrameFlagchip *env, uint32_t id) { env->id = id; } -void CanSerialPortFrameSetId1(tCanSerialPortFrameFlagchip *env, uint32_t id) { - env->id1 = id; -} - -void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, eCanTypeFrame canTypeFrame) { +void CanSerialPortFrameSetType(tCanSerialPortFrameFlagchip *env, FLEXCAN_IdType canTypeFrame) { env->canTypeFrame = canTypeFrame; } static void vCanSerialPortFrameInitStructure(tCanSerialPortFrameFlagchip *env, uint16_t rxDataLength, uint16_t rxSnifferLength) { - for (uint8_t i = 0; i < COUNT_QUEUE; ++i) { - env->rxDataQueue[i] = osMessageQueueNew(rxDataLength, sizeof(can_rx_message_type), NULL); - if (rxSnifferLength) { - env->rxDataSnifferQueue[i] = osMessageQueueNew(rxSnifferLength, sizeof(can_rx_message_type), NULL); - } else { - env->rxDataSnifferQueue[i] = NULL; - } + env->rxDataQueue = osMessageQueueNew(rxDataLength, sizeof(can_rx_message_type), NULL); + if (rxSnifferLength) { + env->rxDataSnifferQueue = osMessageQueueNew(rxSnifferLength, sizeof(can_rx_message_type), NULL); + } else { + env->rxDataSnifferQueue = NULL; } } @@ -66,10 +76,11 @@ void vCanSerialPortFrameInit( FLEXCAN_Type *CANx, // FLEXCAN0 PCC_ClkSrcType canClock, // PCC_CLK_FLEXCAN0 uint8 CAN_INDEX, // CAN0 = 0 ... CAN3 = 3 + IRQn_Type IRQ_CAN, // FlexCAN0_IRQn ... FlexCAN3_IRQn + uint8 CAN_PRIORITY, - eCanBaudRate canBaudRate, - uint8_t irqSubPriority, - eCanTypeFrame canTypeFrame, + FLEXCAN_BaudType canBaudRate, + FLEXCAN_IdType canTypeFrame, uint32_t canId, FLEXCAN_ErrorInterruptCallBackType CAN_ErrorInterrupt_CallBack, FLEXCAN_RxInterruptCallBackType CAN_RxInterrupt_CallBack, @@ -98,7 +109,9 @@ void vCanSerialPortFrameInit( BSP_CAN_INIT_CFG(&tInitCfg); - tInitCfg.eBaudrate = FLEXCAN_BAUD_500K; + BSP_CAN_INIT_MBConfig(&tMbCfg); + + tInitCfg.eBaudrate = canBaudRate; tInitCfg.bEnRxFifo = TRUE; tInitCfg.bEnDma = FALSE; @@ -181,7 +194,16 @@ void vCanSerialPortFrameInit( } - FLEXCAN_SetInterrupt(CAN_INDEX, &tIntCfg); + if ((tIntCfg.bEnErrorInterrupt) || + (tIntCfg.bEnTxMBInterrupt) || + (tIntCfg.bEnRxMBInterrupt) || + (tIntCfg.bEnRxFifoInterrupt)) { + + NVIC_SetPriority(IRQ_CAN, CAN_PRIORITY); + NVIC_EnableIRQ(IRQ_CAN); + + FLEXCAN_SetInterrupt(CAN_INDEX, &tIntCfg); + } FLEXCAN_Start(CAN_INDEX); /* Start CAN */ } @@ -199,18 +221,257 @@ void vCanSerialPortFrameInit( } +void vCanSerialPortFrameDMAInit( + tCanSerialPortFrameFlagchip *env, + + FLEXCAN_Type *CANx, // FLEXCAN0 + PCC_ClkSrcType canClock, // PCC_CLK_FLEXCAN0 + uint8 CAN_INDEX, // CAN0 = 0 ... CAN3 = 3 + + IRQn_Type IRQ_CAN, // FlexCAN0_IRQn ... FlexCAN3_IRQn + uint8 CAN_PRIORITY, + + DMA_ChannelType RX_DMA_CHANNEL, + DMA_RequestSourceType RX_DMA_CHANNEL_REQ, // DMA_REQ_FLEXCAN0 + + uint8_t *DMA_BUF, + + IRQn_Type IRQ_DMA, + uint8_t IRQ_DMA_PRIORITY, + uint8_t IRQ_DMA_CHANNEL_PRIORITY, + + FLEXCAN_BaudType canBaudRate, + FLEXCAN_IdType canTypeFrame, + uint32_t canId, + FLEXCAN_ErrorInterruptCallBackType CAN_ErrorInterrupt_CallBack, + FLEXCAN_RxInterruptCallBackType CAN_RxInterrupt_CallBack, + FLEXCAN_RxInterruptCallBackType CAN_RxFifoInterrupt_CallBack, + FLEXCAN_TxInterruptCallBackType CAN_TxInterrupt_CallBack, + + DMA_TransferCompleteCallbackType DMA_TransferCompleteCallback, + DMA_TransferErrorCallbackType DMA_ErrorCallback +) { + + + FLEXCAN_ErrorType tRetVal; + FLEXCAN_InitType tInitCfg; + FLEXCAN_MBConfigType tMbCfg = {0}; + uint32_t u32FuncClk; + PCC_CtrlType bSP_PCC_Config; + FLEXCAN_InterruptType tIntCfg = {0}; + + env->g_u32RxDataIndex = 0; + + env->can = CANx; + env->CAN_INDEX = CAN_INDEX; + + bSP_PCC_Config.eClockName = canClock; + bSP_PCC_Config.bEn = TRUE; + bSP_PCC_Config.eClkSrc = PCC_CLKGATE_SRC_FOSCDIV; + bSP_PCC_Config.eDivider = PCC_CLK_DIV_BY1; + + PCC_SetPcc(&bSP_PCC_Config); + + + BSP_CAN_INIT_CFG(&tInitCfg); + BSP_CAN_INIT_MBConfig(&tMbCfg); + + tInitCfg.eBaudrate = canBaudRate; + tInitCfg.bEnRxFifo = TRUE; + tInitCfg.bEnDma = TRUE; + + tInitCfg.bEnFd = FALSE; + tInitCfg.bEnBrs = FALSE; + tInitCfg.eMbDataWidth = FLEXCAN_DATAWIDTH_8; + + u32FuncClk = PCC_GetPccFunctionClock(s_ePccCanTable[CAN_INDEX]); + + tInitCfg.eClkSrcSel = FLEXCAN_CLOCK_FUNCTION; /* functional clock */ + tInitCfg.eClkSrcHz = (FLEXCAN_BaudClkType) u32FuncClk; /* function clock frequency */ + + tInitCfg.eDirect = FLEXCAN_DIR_ENABLE_WITHOUT_TRIG; + + + tRetVal = FLEXCAN_Init(CAN_INDEX, &tInitCfg); + + if (tRetVal == FLEXCAN_ERROR_OK) { + /* +++++++++++ can mb initial ++++++++++++ */ + + env->pRxFilterFifoList[0].eRxFrameType = FLEXCAN_ID_STD; + env->pRxFilterFifoList[0].u32RxCanId = 0U; + env->pRxFilterFifoList[0].u32RxCanIdMask = 0U; + + env->pRxFilterFifoList[1].eRxFrameType = FLEXCAN_ID_STD; + env->pRxFilterFifoList[1].u32RxCanId = 0U; + env->pRxFilterFifoList[1].u32RxCanIdMask = 0U; + + tMbCfg.pRxFilterMBList = env->pRxFilterFifoList; + tMbCfg.u8RxFilterMBCnt = sizeof(env->pRxFilterFifoList) / sizeof(env->pRxFilterFifoList[0]); + + tMbCfg.pRxBuf = CAN_GET_BUFFER(CAN_INDEX); + + /* tx config */ + + tMbCfg.u8TxMsgCnt = 3U; /* tx occupy 3 mb */ + + tRetVal = FLEXCAN_RxFilterConfig(CAN_INDEX, &tMbCfg); + + if (CAN_ErrorInterrupt_CallBack == NULL) { + tIntCfg.bEnErrorInterrupt = 0U; + tIntCfg.pErrorNotify = NULL; + + tIntCfg.bEnTxMBInterrupt = 0U; + tIntCfg.pRxMBNotify = NULL; + + tIntCfg.bEnRxMBInterrupt = 0U; + tIntCfg.pRxFifoNotify = NULL; + + tIntCfg.bEnRxFifoInterrupt = 0U; + tIntCfg.pTxMBNotify = NULL; + + } else { + tIntCfg.bEnErrorInterrupt = 1U; + tIntCfg.pErrorNotify = CAN_ErrorInterrupt_CallBack; + + tIntCfg.bEnTxMBInterrupt = 1U; + tIntCfg.pRxMBNotify = CAN_RxInterrupt_CallBack; + + tIntCfg.bEnRxMBInterrupt = 1U; + tIntCfg.pRxFifoNotify = CAN_RxFifoInterrupt_CallBack; + + tIntCfg.bEnRxFifoInterrupt = 1U; + tIntCfg.pTxMBNotify = CAN_TxInterrupt_CallBack; + + } + + + DMA_InitType dmaInitCfg; + BSP_DMA_INIT_CFG(&dmaInitCfg); + + DMA_ChannelCfgType chnCfg = {0}; + + DMA_InterruptCfgType interruptCfg = {0}; + uint32_t u32TargetAddr; + + dmaInitCfg.eArbitrationAlgorithm = DMA_ARBITRATION_ALGORITHM_FIXED_PRIORITY; + dmaInitCfg.bHaltOnError = false; + + DMA_Init(DMA_INSTANCE_0, &dmaInitCfg); + + u32TargetAddr = (uint32_t) (DMA_BUF); + + chnCfg.pSrcBuffer = &(CANx->RAM[0]); + chnCfg.pDestBuffer = (void *) (u32TargetAddr); + chnCfg.u32BlockSize = 16U; + chnCfg.u16BlockCount = 1U; + chnCfg.u8ChannelPriority = IRQ_DMA_CHANNEL_PRIORITY; + chnCfg.eSrcDataSize = DMA_TRANSFER_SIZE_4B; + chnCfg.eDestDataSize = DMA_TRANSFER_SIZE_4B; + chnCfg.eSrcIncMode = DMA_INCREMENT_DATA_SIZE; + chnCfg.eDestIncMode = DMA_INCREMENT_DATA_SIZE; + chnCfg.bSrcBlockOffsetEn = 0U; + chnCfg.bDestBlockOffsetEn = 0U; + chnCfg.s32BlockOffset = 0; + chnCfg.bSrcAddrLoopbackEn = 1U; + chnCfg.bDestAddrLoopbackEn = false; + chnCfg.bAutoStop = 0U; + chnCfg.bSrcCircularBufferEn = false; + chnCfg.u32SrcCircBufferSize = DMA_CIRCULAR_BUFFER_SIZE_1B; + chnCfg.bDestCircularBufferEn = true; + chnCfg.u32DestCircBufferSize = 256U; + chnCfg.eTriggerSrc = RX_DMA_CHANNEL_REQ; + DMA_InitChannel(DMA_INSTANCE_0, (DMA_ChannelType) RX_DMA_CHANNEL, &chnCfg); + + interruptCfg.bTransferCompleteIntEn = 1; + interruptCfg.pTransferCompleteNotify = DMA_TransferCompleteCallback; + interruptCfg.bTransferErrorIntEn = 1; + interruptCfg.pTransferErrorNotify = DMA_ErrorCallback; + + DMA_InitChannelInterrupt(DMA_INSTANCE_0, (DMA_ChannelType) RX_DMA_CHANNEL, &interruptCfg); + + NVIC_SetPriorityGrouping(NVIC_PRIORITY_GROUP_4); + + + NVIC_SetPriority(DMA_Error_IRQn, IRQ_DMA_PRIORITY); + NVIC_SetPriority(IRQ_DMA, IRQ_DMA_PRIORITY); + NVIC_EnableIRQ(IRQ_DMA); + + DMA_StartChannel(DMA_INSTANCE_0, (DMA_ChannelType) RX_DMA_CHANNEL); + + if ((tIntCfg.bEnErrorInterrupt) || + (tIntCfg.bEnTxMBInterrupt) || + (tIntCfg.bEnRxMBInterrupt) || + (tIntCfg.bEnRxFifoInterrupt)) { + + NVIC_SetPriority(IRQ_CAN, CAN_PRIORITY); + NVIC_EnableIRQ(IRQ_CAN); + + FLEXCAN_SetInterrupt(CAN_INDEX, &tIntCfg); + + } + + FLEXCAN_Start(CAN_INDEX); /* Start CAN */ + } + + + if (!env->reInit) { + env->reInit = true; + vCanSerialPortFrameInitStructure(env, 10, 0); + + CanSerialPortFrameSetType(env, canTypeFrame); + CanSerialPortFrameSetId(env, canId); + + env->canBaudRate = canBaudRate; + } + +} + +void CanSerialPortFrameIrqRxProcessing(tCanSerialPortFrameFlagchip *env, uint32_t *pBuf) { + can_rx_message_type rx_message_struct; + + uint32_t u32TempAddr = (uint32_t) FLEXCAN_MB_WORDN_ADDR(pBuf, 0U, 8U, 0U); + + uint32_t dlc = FLEXCAN_MB_DLC_GET(u32TempAddr); + rx_message_struct.dlc = FLEXCAN_DlcToDataLen(dlc); + + rx_message_struct.id_type = FLEXCAN_MB_IDE_GET(u32TempAddr); + + if (rx_message_struct.id_type == FLEXCAN_ID_STD) { + rx_message_struct.standard_id = FLEXCAN_MB_STDID_GET(u32TempAddr); + } else { + rx_message_struct.extended_id = FLEXCAN_MB_EXTID_GET(u32TempAddr); + } + + uint32_t *pSrc = (uint32_t *) FLEXCAN_MB_WORDN_ADDR(pBuf, 0U, 8U, 8U); + uint32_t *pDest = (uint32_t *) &rx_message_struct.data[0]; + + uint32_t u32WordLen = rx_message_struct.dlc / 4U + (rx_message_struct.dlc % 4U > 0U ? 1U : 0U); + + for (uint8_t u8Index = 0U; u8Index < u32WordLen; ++u8Index) { + REV_BYTES_32(pSrc[u8Index], pDest[u8Index]); + } + + osMessageQueuePut(env->rxDataQueue, &rx_message_struct, 0x0, 0U); + + if (env->rxDataSnifferQueue) { + osMessageQueuePut(env->rxDataSnifferQueue, &rx_message_struct, 0x0, 0U); + } + +} + + void CAN_RxInterrupt_CallBack_Handler(tCanSerialPortFrameFlagchip *env, uint8_t u8CanIndex, FLEXCAN_RxMsgType *pRxCfg) { can_rx_message_type rx_message_struct; - rx_message_struct.u16CanId = pRxCfg->u32CanId; - rx_message_struct.u8DataLen = pRxCfg->u32DataLen; - memcpy(rx_message_struct.aData, pRxCfg->aData, rx_message_struct.u8DataLen); + rx_message_struct.standard_id = pRxCfg->u32CanId; + rx_message_struct.dlc = pRxCfg->u32DataLen; + memcpy(rx_message_struct.data, pRxCfg->aData, rx_message_struct.dlc); - osMessageQueuePut(env->rxDataQueue[pRxCfg->u8MbIndex], &rx_message_struct, 0x0, 0U); + osMessageQueuePut(env->rxDataQueue, &rx_message_struct, 0x0, 0U); - if (env->rxDataSnifferQueue[pRxCfg->u8MbIndex]) { - osMessageQueuePut(env->rxDataSnifferQueue[pRxCfg->u8MbIndex], &rx_message_struct, 0x0, 0U); + if (env->rxDataSnifferQueue) { + osMessageQueuePut(env->rxDataSnifferQueue, &rx_message_struct, 0x0, 0U); } } @@ -248,17 +509,17 @@ static uint16_t vSerialPortFrameReceiveQueue( } static uint16_t -vCanSerialPortFrameReceive(tCanSerialPortFrameFlagchip *env, uint8_t u8MbIndex, uint8_t *data, uint16_t size, +vCanSerialPortFrameReceive(tCanSerialPortFrameFlagchip *env, uint8_t *data, uint16_t size, uint32_t timeout) { - return vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataQueue[u8MbIndex]); + return vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataQueue); } static uint16_t -vCanSerialPortFrameReceiveSniffer(tCanSerialPortFrameFlagchip *env, uint8_t u8MbIndex, uint8_t *data, uint16_t size, +vCanSerialPortFrameReceiveSniffer(tCanSerialPortFrameFlagchip *env, uint8_t *data, uint16_t size, uint32_t timeout) { - return env->rxDataSnifferQueue[u8MbIndex] - ? vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataSnifferQueue[u8MbIndex]) + return env->rxDataSnifferQueue + ? vSerialPortFrameReceiveQueue(env, data, size, timeout, env->rxDataSnifferQueue) : 0; } @@ -279,9 +540,9 @@ uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t * tTxMsg.u32DataLen = 8; tTxMsg.eDataType = FLEXCAN_FRAME_DATA; - tTxMsg.eFrameType = FLEXCAN_ID_STD; + tTxMsg.eFrameType = (FLEXCAN_IdType) env->canTypeFrame; tTxMsg.bWaitTxCompleted = 1U; - tTxMsg.u16WaitTxTimeout = 1000U; + tTxMsg.u16WaitTxTimeout = 10000U; uint16_t len = 0; @@ -317,93 +578,10 @@ uint16_t vCanSerialPortFrameTransmit(tCanSerialPortFrameFlagchip *env, uint8_t * size -= tailSize; } - - - -/* - - uint16_t sent = 0; - uint32_t endMs = SystemGetMs() + timeout; - - uint16_t fullSize = size / 8; - uint8_t tailSize = size % 8; - - uint8_t transmit_mailbox; - can_tx_message_type TxMessage; - - - if (env->canTypeFrame == CAN_STD_ID) { - TxMessage.standard_id = env->id; - TxMessage.extended_id = 0; - TxMessage.id_type = CAN_ID_STANDARD; - } - - if (env->canTypeFrame == CAN_EXT_ID) { - TxMessage.standard_id = 0; - TxMessage.extended_id = env->id; - TxMessage.id_type = CAN_ID_EXTENDED; - } - - TxMessage.frame_type = CAN_TFT_DATA; - TxMessage.dlc = 8; - - while (size && ((timeout == SystemWaitForever) || (endMs > SystemGetMs()))) { - - uint16_t len = 0; - for (uint16_t i = 0; i < fullSize; ++i) { - - memcpy(TxMessage.data, &data[len], 8); - len += 8; - - transmit_mailbox = can_message_transmitExt(env->can, &TxMessage, CAN_TX_MAILBOX0); - - while (can_transmit_status_get(env->can, (can_tx_mailbox_num_type) transmit_mailbox) != - CAN_TX_STATUS_SUCCESSFUL) { - - if (!((timeout == SystemWaitForever) || (endMs > SystemGetMs()))) { - return sent; - } - -// if ((can_flag_get(env->can, CAN_BOF_FLAG) != RESET) || -// (can_flag_get(env->can, CAN_EPF_FLAG) != RESET) || -// (can_flag_get(env->can, CAN_EAF_FLAG) != RESET)) { -// return sent; -// } - - } - - sent += 8; - size -= 8; - } - - if (tailSize) { - TxMessage.dlc = tailSize; - memcpy(TxMessage.data, &data[len], tailSize); - - transmit_mailbox = can_message_transmitExt(env->can, &TxMessage, CAN_TX_MAILBOX0); - - can_transmit_status_type status = can_transmit_status_get(env->can, - (can_tx_mailbox_num_type) transmit_mailbox); - - while (status != CAN_TX_STATUS_SUCCESSFUL) { - - status = can_transmit_status_get(env->can, (can_tx_mailbox_num_type) transmit_mailbox); - - if (!((timeout == SystemWaitForever) || (endMs > SystemGetMs()))) { - return sent; - } - - } - - sent += tailSize; - size -= tailSize; - } - - } -*/ return sent; } + tSerialPortFrameIO CanPortFrame_GetIo(tCanSerialPortFrameFlagchip *env) { tSerialPortFrameIO io = { .env = env,