HAL_Lib/Src/hal_can.c

////////////////////////////////////////////////////////////////////////////////
/// @file     hal_can.c
/// @author   AE TEAM
/// @brief    THIS FILE PROVIDES ALL THE CAN FIRMWARE FUNCTIONS.
////////////////////////////////////////////////////////////////////////////////
/// @attention
///
/// THE EXISTING FIRMWARE IS ONLY FOR REFERENCE, WHICH IS DESIGNED TO PROVIDE
/// CUSTOMERS WITH CODING INFORMATION ABOUT THEIR PRODUCTS SO THEY CAN SAVE
/// TIME. THEREFORE, MINDMOTION SHALL NOT BE LIABLE FOR ANY DIRECT, INDIRECT OR
/// CONSEQUENTIAL DAMAGES ABOUT ANY CLAIMS ARISING OUT OF THE CONTENT OF SUCH
/// HARDWARE AND/OR THE USE OF THE CODING INFORMATION CONTAINED HEREIN IN
/// CONNECTION WITH PRODUCTS MADE BY CUSTOMERS.
///
/// <H2><CENTER>&COPY; COPYRIGHT MINDMOTION </CENTER></H2>
////////////////////////////////////////////////////////////////////////////////

// Define to prevent recursive inclusion
#define __HAL_CAN_C

// Files includes
#include "hal_can.h"
#include "hal_rcc.h"

////////////////////////////////////////////////////////////////////////////////
/// @addtogroup MM32_Hardware_Abstract_Layer
/// @{

////////////////////////////////////////////////////////////////////////////////
/// @addtogroup CAN_HAL
/// @{

////////////////////////////////////////////////////////////////////////////////
/// @addtogroup CAN_Exported_Functions
/// @{


////////////////////////////////////////////////////////////////////////////////
/// @brief  Deinitializes the CAN peripheral registers to their default reset
/// values.
/// @param  can: select the CAN peripheral.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_DeInit(CAN_TypeDef* can)
{
    exRCC_APB1PeriphReset(RCC_APB1ENR_CAN);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief   Initializes the CAN peripheral according to the specified
///          parameters in the CAN_InitStruct.
/// @param   can: select the CAN peripheral.
/// @param   CAN_InitStruct: pointer to a CAN_InitTypeDef structure that
///          contains the configuration information for the CAN peripheral.
/// @retval  Constant indicates initialization succeed which will be
///          CANINITFAILED or CANINITOK.
////////////////////////////////////////////////////////////////////////////////
u8 CAN_Init(CAN_TypeDef* can, CAN_Basic_InitTypeDef* init_struct)
{
    u8 InitStatus = CANINITFAILED;

    can->BTR0 = ((u32)(init_struct->SJW) << 6) | ((u32)(init_struct->BRP));
    can->BTR1 = ((u32)(init_struct->SAM) << 7) | ((u32)(init_struct->TESG2) << 4) | ((u32)(init_struct->TESG1));

    if (init_struct->GTS == ENABLE) {
        can->CMR |= (u32)CAN_SleepMode;
        InitStatus = CANINITFAILED;
    }
    else {
        can->CMR &= ~(u32)CAN_SleepMode;
        InitStatus = CANINITOK;
    }

    (init_struct->GTS == ENABLE) ? (can->CMR |= (u32)CAN_SleepMode) : (can->CMR &= ~(u32)CAN_SleepMode);

    can->CDR |=
        ((init_struct->CBP) << 6) | ((init_struct->RXINTEN) << 5) | ((init_struct->CLOSE_OPEN_CLK) << 3) | (init_struct->CDCLK);

    return InitStatus;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Configures the CAN_Basic reception filter according to the specified
///         parameters in the basic_filter_init_struct.
/// @param  basic_filter_init_struct: pointer to a CAN_Basic_FilterInitTypeDef
///         structure that contains the configuration information.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_FilterInit(CAN_Basic_FilterInitTypeDef* basic_filter_init_struct)
{
    // Filter Mode
    CAN1->ACR = basic_filter_init_struct->CAN_FilterId;
    CAN1->AMR = basic_filter_init_struct->CAN_FilterMaskId;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Fills each init_struct member with its default value.
/// @param  init_struct : pointer to a CAN_Basic_InitTypeDef structure which will be initialized.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_StructInit(CAN_Basic_InitTypeDef* init_struct)
{
    // Reset CAN_Basic init structure parameters values

    // initialize the BRP member(where can be set with (0..63))
    init_struct->BRP = 0x0;
    // initialize the SJW member(where can be set with (0..3))
    init_struct->SJW = 0x0;
    // Initialize the TESG1 member(where can be set with (0..15))
    init_struct->TESG1 = 0x0;
    // Initialize the TESG2 member(where can be set with(0..7))
    init_struct->TESG2 = 0x0;
    // Initialize the SAM member(where can be set (SET or RESET))
    init_struct->SAM = RESET;
    // Initialize the GTS member to Sleep Mode(where can be set (ENABLE or
    // DISABLE))
    init_struct->GTS = DISABLE;
    // Initialize the external pin CLKOUT frequence
    init_struct->CDCLK = 0x0;
    // Initialize the external clk is open or close
    init_struct->CLOSE_OPEN_CLK = 0x0;
    // Initialize the TX1 pin work as rx interrupt output
    init_struct->RXINTEN = 0x0;
    // Initialize the CBP of CDR register
    init_struct->CBP = 0x0;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Enables or disables the specified CAN interrupts.
/// @param  can:  select the CAN peripheral.
/// @param  it: specifies the CAN interrupt sources to be enabled or
///         disabled.
///         This parameter can be: CAN_IT_OIE, CAN_IT_EIE, CAN_IT_TIE,
///         CAN_IT_RIE.
/// @param  state: new state of the CAN interrupts.
///         This parameter can be: ENABLE or DISABLE.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_ITConfig(CAN_TypeDef* can, u32 it, FunctionalState state)
{
    (state) ? (can->CR |= it) : (can->CR &= ~it);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Initiates and transmits a CAN frame message.
/// @param  can:select the CAN peripheral.
/// @param  TxMessage: pointer to a structure which contains CAN Id, CAN DLC and
///         CAN data.
/// @retval CANTXOK if the CAN driver transmits the message
////////////////////////////////////////////////////////////////////////////////
u8 CAN_Transmit(CAN_TypeDef* can, CanBasicTxMsg* basic_transmit_message)
{
    can->TXID0 = (basic_transmit_message->IDH);
    can->TXID1 = (basic_transmit_message->IDL << 5) | (basic_transmit_message->RTR << 4) | (basic_transmit_message->DLC);
    if ((FunctionalState)(basic_transmit_message->RTR) != ENABLE) {
        can->TXDR0 = basic_transmit_message->Data[0];
        can->TXDR1 = basic_transmit_message->Data[1];
        can->TXDR2 = basic_transmit_message->Data[2];
        can->TXDR3 = basic_transmit_message->Data[3];
        can->TXDR4 = basic_transmit_message->Data[4];
        can->TXDR5 = basic_transmit_message->Data[5];
        can->TXDR6 = basic_transmit_message->Data[6];
        can->TXDR7 = basic_transmit_message->Data[7];
    }

    can->CMR = CAN_CMR_TR;

    return (can->SR & 0x01);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Cancels a transmit request.
/// @param  can: select the CAN peripheral.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_CancelTransmit(CAN_TypeDef* can)
{
    // abort transmission
    can->CMR = CAN_AT;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Releases the specified receive FIFO.
/// @param  can: select the CAN peripheral.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_FIFORelease(CAN_TypeDef* can)
{
    // Release FIFO
    can->CMR |= (u32)CAN_RRB;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Receives a correct CAN frame.
/// @param  can: select the CAN peripheral.
/// @param  RxMessage: pointer to a structure receive frame which contains CAN
///         Id,CAN DLC, CAN data and FMI number.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Receive(CAN_TypeDef* can, CanBasicRxMsg* basic_receive_message)
{
    u16 tempid;

    basic_receive_message->RTR = (u8)((can->RXID1) >> 4) & 0x1;
    basic_receive_message->DLC = (u8)((can->RXID1) & 0xf);
    tempid              = (u16)(((can->RXID1) & 0xe0) >> 5);
    tempid |= (u16)(can->RXID0 << 3);
    basic_receive_message->ID      = tempid;
    basic_receive_message->Data[0] = CAN1->RXDR0;
    basic_receive_message->Data[1] = CAN1->RXDR1;
    basic_receive_message->Data[2] = CAN1->RXDR2;
    basic_receive_message->Data[3] = CAN1->RXDR3;
    basic_receive_message->Data[4] = CAN1->RXDR4;
    basic_receive_message->Data[5] = CAN1->RXDR5;
    basic_receive_message->Data[6] = CAN1->RXDR6;
    basic_receive_message->Data[7] = CAN1->RXDR7;
    CAN_FIFORelease(can);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Select the Sleep mode or not in Basic workmode
/// @param  state to go into the Sleep mode or go out
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
u8 CAN_Sleep(CAN_TypeDef* can)
{
    can->CMR |= CAN_SleepMode;
    // At this step, sleep mode status
    return (u8)((can->CMR & 0x10) == CAN_SleepMode) ? CANSLEEPOK : CANSLEEPFAILED;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Wakes the CAN up.
/// @param  can: where x can be 1 to select the CAN peripheral.
/// @retval CANWAKEUPOK if sleep mode left, CANWAKEUPFAILED in an other case.
////////////////////////////////////////////////////////////////////////////////
u8 CAN_WakeUp(CAN_TypeDef* can)
{
    // Wake up request
    can->CMR &= ~CAN_SleepMode;
    return (u8)((can->CMR & 0x01) == 0) ? CANWAKEUPOK : CANWAKEUPFAILED;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Checks whether the specified CAN flag is set or not.
/// @param  can: select the CAN peripheral.
/// @param  flag: specifies the flag to check.
///         This parameter can be one of the following values:
///            @arg CAN_STATUS_RBS: Receive buffer status
///            @arg CAN_STATUS_DOS: Data overflow status
///            @arg CAN_STATUS_TBS: Transmit buffer status
///            @arg CAN_STATUS_TCS: Transmit complete status
///            @arg CAN_STATUS_RS: Receiving status
///            @arg CAN_STATUS_TS: Transmiting status
///            @arg CAN_STATUS_ES: Error status
///            @arg CAN_STATUS_BS: bus status, close or open
/// @retval The new state of CAN_FLAG (SET or RESET).
////////////////////////////////////////////////////////////////////////////////
FlagStatus CAN_GetFlagStatus(CAN_TypeDef* can, u32 flag)
{
    return (FlagStatus)(((can->SR & flag) == flag) ? SET : RESET);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Checks whether the specified CAN interrupt has occurred or not.
/// @param  can: where x can be 1 to select the CAN peripheral.
/// @param  it: specifies the CAN interrupt source to check.
///         This parameter can be one of the following values:
///            @arg CAN_IT_RI: Receive FIFO not empty Interrupt
///            @arg CAN_IT_TI: Transmit Interrupt
///            @arg CAN_IT_EI: ERROR Interrupt
///            @arg CAN_IT_DOI: Data voerflow Interrupt
///            @arg CAN_IT_WUI: Wakeup Interrupt
///            @arg CAN_IT_ALL: use it can enble all Interrupt
/// @retval The current state of it (SET or RESET).
////////////////////////////////////////////////////////////////////////////////
ITStatus CAN_GetITStatus(CAN_TypeDef* can, u32 it)
{
    return (ITStatus)((can->IR & it) != it) ? RESET : SET;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Select the can work as peli mode or basic mode
/// @param  can: where x can be 1 or 2 to to select the CAN peripheral.
/// @param  CAN_MODE: specifies the work mode:CAN_BASICMode,CAN_PELIMode
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Mode_Cmd(CAN_TypeDef* can, u32 mode)
{
    can->CDR |= mode;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Select the Reset mode or not
/// @param  can: where x can be 1 or 2 to to select the CAN peripheral.
/// @param  state to go into the Reset mode or go out
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_ResetMode_Cmd(CAN_TypeDef* can, FunctionalState state)
{
    (state == ENABLE) ? (can->CR |= CAN_ResetMode) : (can->CR &= ~CAN_ResetMode);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Clear the data overflow.
/// @param  can: where x can be 1 or 2 to to select the CAN peripheral.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_ClearDataOverflow(CAN_TypeDef* can)
{
    can->CMR |= (u32)CAN_CDO;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Clears the CAN's IT pending.
/// @param  can: where x can be 1 or 2 to to select the CAN peripheral.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_ClearITPendingBit(CAN_TypeDef* can)
{
    u32 temp = 0;
    temp     = temp;
    temp     = can->IR;  // read this register clear all interrupt
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Select the Sleep mode or not in Peli workmode
/// @param  state to go into the Sleep mode or go out
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Peli_SleepMode_Cmd(FunctionalState state)
{
    (state == ENABLE) ? (CAN1_PELI->MOD |= CAN_SleepMode) : (CAN1_PELI->MOD &= ~CAN_SleepMode);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Fills each CAN1_PELI_InitStruct member with its default value.
/// @param  init_struct : pointer to a CAN_Peli_InitTypeDef structure
///         which will be initialized.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Peli_StructInit(CAN_Peli_InitTypeDef* init_struct)
{
    //--------------- Reset CAN_Peli init structure parameters values
    //---------------
    init_struct->BRP   = 0x0;      // initialize the BRP member(where can be set with (0..63))
    init_struct->SJW   = 0x0;      // initialize the SJW member(where can be set with (0..3))
    init_struct->TESG1 = 0x0;      // Initialize the TESG1 member(where can be set with (0..15))
    init_struct->TESG2 = 0x0;      // Initialize the TESG2 member(where can be set with(0..7))
    init_struct->SAM   = RESET;    // Initialize the SAM member(where can be set (SET or RESET))
    init_struct->LOM   = DISABLE;  // Initialize the LOM member
    init_struct->STM   = DISABLE;  // Initialize the STM member
    init_struct->SM    = DISABLE;  // Initialize the SM member
    init_struct->SRR   = DISABLE;
    init_struct->EWLR  = 0x96;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Initializes the CAN_Peli peripheral according to the specified
///         parameters in the init_struct.
/// @param  init_struct: pointer to a CAN_Peli_InitTypeDef structure that
///         contains the configuration information for the CAN peripheral in the peli workmode.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Peli_Init(CAN_Peli_InitTypeDef* init_struct)
{
    CAN1_PELI->BTR0 = ((u32)init_struct->SJW << 6) | ((u32)init_struct->BRP);
    CAN1_PELI->BTR1 = ((u32)init_struct->SAM << 7) | ((u32)init_struct->TESG2 << 4) | ((u32)init_struct->TESG1);
    if (init_struct->LOM == ENABLE)
        CAN1_PELI->MOD |= (u32)CAN_ListenOnlyMode;
    else
        CAN1_PELI->MOD &= ~(u32)CAN_ListenOnlyMode;
    if (init_struct->STM == ENABLE)
        CAN1_PELI->MOD |= (u32)CAN_SeftTestMode;
    else
        CAN1_PELI->MOD &= ~(u32)CAN_SeftTestMode;
    if (init_struct->SM == ENABLE)
        CAN1_PELI->MOD |= (u32)CAN_SleepMode;
    else
        CAN1_PELI->MOD &= ~(u32)CAN_SleepMode;
    CAN1_PELI->EWLR = (u32)init_struct->EWLR;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Configures the CAN_Peli reception filter according to the specified
///         parameters in the peli_filter_init_struct.
/// @param  peli_filter_init_struct: pointer to a CAN_Peli_FilterInitTypeDef
///         structure that contains the configuration information.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Peli_FilterInit(CAN_Peli_FilterInitTypeDef* peli_filter_init_struct)
{
    (peli_filter_init_struct->AFM == CAN_FilterMode_Singal) ? (CAN1_PELI->MOD |= (u32)CAN_FilterMode_Singal)
    : (CAN1_PELI->MOD &= (u32)CAN_FilterMode_Double);

    CAN1_PELI->FF    = peli_filter_init_struct->CAN_FilterId0;
    CAN1_PELI->ID0   = peli_filter_init_struct->CAN_FilterId1;
    CAN1_PELI->ID1   = peli_filter_init_struct->CAN_FilterId2;
    CAN1_PELI->DATA0 = peli_filter_init_struct->CAN_FilterId3;

    CAN1_PELI->DATA1 = peli_filter_init_struct->CAN_FilterMaskId0;
    CAN1_PELI->DATA2 = peli_filter_init_struct->CAN_FilterMaskId1;
    CAN1_PELI->DATA3 = peli_filter_init_struct->CAN_FilterMaskId2;
    CAN1_PELI->DATA4 = peli_filter_init_struct->CAN_FilterMaskId3;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Fills each peli_filter_init_struct member with its default value.
/// @param  peli_filter_init_struct: pointer to a CAN_InitTypeDef structure
///         which ill be initialized.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Peli_FilterStructInit(CAN_Peli_FilterInitTypeDef* peli_filter_init_struct)
{
    peli_filter_init_struct->CAN_FilterId0 = 0;
    peli_filter_init_struct->CAN_FilterId1 = 0;
    peli_filter_init_struct->CAN_FilterId2 = 0;
    peli_filter_init_struct->CAN_FilterId3 = 0;

    peli_filter_init_struct->CAN_FilterMaskId0 = 0;
    peli_filter_init_struct->CAN_FilterMaskId1 = 0;
    peli_filter_init_struct->CAN_FilterMaskId2 = 0;
    peli_filter_init_struct->CAN_FilterMaskId3 = 0;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Initiates and transmits a CAN frame message.
/// @param  TxMessage: pointer to a structure which contains CAN Id, CAN DLC and
///         CAN data.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Peli_Transmit(CanPeliTxMsg* peli_transmit_message)
{
    CAN1_PELI->FF = (peli_transmit_message->FF << 7) | (peli_transmit_message->RTR << 6) | (peli_transmit_message->DLC);
    if (((FunctionalState)peli_transmit_message->FF) != ENABLE) {
        CAN1_PELI->ID0 = (peli_transmit_message->IDHH);

        CAN1_PELI->ID1 = (peli_transmit_message->IDHL & 0xE0);
        if ((FunctionalState)(peli_transmit_message->RTR) != ENABLE) {
            CAN1_PELI->DATA0 = peli_transmit_message->Data[0];
            CAN1_PELI->DATA1 = peli_transmit_message->Data[1];
            CAN1_PELI->DATA2 = peli_transmit_message->Data[2];
            CAN1_PELI->DATA3 = peli_transmit_message->Data[3];
            CAN1_PELI->DATA4 = peli_transmit_message->Data[4];
            CAN1_PELI->DATA5 = peli_transmit_message->Data[5];
            CAN1_PELI->DATA6 = peli_transmit_message->Data[6];
            CAN1_PELI->DATA7 = peli_transmit_message->Data[7];
        }
    }
    else {
        CAN1_PELI->ID0   = peli_transmit_message->IDHH;
        CAN1_PELI->ID1   = peli_transmit_message->IDHL;
        CAN1_PELI->DATA0 = peli_transmit_message->IDLH;
        CAN1_PELI->DATA1 = peli_transmit_message->IDLL;
        if ((FunctionalState)(peli_transmit_message->RTR) != ENABLE) {
            CAN1_PELI->DATA2 = peli_transmit_message->Data[0];
            CAN1_PELI->DATA3 = peli_transmit_message->Data[1];
            CAN1_PELI->DATA4 = peli_transmit_message->Data[2];
            CAN1_PELI->DATA5 = peli_transmit_message->Data[3];
            CAN1_PELI->DATA6 = peli_transmit_message->Data[4];
            CAN1_PELI->DATA7 = peli_transmit_message->Data[5];
            CAN1_PELI->DATA8 = peli_transmit_message->Data[6];
            CAN1_PELI->DATA9 = peli_transmit_message->Data[7];
        }
    }

    (CAN1_PELI->MOD & CAN_MOD_STM) ? (CAN1->CMR = CAN_CMR_GTS | CAN_CMR_AT) : (CAN1->CMR = CAN_CMR_TR | CAN_CMR_AT);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Initiates and transmits a CAN frame message.
/// @param  TxMessage: pointer to a structure which contains CAN Id, CAN DLC and
///         CAN data.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Peli_TransmitRepeat(CanPeliTxMsg* peli_transmit_message)
{
    CAN1_PELI->FF = (peli_transmit_message->FF << 7) | (peli_transmit_message->RTR << 6) | (peli_transmit_message->DLC);
    if (((FunctionalState)peli_transmit_message->FF) != ENABLE) {
        CAN1_PELI->ID0 = (peli_transmit_message->IDHH);

        CAN1_PELI->ID1 = (peli_transmit_message->IDHL & 0xE0);
        if ((FunctionalState)(peli_transmit_message->RTR) != ENABLE) {
            CAN1_PELI->DATA0 = peli_transmit_message->Data[0];
            CAN1_PELI->DATA1 = peli_transmit_message->Data[1];
            CAN1_PELI->DATA2 = peli_transmit_message->Data[2];
            CAN1_PELI->DATA3 = peli_transmit_message->Data[3];
            CAN1_PELI->DATA4 = peli_transmit_message->Data[4];
            CAN1_PELI->DATA5 = peli_transmit_message->Data[5];
            CAN1_PELI->DATA6 = peli_transmit_message->Data[6];
            CAN1_PELI->DATA7 = peli_transmit_message->Data[7];
        }
    }
    else {
        CAN1_PELI->ID0   = peli_transmit_message->IDHH;
        CAN1_PELI->ID1   = peli_transmit_message->IDHL;
        CAN1_PELI->DATA0 = peli_transmit_message->IDLH;
        CAN1_PELI->DATA1 = peli_transmit_message->IDLL;
        if ((FunctionalState)(peli_transmit_message->RTR) != ENABLE) {
            CAN1_PELI->DATA2 = peli_transmit_message->Data[0];
            CAN1_PELI->DATA3 = peli_transmit_message->Data[1];
            CAN1_PELI->DATA4 = peli_transmit_message->Data[2];
            CAN1_PELI->DATA5 = peli_transmit_message->Data[3];
            CAN1_PELI->DATA6 = peli_transmit_message->Data[4];
            CAN1_PELI->DATA7 = peli_transmit_message->Data[5];
            CAN1_PELI->DATA8 = peli_transmit_message->Data[6];
            CAN1_PELI->DATA9 = peli_transmit_message->Data[7];
        }
    }

    (CAN1_PELI->MOD & CAN_MOD_STM) ? (CAN1->CMR = CAN_CMR_GTS | CAN_CMR_AT) : (CAN1->CMR = CAN_CMR_TR);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Receives a correct CAN frame.
/// @param  RxMessage: pointer to a structure receive frame which contains CAN
///         Id,CAN DLC, CAN data and FMI number.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Peli_Receive(CanPeliRxMsg* peli_receive_message)
{
    u32 tempid;
    peli_receive_message->FF  = (CAN1_PELI->FF) >> 7;
    peli_receive_message->RTR = ((CAN1_PELI->FF) >> 6) & 0x1;
    peli_receive_message->DLC = (CAN1_PELI->FF) & 0xf;

    if (((FunctionalState)peli_receive_message->FF) != ENABLE) {
        tempid = (u32)(CAN1_PELI->ID1 >> 5);
        tempid |= (u32)(CAN1_PELI->ID0 << 3);
        peli_receive_message->ID      = tempid;
        peli_receive_message->Data[0] = CAN1_PELI->DATA0;
        peli_receive_message->Data[1] = CAN1_PELI->DATA1;
        peli_receive_message->Data[2] = CAN1_PELI->DATA2;
        peli_receive_message->Data[3] = CAN1_PELI->DATA3;
        peli_receive_message->Data[4] = CAN1_PELI->DATA4;
        peli_receive_message->Data[5] = CAN1_PELI->DATA5;
        peli_receive_message->Data[6] = CAN1_PELI->DATA6;
        peli_receive_message->Data[7] = CAN1_PELI->DATA7;
    }
    else {
        tempid = (u32)((CAN1_PELI->DATA1 & 0xf8) >> 3);
        tempid |= (u32)(CAN1_PELI->DATA0 << 5);
        tempid |= (u32)(CAN1_PELI->ID1 << 13);
        tempid |= (u32)(CAN1_PELI->ID0 << 21);
        peli_receive_message->ID      = tempid;
        peli_receive_message->Data[0] = CAN1_PELI->DATA2;
        peli_receive_message->Data[1] = CAN1_PELI->DATA3;
        peli_receive_message->Data[2] = CAN1_PELI->DATA4;
        peli_receive_message->Data[3] = CAN1_PELI->DATA5;
        peli_receive_message->Data[4] = CAN1_PELI->DATA6;
        peli_receive_message->Data[5] = CAN1_PELI->DATA7;
        peli_receive_message->Data[6] = CAN1_PELI->DATA8;
        peli_receive_message->Data[7] = CAN1_PELI->DATA9;
    }
    CAN_FIFORelease(CAN1);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Get available current informatoin in receive FIFO only in Peli
///         workmode.
/// @retval The value in reg RMC
////////////////////////////////////////////////////////////////////////////////
u32 CAN_Peli_GetRxFIFOInfo(void)
{
    return CAN1_PELI->RMC;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Returns the CAN's last error code (LEC).
/// @retval Error code:
///          - CAN_ERRORCODE_NoErr: No Error
///          - CAN_ERRORCODE_StuffErr: Stuff Error
///          - CAN_ERRORCODE_FormErr: Form Error
///          - CAN_ERRORCODE_ACKErr : Acknowledgment Error
///          - CAN_ERRORCODE_BitRecessiveErr: Bit Recessive Error
///          - CAN_ERRORCODE_BitDominantErr: Bit Dominant Error
///          - CAN_ERRORCODE_CRCErr: CRC Error
///          - CAN_ERRORCODE_SoftwareSetErr: Software Set Error
////////////////////////////////////////////////////////////////////////////////
u8 CAN_Peli_GetLastErrorCode(void)
{
    // Return the error code
    return (u8)CAN1_PELI->ECC;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Returns the CAN Receive Error Counter (REC).
/// @note   In case of an error during reception, this counter is incremented
///         by 1 or by 8 depending on the error condition as defined by the CAN
///         standard. After every successful reception, the counter is
///         decremented by 1 or reset to 120 if its value was higher than 128.
///         When the counter value exceeds 127, the CAN controller enters the
///         error passive state.
/// @retval CAN Receive Error Counter.
////////////////////////////////////////////////////////////////////////////////
u8 CAN_Peli_GetReceiveErrorCounter(void)
{
    // Return the Receive Error Counter
    return (u8)(CAN1_PELI->RXERR);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Returns the LSB of the 9-bit can Transmit Error Counter(TEC).
/// @retval LSB of the 8-bit CAN Transmit Error Counter.
////////////////////////////////////////////////////////////////////////////////
u8 CAN_Peli_GetLSBTransmitErrorCounter(void)
{
    // Return the LSB of the 8-bit CAN Transmit Error Counter(TEC)
    return (u8)(CAN1_PELI->TXERR);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Enables or disables the specified CAN interrupts in peli workmode.
/// @param  it: specifies the CAN interrupt sources to be enabled or
///         disabled.
///         This parameter can be:
/// @arg    CAN_IT_RI: Receive FIFO not empty Interrupt
/// @arg    CAN_IT_TI: Transmit Interrupt
/// @arg    CAN_IT_EI: ERROR Interrupt
/// @arg    CAN_IT_DOI: Data voerflow Interrupt
/// @arg    CAN_IT_WUI: Wakeup Interrupt
/// @arg    CAN_IT_EPI(only Peli): passive error Interrupt
/// @arg    CAN_IT_ALI(only Peli): arbiter lose Interrupt
/// @arg    CAN_IT_BEI(only Peli): bus error Interrupt
/// @arg    CAN_IT_ALL: use it can enble all Interrupt
/// @param  state: new state of the CAN interrupts.
///         This parameter can be: ENABLE or DISABLE.
/// @retval None.
////////////////////////////////////////////////////////////////////////////////
void CAN_Peli_ITConfig(u32 it, FunctionalState state)
{
    (state) ? (CAN1_PELI->IER |= it) : (CAN1_PELI->IER &= ~it);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Checks whether the specified CAN interrupt has occurred or not.
/// @param  it: specifies the CAN interrupt source to check.
///         This parameter can be one of the following values:
/// @arg    CAN_IT_RI: Receive FIFO not empty Interrupt
/// @arg    CAN_IT_TI: Transmit Interrupt
/// @arg    CAN_IT_EI: ERROR Interrupt
/// @arg    CAN_IT_DOI: Data voerflow Interrupt
/// @arg    CAN_IT_WUI: Wakeup Interrupt
/// @arg    CAN_IT_EPI(only Peli): passive error Interrupt
/// @arg    CAN_IT_ALI(only Peli): arbiter lose Interrupt
/// @arg    CAN_IT_BEI(only Peli): bus error Interrupt
/// @arg    CAN_IT_ALL: use it can enble all Interrupt
/// @retval The current state of it (SET or RESET).
////////////////////////////////////////////////////////////////////////////////
ITStatus CAN_Peli_GetITStatus(u32 it)
{
    return (ITStatus)(((CAN1_PELI->IR & it) != it) ? RESET : SET);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief  Config CAN_Peli_InitTypeDef baud parameter.
/// @param  CAN_Peli_InitTypeDef: CAN struct.
/// @param  src_clk: CAN module clock.
/// @param  baud: specified baud.
/// @retval The current state of it (SET or RESET).
////////////////////////////////////////////////////////////////////////////////
void CAN_AutoCfg_BaudParam(CAN_Peli_InitTypeDef* init_struct, u32 src_clk, u32 baud)
{
    u32 i, value = baud, record = 1;
    u32 remain = 0, sumPrescaler = 0;
    while ((baud == 0) || (src_clk == 0))
        ;
    sumPrescaler = src_clk / baud;
    sumPrescaler = sumPrescaler / 2;
    for (i = 25; i > 3; i--) {
        remain = sumPrescaler - ((sumPrescaler / i) * i);
        if (remain == 0) {
            record = i;
            break;
        }
        else {
            if (remain < value) {
                value  = remain;
                record = i;
            }
        }
    }
    init_struct->SJW   = 0;
    init_struct->BRP   = (sumPrescaler / record) - 1;
    init_struct->TESG2 = (record - 3) / 3;
    init_struct->TESG1 = (record - 3) - init_struct->TESG2;
}

/// @}

/// @}

/// @}