S32 Design Studio PE工具配置canCom

工具配置

基本就是默认配置就行，有需要的话就按照下面的方式改改。

生成代码

在Generated_Code/canCom1.c里面，对应刚才配置的信息。canCom1_InitConfig0是配置结构体，canCom1_State是初始化之后的状态结构体。

flexcan_state_t canCom1_State; const flexcan_user_config_t canCom1_InitConfig0 = {.fd_enable = false,.pe_clock = FLEXCAN_CLK_SOURCE_OSC,.max_num_mb = 32,.num_id_filters = FLEXCAN_RX_FIFO_ID_FILTERS_32,.is_rx_fifo_needed = true,.flexcanMode = FLEXCAN_NORMAL_MODE,.payload = FLEXCAN_PAYLOAD_SIZE_8,.bitrate = {.propSeg = 7,.phaseSeg1 = 3,.phaseSeg2 = 2,.preDivider = 0,.rJumpwidth = 1},.bitrate_cbt = {.propSeg = 7,.phaseSeg1 = 3,.phaseSeg2 = 2,.preDivider = 0,.rJumpwidth = 1},.transfer_type = FLEXCAN_RXFIFO_USING_INTERRUPTS,.rxFifoDMAChannel = 0U
};

接口使用

FLEXCAN_DRV_SetBitrate

设置波特率

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_SetBitrate* Description   : Set FlexCAN baudrate.* This function will set up all the time segment values for classical frames or the* extended time segments for the arbitration phase of FD frames. Those time segment* values are passed in by the user and are based on the required baudrate.** Implements    : FLEXCAN_DRV_SetBitrate_Activity*END**************************************************************************/
void FLEXCAN_DRV_SetBitrate(uint8_t instance, const flexcan_time_segment_t *bitrate)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);DEV_ASSERT(bitrate != NULL);CAN_Type * base = g_flexcanBase[instance];
#if FEATURE_CAN_HAS_FDbool fdEnabled = FLEXCAN_IsFDEnabled(base);
#endifFLEXCAN_EnterFreezeMode(base);#if FEATURE_CAN_HAS_FDif (fdEnabled){/* Set extended time segments*/FLEXCAN_SetExtendedTimeSegments(base, bitrate);}else
#endif{/* Set time segments*/FLEXCAN_SetTimeSegments(base, bitrate);}FLEXCAN_ExitFreezeMode(base);
}

FLEXCAN_DRV_GetBitrate

获取波特率

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_GetBitrate* Description   : Get FlexCAN baudrate.* This function will be return the current bit rate settings for classical frames* or the arbitration phase of FD frames.** Implements    : FLEXCAN_DRV_GetBitrate_Activity*END**************************************************************************/
void  FLEXCAN_DRV_GetBitrate(uint8_t instance, flexcan_time_segment_t *bitrate)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);DEV_ASSERT(bitrate != NULL);const CAN_Type * base = g_flexcanBase[instance];/* Get the time segments*/FLEXCAN_GetTimeSegments(base, bitrate);}

FLEXCAN_DRV_SetRxMaskType

设置接收掩码类型

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_SetMasktype* Description   : Set RX masking type.* This function will set RX masking type as RX global mask or RX individual* mask.** Implements    : FLEXCAN_DRV_SetRxMaskType_Activity*END**************************************************************************/
void  FLEXCAN_DRV_SetRxMaskType(uint8_t instance, flexcan_rx_mask_type_t type)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);CAN_Type * base = g_flexcanBase[instance];FLEXCAN_EnterFreezeMode(base);FLEXCAN_SetRxMaskType(base, type);FLEXCAN_ExitFreezeMode(base);
}

FLEXCAN_DRV_SetRxFifoGlobalMask

设置接收队列掩码

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_SetRxFifoGlobalMask* Description   : Set Rx FIFO global mask as the 11-bit standard mask or the* 29-bit extended mask.** Implements    : FLEXCAN_DRV_SetRxFifoGlobalMask_Activity*END**************************************************************************/
void FLEXCAN_DRV_SetRxFifoGlobalMask(uint8_t instance,flexcan_msgbuff_id_type_t id_type,uint32_t mask)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);flexcan_rx_fifo_id_element_format_t formatType;CAN_Type * base = g_flexcanBase[instance];uint32_t calcMask = 0U;FLEXCAN_EnterFreezeMode(base);if (true == FLEXCAN_IsRxFifoEnabled(base)){formatType = FLEXCAN_GetRxFifoIdFormat(base);calcMask = FLEXCAN_GetRxFifoMask(id_type, formatType, mask);switch (formatType){case FLEXCAN_RX_FIFO_ID_FORMAT_A :FLEXCAN_SetRxFifoGlobalMask(base, calcMask);break;case FLEXCAN_RX_FIFO_ID_FORMAT_B :FLEXCAN_SetRxFifoGlobalMask(base, (calcMask | (calcMask >> FLEXCAN_RX_FIFO_ID_FILTER_FORMATB_EXT_SHIFT1)));break;case FLEXCAN_RX_FIFO_ID_FORMAT_C :FLEXCAN_SetRxFifoGlobalMask(base, (calcMask | (calcMask >> FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT1) |(calcMask >> FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT2) |(calcMask >> FLEXCAN_RX_FIFO_ID_FILTER_FORMATC_SHIFT3)));break;default :/* Will Enable all filter fields mask */FLEXCAN_SetRxFifoGlobalMask(base, 0xFFFFFFFFU);break;}}FLEXCAN_ExitFreezeMode(base);
}

FLEXCAN_DRV_SetRxMbGlobalMask

设置接收报文缓冲区的掩码

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_SetRxMbGlobalMask* Description   : Set Rx Message Buffer global mask as the 11-bit standard mask* or the 29-bit extended mask.** Implements    : FLEXCAN_DRV_SetRxMbGlobalMask_Activity*END**************************************************************************/
void FLEXCAN_DRV_SetRxMbGlobalMask(uint8_t instance,flexcan_msgbuff_id_type_t id_type,uint32_t mask)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);CAN_Type * base = g_flexcanBase[instance];FLEXCAN_EnterFreezeMode(base);if (id_type == FLEXCAN_MSG_ID_STD){/* Set standard global mask for RX MB*/FLEXCAN_SetRxMsgBuffGlobalStdMask(base, mask);}else if (id_type == FLEXCAN_MSG_ID_EXT){/* Set extended global mask for RX MB*/FLEXCAN_SetRxMsgBuffGlobalExtMask(base, mask);}else {/* Should not get here */}FLEXCAN_ExitFreezeMode(base);
}

FLEXCAN_DRV_Init

初始化接口

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_Init* Description   : Initialize FlexCAN driver.* This function will select a source clock, reset FlexCAN module, set maximum* number of message buffers, initialize all message buffers as inactive, enable* RX FIFO if needed, mask all mask bits, disable all MB interrupts, enable* FlexCAN normal mode, and enable all the error interrupts if needed.** Implements    : FLEXCAN_DRV_Init_Activity*END**************************************************************************/
status_t FLEXCAN_DRV_Init(uint8_t instance,flexcan_state_t *state,const flexcan_user_config_t *data)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);DEV_ASSERT(state != NULL);DEV_ASSERT(g_flexcanStatePtr[instance] == NULL);
#ifdef ERRATA_E10595if (instance != 0U){DEV_ASSERT((MC_ME->GS & MC_ME_GS_S_FXOSC_MASK) != 0U);}
#endifstatus_t result;CAN_Type * base = g_flexcanBase[instance];flexcan_time_segment_t bitrate;status_t osifStat;uint32_t i, j;if(FLEXCAN_IsEnabled(base)){/* To enter Disable Mode requires FreezMode first */FLEXCAN_EnterFreezeMode(base);FLEXCAN_Disable(base);}#if FEATURE_CAN_HAS_PE_CLKSRC_SELECT/* Select a source clock for the FlexCAN engine */FLEXCAN_SelectClock(base, data->pe_clock);
#endif/* Enable the CAN clock */FLEXCAN_Enable(base);FLEXCAN_EnterFreezeMode(base);/* Initialize FLEXCAN device */FLEXCAN_Init(base);#ifdef ERRATA_E10368
#if FEATURE_CAN_HAS_FDFLEXCAN_Errata10368(instance, data);
#endif /* FEATURE_CAN_HAS_FD */
#endif /* ERRATA_E10368 */#if FEATURE_CAN_HAS_FD/* Enable/Disable FD and check FD was set as expected. Setting FD as enabled* might fail if the current CAN instance does not support FD. */FLEXCAN_SetFDEnabled(base, data->fd_enable);if (FLEXCAN_IsFDEnabled(base) != data->fd_enable){return STATUS_ERROR;}/* If the FD feature is enabled, enable the Stuff Bit Count, in order to be* ISO-compliant. */FLEXCAN_SetStuffBitCount(base, data->fd_enable);
#endif/* Disable the self reception feature if FlexCAN is not in loopback mode. */if (data->flexcanMode != FLEXCAN_LOOPBACK_MODE){FLEXCAN_SetSelfReception(base, false);}/* Enable RxFIFO feature, if requested. This might fail if the FD mode is* enabled. */if (data->is_rx_fifo_needed){result = FLEXCAN_EnableRxFifo(base, (uint32_t)data->num_id_filters);if (result != STATUS_SUCCESS){return result;}}#if FEATURE_CAN_HAS_DMA_ENABLE/* Enable DMA support for RxFIFO transfer, if requested. */if (data->transfer_type == FLEXCAN_RXFIFO_USING_DMA){if (FLEXCAN_IsRxFifoEnabled(base)){FLEXCAN_SetRxFifoDMA(base, true);}else{return STATUS_ERROR;}}if (data->transfer_type == FLEXCAN_RXFIFO_USING_INTERRUPTS){FLEXCAN_SetRxFifoDMA(base, false);}
#endif#if FEATURE_CAN_HAS_FD/* Set payload size. */FLEXCAN_SetPayloadSize(base, data->payload);
#endifresult = FLEXCAN_SetMaxMsgBuffNum(base, data->max_num_mb);if (result != STATUS_SUCCESS){return result;}#if FEATURE_CAN_HAS_FD/* Set bit rate. */if (FLEXCAN_IsFDEnabled(base)){bitrate = data->bitrate;FLEXCAN_SetExtendedTimeSegments(base, &bitrate);bitrate = data->bitrate_cbt;FLEXCAN_SetFDTimeSegments(base, &bitrate);}else
#endif{bitrate = data->bitrate;FLEXCAN_SetTimeSegments(base, &bitrate);}/* Select mode */FLEXCAN_SetOperationMode(base, data->flexcanMode);if (data->flexcanMode != FLEXCAN_FREEZE_MODE){FLEXCAN_ExitFreezeMode(base);}/* Enable FlexCAN interrupts.*/FLEXCAN_EnableIRQs(instance);for (i = 0; i < FEATURE_CAN_MAX_MB_NUM; i++){osifStat = OSIF_SemaCreate(&state->mbs[i].mbSema, 0U);if (osifStat != STATUS_SUCCESS){for (j = 0; j < i; j++){(void)OSIF_SemaDestroy(&state->mbs[j].mbSema);}return STATUS_ERROR;}state->mbs[i].isBlocking = false;state->mbs[i].mb_message = NULL;state->mbs[i].state = FLEXCAN_MB_IDLE;}
#if FEATURE_CAN_HAS_MEM_ERR_DETFLEXCAN_DisableMemErrorDetection(base);
#endif/* Store transfer type and DMA channel number used in transfer */state->transferType = data->transfer_type;
#if FEATURE_CAN_HAS_DMA_ENABLEstate->rxFifoDMAChannel = data->rxFifoDMAChannel;
#endif/* Clear Callbacks in case of autovariables garbage */state->callback = NULL;state->callbackParam = NULL;state->error_callback = NULL;state->errorCallbackParam = NULL;/* Save runtime structure pointers so irq handler can point to the correct state structure */g_flexcanStatePtr[instance] = state;return (STATUS_SUCCESS);
}

FLEXCAN_DRV_Deinit

逆初始化

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_Deinit* Description   : Shutdown a FlexCAN module.* This function will disable all FlexCAN interrupts, and disable the FlexCAN.** Implements    : FLEXCAN_DRV_Deinit_Activity*END**************************************************************************/
status_t FLEXCAN_DRV_Deinit(uint8_t instance)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);CAN_Type * base = g_flexcanBase[instance];const flexcan_state_t * state = g_flexcanStatePtr[instance];status_t result = STATUS_SUCCESS;status_t osifStat;uint32_t i;/* Disable FlexCAN interrupts.*/if (state != NULL){if (state->error_callback != NULL){FLEXCAN_SetErrIntCmd(base, FLEXCAN_INT_ERR, false);FLEXCAN_SetErrIntCmd(base, FLEXCAN_INT_RX_WARNING, false);FLEXCAN_SetErrIntCmd(base, FLEXCAN_INT_TX_WARNING, false);FLEXCAN_SetErrIntCmd(base, FLEXCAN_INT_BUSOFF, false);}}#if FEATURE_CAN_HAS_WAKE_UP_IRQif (g_flexcanWakeUpIrqId[instance] != NotAvail_IRQn){INT_SYS_DisableIRQ(g_flexcanWakeUpIrqId[instance]);}
#endifINT_SYS_DisableIRQ(g_flexcanErrorIrqId[instance]);INT_SYS_DisableIRQ(g_flexcanBusOffIrqId[instance]);for (i = 0; i < FEATURE_CAN_MB_IRQS_MAX_COUNT; i++){if (g_flexcanOredMessageBufferIrqId[i][instance] != NotAvail_IRQn){INT_SYS_DisableIRQ(g_flexcanOredMessageBufferIrqId[i][instance]);}}if(FLEXCAN_IsEnabled(g_flexcanBase[instance])){/* Enter Freeze Mode Required before to enter Disabled Mode */FLEXCAN_EnterFreezeMode(g_flexcanBase[instance]);/* Disable FlexCAN.*/FLEXCAN_Disable(g_flexcanBase[instance]);/* Check if the state have been initialized */}if (state != NULL){for (i = 0; i < FEATURE_CAN_MAX_MB_NUM; i++){osifStat = OSIF_SemaDestroy(&state->mbs[i].mbSema);if (osifStat != STATUS_SUCCESS){result = STATUS_ERROR;}}}if (result == STATUS_SUCCESS){/* Clear state pointer that is checked by FLEXCAN_DRV_Init */g_flexcanStatePtr[instance] = NULL;}return result;
}

FLEXCAN_DRV_ConfigTxMb

配置发送报文缓存区，入参为索引、缓存区ID、数据信息结构体、报文ID。

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_ConfigTxMb* Description   : Configure a Tx message buffer.* This function will first check if RX FIFO is enabled. If RX FIFO is enabled,* the function will make sure if the MB requested is not occupied by RX FIFO* and ID filter table. Then this function will set up the message buffer fields,* configure the message buffer code for Tx buffer as INACTIVE, and enable the* Message Buffer interrupt.** Implements    : FLEXCAN_DRV_ConfigTxMb_Activity*END**************************************************************************/
status_t FLEXCAN_DRV_ConfigTxMb(uint8_t instance,uint8_t mb_idx,const flexcan_data_info_t *tx_info,uint32_t msg_id)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);DEV_ASSERT(tx_info != NULL);flexcan_msgbuff_code_status_t cs;CAN_Type * base = g_flexcanBase[instance];/* Initialize transmit mb*/cs.dataLen = tx_info->data_length;cs.msgIdType = tx_info->msg_id_type;
#if FEATURE_CAN_HAS_FDcs.enable_brs = tx_info->enable_brs;cs.fd_enable = tx_info->fd_enable;cs.fd_padding = tx_info->fd_padding;
#endifcs.code = (uint32_t)FLEXCAN_TX_INACTIVE;return FLEXCAN_SetTxMsgBuff(base, mb_idx, &cs, msg_id, NULL);
}

FLEXCAN_DRV_SendBlocking

阻塞发送

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_SendBlocking* Description   : This function sends a CAN frame using a configured message* buffer. The function blocks until either the frame was sent, or the specified* timeout expired.** Implements    : FLEXCAN_DRV_SendBlocking_Activity*END**************************************************************************/
status_t FLEXCAN_DRV_SendBlocking(uint8_t instance,uint8_t mb_idx,const flexcan_data_info_t *tx_info,uint32_t msg_id,const uint8_t *mb_data,uint32_t timeout_ms)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);DEV_ASSERT(tx_info != NULL);status_t result;flexcan_state_t * state = g_flexcanStatePtr[instance];CAN_Type * base  = g_flexcanBase[instance];result = FLEXCAN_StartSendData(instance, mb_idx, tx_info, msg_id, mb_data, true);if (result == STATUS_SUCCESS){status_t status;/* Enable message buffer interrupt*/(void)FLEXCAN_SetMsgBuffIntCmd(base, mb_idx, true);status = OSIF_SemaWait(&state->mbs[mb_idx].mbSema, timeout_ms);if (status == STATUS_TIMEOUT){if (state->mbs[mb_idx].state != FLEXCAN_MB_IDLE){/* Disable message buffer interrupt */(void)FLEXCAN_SetMsgBuffIntCmd(base, mb_idx, false);/* Clear message buffer flag */FLEXCAN_ClearMsgBuffIntStatusFlag(base, mb_idx);FLEXCAN_AbortTxMsgBuff(base, mb_idx);uint32_t flexcan_mb_config;#ifndef ERRATA_E9527/* Wait to finish abort operation */while(FLEXCAN_GetBuffStatusFlag(base, mb_idx) == 0U){/* Do Nothing wait for the flag */}
#endifvolatile const uint32_t *flexcan_mb = FLEXCAN_GetMsgBuffRegion(base, mb_idx);flexcan_mb_config = * flexcan_mb;/* Check if the MBs have been safely Inactivated */if (((flexcan_mb_config & CAN_CS_CODE_MASK) >> CAN_CS_CODE_SHIFT) == (uint32_t)FLEXCAN_TX_INACTIVE){
#ifndef ERRATA_E9527/* Transmission have occurred */result = STATUS_SUCCESS;
#else/* Transmission have not occurred because it uses the inactivation operation */if (FLEXCAN_GetBuffStatusFlag(base, mb_idx) == 0U){result = STATUS_TIMEOUT;}else{result = STATUS_SUCCESS;}
#endif}if (((flexcan_mb_config & CAN_CS_CODE_MASK) >> CAN_CS_CODE_SHIFT) == (uint32_t)FLEXCAN_TX_ABORT){/* Transmission have occurred */result = STATUS_TIMEOUT;}/* Clear message buffer flag */FLEXCAN_ClearMsgBuffIntStatusFlag(base, mb_idx);state->mbs[mb_idx].state = FLEXCAN_MB_IDLE;}}}return result;
}

FLEXCAN_DRV_Send

普通发送，入参就是索引、报文缓存区ID、发送信息、报文ID、缓存区数据。

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_Send* Description   : This function sends a CAN frame using a configured message* buffer. The function returns immediately. If a callback is installed, it will* be invoked after the frame was sent.** Implements    : FLEXCAN_DRV_Send_Activity*END**************************************************************************/
status_t FLEXCAN_DRV_Send(uint8_t instance,uint8_t mb_idx,const flexcan_data_info_t *tx_info,uint32_t msg_id,const uint8_t *mb_data)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);DEV_ASSERT(tx_info != NULL);status_t result;CAN_Type * base = g_flexcanBase[instance];result = FLEXCAN_StartSendData(instance, mb_idx, tx_info, msg_id, mb_data, false);if(result == STATUS_SUCCESS){/* Enable message buffer interrupt*/result = FLEXCAN_SetMsgBuffIntCmd(base, mb_idx, true);}return result;
}

FLEXCAN_DRV_ReceiveBlocking

阻塞接收

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_ReceiveBlocking* Description   : This function receives a CAN frame into a configured message* buffer. The function blocks until either a frame was received, or the* specified timeout expired.** Implements    : FLEXCAN_DRV_ReceiveBlocking_Activity*END**************************************************************************/
status_t FLEXCAN_DRV_ReceiveBlocking(uint8_t instance,uint8_t mb_idx,flexcan_msgbuff_t *data,uint32_t timeout_ms)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);status_t result;flexcan_state_t * state = g_flexcanStatePtr[instance];CAN_Type * base = g_flexcanBase[instance];result = FLEXCAN_StartRxMessageBufferData(instance, mb_idx, data, true);if(result == STATUS_SUCCESS){status_t status;status = OSIF_SemaWait(&state->mbs[mb_idx].mbSema, timeout_ms);if (status == STATUS_TIMEOUT){/* If the flag is set Successful reception else report TimeOut */if(FLEXCAN_GetMsgBuffIntStatusFlag(base,mb_idx) == (uint8_t)0U){result = STATUS_TIMEOUT;}/* Disable message buffer interrupt */(void)FLEXCAN_SetMsgBuffIntCmd(base, mb_idx, false);}/* Consider the MB state has been changed by interrupt as frame received */ if (state->mbs[mb_idx].state == FLEXCAN_MB_IDLE){return STATUS_SUCCESS;}state->mbs[mb_idx].state = FLEXCAN_MB_IDLE;}return result;
}

FLEXCAN_DRV_Receive

普通接收

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_Receive* Description   : This function receives a CAN frame into a configured message* buffer. The function returns immediately. If a callback is installed, it will* be invoked after the frame was received and read into the specified buffer.** Implements    : FLEXCAN_DRV_Receive_Activity*END**************************************************************************/
status_t FLEXCAN_DRV_Receive(uint8_t instance,uint8_t mb_idx,flexcan_msgbuff_t *data)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);status_t result;result = FLEXCAN_StartRxMessageBufferData(instance, mb_idx, data, false);return result;
}

FLEXCAN_DRV_RxFifoBlocking

阻塞接收到FIFO里面

/*FUNCTION************************************************************************ Function Name : FLEXCAN_DRV_RxFifoBlocking* Description   : This function receives a CAN frame using the Rx FIFO. The* function blocks until either a frame was received, or the specified timeout* expired.** Implements    : FLEXCAN_DRV_RxFifoBlocking_Activity*END**************************************************************************/
status_t FLEXCAN_DRV_RxFifoBlocking(uint8_t instance,flexcan_msgbuff_t *data,uint32_t timeout_ms)
{DEV_ASSERT(instance < CAN_INSTANCE_COUNT);status_t result;flexcan_state_t * state = g_flexcanStatePtr[instance];CAN_Type * base = g_flexcanBase[instance];result = FLEXCAN_StartRxMessageFifoData(instance, data, true);if (result == STATUS_SUCCESS){result = OSIF_SemaWait(&state->mbs[FLEXCAN_MB_HANDLE_RXFIFO].mbSema, timeout_ms);if (result == STATUS_TIMEOUT){/* If the status is updated reception successful else report TimeOut */if (state->mbs[FLEXCAN_MB_HANDLE_RXFIFO].state == FLEXCAN_MB_IDLE){result = STATUS_SUCCESS;}/* Disable RX FIFO interrupts*/(void)FLEXCAN_SetMsgBuffIntCmd(base, FEATURE_CAN_RXFIFO_FRAME_AVAILABLE, false);(void)FLEXCAN_SetMsgBuffIntCmd(base, FEATURE_CAN_RXFIFO_WARNING, false);(void)FLEXCAN_SetMsgBuffIntCmd(base, FEATURE_CAN_RXFIFO_OVERFLOW, false);#if FEATURE_CAN_HAS_DMA_ENABLE/* Check if transfer is done over DMA and stop transfer */if ((state->mbs[FLEXCAN_MB_HANDLE_RXFIFO].state == FLEXCAN_MB_RX_BUSY) && (state->transferType == FLEXCAN_RXFIFO_USING_DMA)){/* This function always return status success */(void)EDMA_DRV_StopChannel(state->rxFifoDMAChannel);}
#endif}state->mbs[FLEXCAN_MB_HANDLE_RXFIFO].state = FLEXCAN_MB_IDLE;}return result;
}