can.c

Go to the documentation of this file.

/**************************************************************************/
#include "NuMicro.h"

#if defined(CAN2)
static uint8_t gu8LockCanIf[3ul][2ul] = {0ul};    /* The chip has three CANs. */
#elif defined(CAN1)
static uint8_t gu8LockCanIf[2ul][2ul] = {0ul};    /* The chip has two CANs. */
#elif defined(CAN0) || defined(CAN)
static uint8_t gu8LockCanIf[1ul][2ul] = {0ul};    /* The chip only has one CAN. */
#endif

#define RETRY_COUNTS    (0x10000000ul)

#define TSEG1_MIN 2ul
#define TSEG1_MAX 16ul
#define TSEG2_MIN 1ul
#define TSEG2_MAX 8ul
#define BRP_MIN   1ul
#define BRP_MAX   1024ul  /* 6-bit BRP field + 4-bit BRPE field*/
#define SJW_MAX   4ul
#define BRP_INC   1ul

/* #define DEBUG_PRINTF printf */
#define DEBUG_PRINTF(...)

static uint32_t LockIF(CAN_T *tCAN);
static uint32_t LockIF_TL(CAN_T *tCAN);
static void ReleaseIF(CAN_T *tCAN, uint32_t u32IfNo);
static int can_update_spt(int sampl_pt, int tseg, int *tseg1, int *tseg2);

static uint32_t LockIF(CAN_T *tCAN)
{
    uint32_t u32CanNo;
    uint32_t u32FreeIfNo;
    uint32_t u32IntMask;

#if defined(CAN1)
    if(tCAN == CAN0)
        u32CanNo = 0ul;
    else if(tCAN == CAN1)
        u32CanNo = 1ul;
    #if defined(CAN2)
    else if(tCAN == CAN2)
        u32CanNo = 2ul;
    #endif
#else /* defined(CAN0) || defined(CAN) */
    u32CanNo = 0ul;
#endif

    u32FreeIfNo = 2ul;

    /* Disable CAN interrupt */
    u32IntMask = tCAN->CON & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk);
    tCAN->CON = tCAN->CON & ~(CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk);

    /* Check interface 1 is available or not */
    if((tCAN->IF[0ul].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0ul)
    {
        if(gu8LockCanIf[u32CanNo][0ul] == 0ul)
        {
            gu8LockCanIf[u32CanNo][0ul] = 1u;
            u32FreeIfNo = 0ul;
        }
        else
        {
        }
    }
    else
    {
    }

    /* Or check interface 2 is available or not */
    if(u32FreeIfNo == 2ul)
    {
        if((tCAN->IF[1ul].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0ul)
        {
            if(gu8LockCanIf[u32CanNo][1ul] == 0ul)
            {
                gu8LockCanIf[u32CanNo][1ul] = 1u;
                u32FreeIfNo = 1ul;
            }
            else
            {
            }
        }
        else
        {
        }
    }
    else
    {
    }

    /* Enable CAN interrupt */
    tCAN->CON |= u32IntMask;

    return u32FreeIfNo;
}

static uint32_t LockIF_TL(CAN_T *tCAN)
{
    uint32_t u32Count;
    uint32_t u32FreeIfNo;

    for(u32Count = 0ul; u32Count < RETRY_COUNTS; u32Count++)
    {
        if((u32FreeIfNo = LockIF(tCAN)) != 2ul)
        {
            break;
        }
        else
        {
        }
    }

    return u32FreeIfNo;
}

static void ReleaseIF(CAN_T *tCAN, uint32_t u32IfNo)
{
    uint32_t u32IntMask;
    uint32_t u32CanNo;

    if(u32IfNo >= 2ul)
    {
    }
    else
    {
#if defined(CAN1)
    if(tCAN == CAN0)
        u32CanNo = 0ul;
    else if(tCAN == CAN1)
        u32CanNo = 1ul;
    #if defined(CAN2)
    else if(tCAN == CAN2)
        u32CanNo = 2ul;
    #endif
#else /* defined(CAN0) || defined(CAN) */
        u32CanNo = 0ul;
#endif

        /* Disable CAN interrupt */
        u32IntMask = tCAN->CON & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk);
        tCAN->CON = tCAN->CON & ~(CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk);

        gu8LockCanIf[u32CanNo][u32IfNo] = 0u;

        /* Enable CAN interrupt */
        tCAN->CON |= u32IntMask;
    }
}

static int can_update_spt(int sampl_pt, int tseg, int *tseg1, int *tseg2)
{
    *tseg2 = tseg + 1 - (sampl_pt * (tseg + 1)) / 1000;
    if (*tseg2 < TSEG2_MIN)
    {
        *tseg2 = TSEG2_MIN;
    }
    else
    {
    }

    if (*tseg2 > TSEG2_MAX)
    {
        *tseg2 = TSEG2_MAX;
    }
    else
    {
    }

    *tseg1 = tseg - *tseg2;
    if (*tseg1 > TSEG1_MAX)
    {
        *tseg1 = TSEG1_MAX;
        *tseg2 = tseg - *tseg1;
    }
    else
    {
    }

    return 1000 * (tseg + 1 - *tseg2) / (tseg + 1);
}

void CAN_EnterInitMode(CAN_T *tCAN, uint8_t u8Mask)
{
    tCAN->CON = u8Mask | (CAN_CON_INIT_Msk | CAN_CON_CCE_Msk);
}


void CAN_LeaveInitMode(CAN_T *tCAN)
{
    tCAN->CON &= (~(CAN_CON_INIT_Msk | CAN_CON_CCE_Msk));
    while(tCAN->CON & CAN_CON_INIT_Msk)
    {
        /* Check INIT bit is released */
    }
}

void CAN_WaitMsg(CAN_T *tCAN)
{
    tCAN->STATUS = 0x0ul; /* clr status */

    while(1)
    {
        if(tCAN->IF[1].MCON & CAN_IF_MCON_NEWDAT_Msk)   /* check new data */
        {
            /* New Data IN */
            break;
        }
        else
        {
        }

        if(tCAN->STATUS & CAN_STATUS_RXOK_Msk)
        {
            /* Rx OK */
        }
        else
        {
        }

        if(tCAN->STATUS & CAN_STATUS_LEC_Msk)
        {
            /* Error */
        }
        else
        {
        }
    }
}

uint32_t CAN_GetCANBitRate(CAN_T *tCAN)
{
    uint32_t u32Tseg1, u32Tseg2;
    uint32_t u32Bpr;

    u32Tseg1 = (tCAN->BTIME & CAN_BTIME_TSEG1_Msk) >> CAN_BTIME_TSEG1_Pos;
    u32Tseg2 = (tCAN->BTIME & CAN_BTIME_TSEG2_Msk) >> CAN_BTIME_TSEG2_Pos;
    u32Bpr   = (tCAN->BTIME & CAN_BTIME_BRP_Msk) | (tCAN->BRPE << 6ul);

    return (SystemCoreClock / (u32Bpr + 1ul) / (u32Tseg1 + u32Tseg2 + 3ul));
}

void CAN_EnterTestMode(CAN_T *tCAN, uint8_t u8TestMask)
{
    tCAN->CON |= CAN_CON_TEST_Msk;
    tCAN->TEST = u8TestMask;
}


void CAN_LeaveTestMode(CAN_T *tCAN)
{
    tCAN->CON |= CAN_CON_TEST_Msk;
    tCAN->TEST &= ~(CAN_TEST_LBACK_Msk | CAN_TEST_SILENT_Msk | CAN_TEST_BASIC_Msk);
    tCAN->CON &= (~CAN_CON_TEST_Msk);
}

uint32_t CAN_IsNewDataReceived(CAN_T *tCAN, uint8_t u8MsgObj)
{
    return (u8MsgObj < 16ul ? tCAN->NDAT1 & (1ul << u8MsgObj) : tCAN->NDAT2 & (1ul << (u8MsgObj - 16ul)));
}


int32_t CAN_BasicSendMsg(CAN_T *tCAN, STR_CANMSG_T* pCanMsg)
{
    uint32_t i = 0ul;
    int32_t rev = 1l;

    while(tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk)
    {
    }

    tCAN->STATUS &= (~CAN_STATUS_TXOK_Msk);

    if(pCanMsg->IdType == CAN_STD_ID)
    {
        /* standard ID*/
        tCAN->IF[0].ARB1 = 0ul;
        tCAN->IF[0].ARB2 = (((pCanMsg->Id) & 0x7FFul) << 2ul) ;
    }
    else
    {
        /* extended ID*/
        tCAN->IF[0].ARB1 = (pCanMsg->Id) & 0xFFFFul;
        tCAN->IF[0].ARB2 = ((pCanMsg->Id) & 0x1FFF0000ul) >> 16ul  | CAN_IF_ARB2_XTD_Msk;

    }

    if(pCanMsg->FrameType)
    {
        tCAN->IF[0].ARB2 |= CAN_IF_ARB2_DIR_Msk;
    }
    else
    {
        tCAN->IF[0].ARB2 &= (~CAN_IF_ARB2_DIR_Msk);
    }

    tCAN->IF[0].MCON = (tCAN->IF[0].MCON & (~CAN_IF_MCON_DLC_Msk)) | pCanMsg->DLC;
    tCAN->IF[0].DAT_A1 = (uint16_t)((uint16_t)((uint16_t)pCanMsg->Data[1] << 8) | pCanMsg->Data[0]);
    tCAN->IF[0].DAT_A2 = (uint16_t)((uint16_t)((uint16_t)pCanMsg->Data[3] << 8) | pCanMsg->Data[2]);
    tCAN->IF[0].DAT_B1 = (uint16_t)((uint16_t)((uint16_t)pCanMsg->Data[5] << 8) | pCanMsg->Data[4]);
    tCAN->IF[0].DAT_B2 = (uint16_t)((uint16_t)((uint16_t)pCanMsg->Data[7] << 8) | pCanMsg->Data[6]);

    /* request transmission*/
    tCAN->IF[0].CREQ &= (~CAN_IF_CREQ_BUSY_Msk);
    if(tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk)
    {
        /* Cannot clear busy for sending ...*/
        rev = 0l; /* return FALSE */
    }
    else
    {
        tCAN->IF[0].CREQ |= CAN_IF_CREQ_BUSY_Msk;  /* sending */

        for(i = 0ul; i < 0xFFFFFul; i++)
        {
            if((tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0ul)
            {
                break;
            }
            else
            {
            }
        }

        if(i >= 0xFFFFFul)
        {
            /* Cannot send out... */
            rev = 0l; /* return FALSE */
        }
        else
        {
        }
    }

    return rev;
}

int32_t CAN_BasicReceiveMsg(CAN_T *tCAN, STR_CANMSG_T* pCanMsg)
{
    int32_t rev = 1l;

    if((tCAN->IF[1].MCON & CAN_IF_MCON_NEWDAT_Msk) == 0ul)
    {
        /* In basic mode, receive data always save in IF2 */
        rev = 0; /* return FALSE */
    }
    else
    {

        tCAN->STATUS &= (~CAN_STATUS_RXOK_Msk);

        tCAN->IF[1].CMASK = CAN_IF_CMASK_ARB_Msk
                            | CAN_IF_CMASK_CONTROL_Msk
                            | CAN_IF_CMASK_DATAA_Msk
                            | CAN_IF_CMASK_DATAB_Msk;

        if((tCAN->IF[1].ARB2 & CAN_IF_ARB2_XTD_Msk) == 0ul)
        {
            /* standard ID*/
            pCanMsg->IdType = CAN_STD_ID;
            pCanMsg->Id = (tCAN->IF[1].ARB2 >> 2) & 0x07FFul;

        }
        else
        {
            /* extended ID*/
            pCanMsg->IdType = CAN_EXT_ID;
            pCanMsg->Id  = (tCAN->IF[1].ARB2 & 0x1FFFul) << 16;
            pCanMsg->Id |= (uint32_t)tCAN->IF[1].ARB1;
        }

        pCanMsg->FrameType = (((tCAN->IF[1].ARB2 & CAN_IF_ARB2_DIR_Msk) >> CAN_IF_ARB2_DIR_Pos)) ? 0ul : 1ul;

        pCanMsg->DLC     = (uint8_t)(tCAN->IF[1].MCON & CAN_IF_MCON_DLC_Msk);
        pCanMsg->Data[0] = (uint8_t)(tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA0_Msk);
        pCanMsg->Data[1] = (uint8_t)((tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA1_Msk) >> CAN_IF_DAT_A1_DATA1_Pos);
        pCanMsg->Data[2] = (uint8_t)(tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA2_Msk);
        pCanMsg->Data[3] = (uint8_t)((tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA3_Msk) >> CAN_IF_DAT_A2_DATA3_Pos);
        pCanMsg->Data[4] = (uint8_t)(tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA4_Msk);
        pCanMsg->Data[5] = (uint8_t)((tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA5_Msk) >> CAN_IF_DAT_B1_DATA5_Pos);
        pCanMsg->Data[6] = (uint8_t)(tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA6_Msk);
        pCanMsg->Data[7] = (uint8_t)((tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA7_Msk) >> CAN_IF_DAT_B2_DATA7_Pos);
    }

    return rev;
}

int32_t CAN_SetRxMsgObjAndMsk(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8idType, uint32_t u32id, uint32_t u32idmask, uint8_t u8singleOrFifoLast)
{
    int32_t rev = 1l;
    uint32_t u32MsgIfNum;

    /* Get and lock a free interface */
    if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
    {
        rev = 0; /* return FALSE */
    }
    else
    {
        /* Command Setting */
        tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_WRRD_Msk | CAN_IF_CMASK_MASK_Msk | CAN_IF_CMASK_ARB_Msk |
                                      CAN_IF_CMASK_CONTROL_Msk | CAN_IF_CMASK_DATAA_Msk | CAN_IF_CMASK_DATAB_Msk;

        if(u8idType == CAN_STD_ID)    /* According STD/EXT ID format,Configure Mask and Arbitration register */
        {
            tCAN->IF[u32MsgIfNum].ARB1 = 0ul;
            tCAN->IF[u32MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | (u32id & 0x7FFul) << 2;
        }
        else
        {
            tCAN->IF[u32MsgIfNum].ARB1 = u32id & 0xFFFFul;
            tCAN->IF[u32MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | CAN_IF_ARB2_XTD_Msk | (u32id & 0x1FFF0000ul) >> 16;
        }

        tCAN->IF[u32MsgIfNum].MASK1 = (u32idmask & 0xFFFFul);
        tCAN->IF[u32MsgIfNum].MASK2 = (u32idmask >> 16) & 0xFFFFul;

        /* tCAN->IF[u32MsgIfNum].MCON |= CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk; */
        tCAN->IF[u32MsgIfNum].MCON = CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk;
        if(u8singleOrFifoLast)
        {
            tCAN->IF[u32MsgIfNum].MCON |= CAN_IF_MCON_EOB_Msk;
        }
        else
        {
            tCAN->IF[u32MsgIfNum].MCON &= (~CAN_IF_MCON_EOB_Msk);
        }

        tCAN->IF[u32MsgIfNum].DAT_A1  = 0ul;
        tCAN->IF[u32MsgIfNum].DAT_A2  = 0ul;
        tCAN->IF[u32MsgIfNum].DAT_B1  = 0ul;
        tCAN->IF[u32MsgIfNum].DAT_B2  = 0ul;

        tCAN->IF[u32MsgIfNum].CREQ = 1ul + u8MsgObj;
        ReleaseIF(tCAN, u32MsgIfNum);
    }

    return rev;
}

int32_t CAN_SetRxMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8idType, uint32_t u32id, uint8_t u8singleOrFifoLast)
{
    int32_t rev = 1l;
    uint32_t u32MsgIfNum;

    /* Get and lock a free interface */
    if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
    {
        rev = 0; /* return FALSE */
    }
    else
    {
        /* Command Setting */
        tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_WRRD_Msk | CAN_IF_CMASK_MASK_Msk | CAN_IF_CMASK_ARB_Msk |
                                      CAN_IF_CMASK_CONTROL_Msk | CAN_IF_CMASK_DATAA_Msk | CAN_IF_CMASK_DATAB_Msk;

        if(u8idType == CAN_STD_ID)    /* According STD/EXT ID format,Configure Mask and Arbitration register */
        {
            tCAN->IF[u32MsgIfNum].ARB1 = 0ul;
            tCAN->IF[u32MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | (u32id & 0x7FFul) << 2;
        }
        else
        {
            tCAN->IF[u32MsgIfNum].ARB1 = u32id & 0xFFFFul;
            tCAN->IF[u32MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | CAN_IF_ARB2_XTD_Msk | (u32id & 0x1FFF0000ul) >> 16;
        }

        /* tCAN->IF[u8MsgIfNum].MCON |= CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk; */
        tCAN->IF[u32MsgIfNum].MCON = CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk;
        if(u8singleOrFifoLast)
        {
            tCAN->IF[u32MsgIfNum].MCON |= CAN_IF_MCON_EOB_Msk;
        }
        else
        {
            tCAN->IF[u32MsgIfNum].MCON &= (~CAN_IF_MCON_EOB_Msk);
        }

        tCAN->IF[u32MsgIfNum].DAT_A1  = 0ul;
        tCAN->IF[u32MsgIfNum].DAT_A2  = 0ul;
        tCAN->IF[u32MsgIfNum].DAT_B1  = 0ul;
        tCAN->IF[u32MsgIfNum].DAT_B2  = 0ul;

        tCAN->IF[u32MsgIfNum].CREQ = 1ul + u8MsgObj;
        ReleaseIF(tCAN, u32MsgIfNum);
    }

    return rev;
}

int32_t CAN_ReadMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8Release, STR_CANMSG_T* pCanMsg)
{
    int32_t rev = 1l;
    uint32_t u32MsgIfNum;

    if(!CAN_IsNewDataReceived(tCAN, u8MsgObj))
    {
        rev = 0; /* return FALSE */
    }
    else
    {
        /* Get and lock a free interface */
        if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
        {
            rev = 0; /* return FALSE */
        }
        else
        {
            tCAN->STATUS &= (~CAN_STATUS_RXOK_Msk);

            /* read the message contents*/
            tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_MASK_Msk
                                          | CAN_IF_CMASK_ARB_Msk
                                          | CAN_IF_CMASK_CONTROL_Msk
                                          | CAN_IF_CMASK_CLRINTPND_Msk
                                          | (u8Release ? CAN_IF_CMASK_TXRQSTNEWDAT_Msk : 0ul)
                                          | CAN_IF_CMASK_DATAA_Msk
                                          | CAN_IF_CMASK_DATAB_Msk;

            tCAN->IF[u32MsgIfNum].CREQ = 1ul + u8MsgObj;

            while(tCAN->IF[u32MsgIfNum].CREQ & CAN_IF_CREQ_BUSY_Msk)
            {
                /*Wait*/
            }

            if((tCAN->IF[u32MsgIfNum].ARB2 & CAN_IF_ARB2_XTD_Msk) == 0ul)
            {
                /* standard ID*/
                pCanMsg->IdType = CAN_STD_ID;
                pCanMsg->Id     = (tCAN->IF[u32MsgIfNum].ARB2 & CAN_IF_ARB2_ID_Msk) >> 2ul;
            }
            else
            {
                /* extended ID*/
                pCanMsg->IdType = CAN_EXT_ID;
                pCanMsg->Id  = (((tCAN->IF[u32MsgIfNum].ARB2) & 0x1FFFul) << 16) | tCAN->IF[u32MsgIfNum].ARB1;
            }

            pCanMsg->DLC     = (uint8_t)(tCAN->IF[u32MsgIfNum].MCON & CAN_IF_MCON_DLC_Msk);
            pCanMsg->Data[0] = (uint8_t)(tCAN->IF[u32MsgIfNum].DAT_A1 & CAN_IF_DAT_A1_DATA0_Msk);
            pCanMsg->Data[1] = (uint8_t)((tCAN->IF[u32MsgIfNum].DAT_A1 & CAN_IF_DAT_A1_DATA1_Msk) >> CAN_IF_DAT_A1_DATA1_Pos);
            pCanMsg->Data[2] = (uint8_t)(tCAN->IF[u32MsgIfNum].DAT_A2 & CAN_IF_DAT_A2_DATA2_Msk);
            pCanMsg->Data[3] = (uint8_t)((tCAN->IF[u32MsgIfNum].DAT_A2 & CAN_IF_DAT_A2_DATA3_Msk) >> CAN_IF_DAT_A2_DATA3_Pos);
            pCanMsg->Data[4] = (uint8_t)(tCAN->IF[u32MsgIfNum].DAT_B1 & CAN_IF_DAT_B1_DATA4_Msk);
            pCanMsg->Data[5] = (uint8_t)((tCAN->IF[u32MsgIfNum].DAT_B1 & CAN_IF_DAT_B1_DATA5_Msk) >> CAN_IF_DAT_B1_DATA5_Pos);
            pCanMsg->Data[6] = (uint8_t)(tCAN->IF[u32MsgIfNum].DAT_B2 & CAN_IF_DAT_B2_DATA6_Msk);
            pCanMsg->Data[7] = (uint8_t)((tCAN->IF[u32MsgIfNum].DAT_B2 & CAN_IF_DAT_B2_DATA7_Msk) >> CAN_IF_DAT_B2_DATA7_Pos);

            ReleaseIF(tCAN, u32MsgIfNum);
        }
    }

    return rev;
}


uint32_t CAN_SetBaudRate(CAN_T *tCAN, uint32_t u32BaudRate)
{
    long rate;
    long best_error = 1000000000, error = 0;
    int best_tseg = 0, best_brp = 0, brp = 0;
    int tsegall, tseg = 0, tseg1 = 0, tseg2 = 0;
    int spt_error = 1000, spt = 0, sampl_pt;
    uint64_t clock_freq = (uint64_t)0, u64PCLK_DIV = (uint64_t)1;
    uint32_t sjw = (uint32_t)1;

    CAN_EnterInitMode(tCAN, (uint8_t)0);

    SystemCoreClockUpdate();
    if((tCAN == CAN0) || (tCAN == CAN2))
    {
        u64PCLK_DIV = (uint64_t)(CLK->PCLKDIV & CLK_PCLKDIV_APB0DIV_Msk);
        u64PCLK_DIV = (uint64_t)(1 << u64PCLK_DIV);
    }
    else if(tCAN == CAN1)
    {
        u64PCLK_DIV = (uint64_t)((CLK->PCLKDIV & CLK_PCLKDIV_APB1DIV_Msk) >> CLK_PCLKDIV_APB1DIV_Pos);
        u64PCLK_DIV = (uint64_t)(1 << u64PCLK_DIV);
    }

    clock_freq = SystemCoreClock / u64PCLK_DIV;

    if(u32BaudRate >= (uint32_t)1000000)
    {
        u32BaudRate = (uint32_t)1000000;
    }

    /* Use CIA recommended sample points */
    if (u32BaudRate > (uint32_t)800000)
    {
        sampl_pt = (int)750;
    }
    else if (u32BaudRate > (uint32_t)500000)
    {
        sampl_pt = (int)800;
    }
    else
    {
        sampl_pt = (int)875;
    }

    /* tseg even = round down, odd = round up */
    for (tseg = (TSEG1_MAX + TSEG2_MAX) * 2ul + 1ul; tseg >= (TSEG1_MIN + TSEG2_MIN) * 2ul; tseg--)
    {
        tsegall = 1ul + tseg / 2ul;
        /* Compute all possible tseg choices (tseg=tseg1+tseg2) */
        brp = clock_freq / (tsegall * u32BaudRate) + tseg % 2;
        /* chose brp step which is possible in system */
        brp = (brp / BRP_INC) * BRP_INC;

        if ((brp < BRP_MIN) || (brp > BRP_MAX))
        {
            continue;
        }
        rate = clock_freq / (brp * tsegall);

        error = u32BaudRate - rate;

        /* tseg brp biterror */
        if (error < 0)
        {
            error = -error;
        }
        if (error > best_error)
        {
            continue;
        }
        best_error = error;
        if (error == 0)
        {
            spt = can_update_spt(sampl_pt, tseg / 2, &tseg1, &tseg2);
            error = sampl_pt - spt;
            if (error < 0)
            {
                error = -error;
            }
            if (error > spt_error)
            {
                continue;
            }
            spt_error = error;
        }
        best_tseg = tseg / 2;
        best_brp = brp;

        if (error == 0)
        {
            break;
        }
    }

    spt = can_update_spt(sampl_pt, best_tseg, &tseg1, &tseg2);

    /* check for sjw user settings */
    /* bt->sjw is at least 1 -> sanitize upper bound to sjw_max */
    if (sjw > SJW_MAX)
    {
        sjw = SJW_MAX;
    }
    /* bt->sjw must not be higher than tseg2 */
    if (tseg2 < sjw)
    {
        sjw = tseg2;
    }

    /* real bit-rate */
    u32BaudRate = clock_freq / (best_brp * (tseg1 + tseg2 + 1));

    tCAN->BTIME = ((uint32_t)(tseg2 - 1ul) << CAN_BTIME_TSEG2_Pos) | ((uint32_t)(tseg1 - 1ul) << CAN_BTIME_TSEG1_Pos) |
                  ((uint32_t)(best_brp - 1ul) & CAN_BTIME_BRP_Msk) | (sjw << CAN_BTIME_SJW_Pos);
    tCAN->BRPE  = ((uint32_t)(best_brp - 1ul) >> 6) & 0x0Ful;

    /* printf("\n bitrate = %d \n", CAN_GetCANBitRate(tCAN)); */

    CAN_LeaveInitMode(tCAN);

    return u32BaudRate;
}

void CAN_Close(CAN_T *tCAN)
{
    CAN_DisableInt(tCAN, (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk));
}

uint32_t CAN_Open(CAN_T *tCAN, uint32_t u32BaudRate, uint32_t u32Mode)
{
    uint32_t u32CurrentBitRate;

    u32CurrentBitRate = CAN_SetBaudRate(tCAN, u32BaudRate);

    if(u32Mode == CAN_BASIC_MODE)
    {
        CAN_EnterTestMode(tCAN, (uint8_t)CAN_TEST_BASIC_Msk);
    }
    else
    {
    }

    return u32CurrentBitRate;
}

int32_t CAN_SetTxMsg(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T* pCanMsg)
{
    int32_t rev = 1l;
    uint32_t u32MsgIfNum;

    if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
    {
        rev = 0; /* return FALSE */
    }
    else
    {
        /* update the contents needed for transmission*/
        tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_WRRD_Msk | CAN_IF_CMASK_MASK_Msk | CAN_IF_CMASK_ARB_Msk |
                                      CAN_IF_CMASK_CONTROL_Msk | CAN_IF_CMASK_DATAA_Msk  | CAN_IF_CMASK_DATAB_Msk;

        if(pCanMsg->IdType == CAN_STD_ID)
        {
            /* standard ID*/
            tCAN->IF[u32MsgIfNum].ARB1 = 0ul;
            tCAN->IF[u32MsgIfNum].ARB2 = (((pCanMsg->Id) & 0x7FFul) << 2) | CAN_IF_ARB2_DIR_Msk | CAN_IF_ARB2_MSGVAL_Msk;
        }
        else
        {
            /* extended ID*/
            tCAN->IF[u32MsgIfNum].ARB1 = (pCanMsg->Id) & 0xFFFFul;
            tCAN->IF[u32MsgIfNum].ARB2 = ((pCanMsg->Id) & 0x1FFF0000ul) >> 16 |
                                         CAN_IF_ARB2_DIR_Msk | CAN_IF_ARB2_XTD_Msk | CAN_IF_ARB2_MSGVAL_Msk;
        }

        if(pCanMsg->FrameType)
        {
            tCAN->IF[u32MsgIfNum].ARB2 |=   CAN_IF_ARB2_DIR_Msk;
        }
        else
        {
            tCAN->IF[u32MsgIfNum].ARB2 &= (~CAN_IF_ARB2_DIR_Msk);
        }

        tCAN->IF[u32MsgIfNum].DAT_A1 = (uint16_t)((uint16_t)(((uint16_t)pCanMsg->Data[1] << 8)) | pCanMsg->Data[0]);
        tCAN->IF[u32MsgIfNum].DAT_A2 = (uint16_t)((uint16_t)(((uint16_t)pCanMsg->Data[3] << 8)) | pCanMsg->Data[2]);
        tCAN->IF[u32MsgIfNum].DAT_B1 = (uint16_t)((uint16_t)(((uint16_t)pCanMsg->Data[5] << 8)) | pCanMsg->Data[4]);
        tCAN->IF[u32MsgIfNum].DAT_B2 = (uint16_t)((uint16_t)(((uint16_t)pCanMsg->Data[7] << 8)) | pCanMsg->Data[6]);

        tCAN->IF[u32MsgIfNum].MCON   =  CAN_IF_MCON_NEWDAT_Msk | pCanMsg->DLC | CAN_IF_MCON_TXIE_Msk | CAN_IF_MCON_EOB_Msk;
        tCAN->IF[u32MsgIfNum].CREQ   = 1ul + u32MsgNum;

        ReleaseIF(tCAN, u32MsgIfNum);
    }

    return rev;
}

int32_t CAN_TriggerTxMsg(CAN_T  *tCAN, uint32_t u32MsgNum)
{
    int32_t rev = 1l;
    uint32_t u32MsgIfNum;

    if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
    {
        rev = 0; /* return FALSE */
    }
    else
    {
        tCAN->STATUS &= (~CAN_STATUS_TXOK_Msk);

        /* read the message contents*/
        tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_CLRINTPND_Msk
                                      | CAN_IF_CMASK_TXRQSTNEWDAT_Msk;

        tCAN->IF[u32MsgIfNum].CREQ = 1ul + u32MsgNum;

        while(tCAN->IF[u32MsgIfNum].CREQ & CAN_IF_CREQ_BUSY_Msk)
        {
            /*Wait*/
        }
        tCAN->IF[u32MsgIfNum].CMASK  = CAN_IF_CMASK_WRRD_Msk | CAN_IF_CMASK_TXRQSTNEWDAT_Msk;
        tCAN->IF[u32MsgIfNum].CREQ  = 1ul + u32MsgNum;

        ReleaseIF(tCAN, u32MsgIfNum);
    }

    return rev;
}

void CAN_EnableInt(CAN_T *tCAN, uint32_t u32Mask)
{
    tCAN->CON = (tCAN->CON & ~(CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk)) |
                (u32Mask & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk));
}

void CAN_DisableInt(CAN_T *tCAN, uint32_t u32Mask)
{
    tCAN->CON = tCAN->CON & ~((u32Mask & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk)));
}


int32_t CAN_SetRxMsg(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32IDType, uint32_t u32ID)
{
    int32_t rev = (int32_t)TRUE;
    uint32_t u32TimeOutCount = 0ul;

    while(CAN_SetRxMsgObj(tCAN, (uint8_t)u32MsgNum, (uint8_t)u32IDType, u32ID, (uint8_t)TRUE) == (int32_t)FALSE)
    {
        if(++u32TimeOutCount >= RETRY_COUNTS)
        {
            rev = (int32_t)(FALSE); /* return FALSE */
            break;
        }
        else
        {
        }
    }

    return rev;
}

int32_t CAN_SetRxMsgAndMsk(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32IDType, uint32_t u32ID, uint32_t u32IDMask)
{
    int32_t  rev = (int32_t)TRUE;
    uint32_t u32TimeOutCount = 0ul;

    while(CAN_SetRxMsgObjAndMsk(tCAN, (uint8_t)u32MsgNum, (uint8_t)u32IDType, u32ID, u32IDMask, (uint8_t)TRUE) == (int32_t)FALSE)
    {
        if(++u32TimeOutCount >= RETRY_COUNTS)
        {
            rev = (int32_t)FALSE;
            break;
        }
        else
        {
        }
    }

    return rev;
}

int32_t CAN_SetMultiRxMsg(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32MsgCount, uint32_t u32IDType, uint32_t u32ID)
{
    int32_t  rev = (int32_t)TRUE;
    uint32_t i = 0ul;
    uint32_t u32TimeOutCount;
    uint32_t u32EOB_Flag = 0ul;

    for(i = 1ul; i < u32MsgCount; i++)
    {
        u32TimeOutCount = 0ul;

        u32MsgNum += (i - 1ul);

        if(i == u32MsgCount)
        {
            u32EOB_Flag = 1ul;
        }
        else
        {
        }

        while(CAN_SetRxMsgObj(tCAN, (uint8_t)u32MsgNum, (uint8_t)u32IDType, u32ID, (uint8_t)u32EOB_Flag) == (int32_t)FALSE)
        {
            if(++u32TimeOutCount >= RETRY_COUNTS)
            {
                rev = (int32_t)FALSE;
                break;
            }
            else
            {
            }
        }
    }

    return rev;
}


int32_t CAN_Transmit(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T* pCanMsg)
{
    int32_t rev = (int32_t)TRUE;
    uint32_t u32Tmp;

    u32Tmp = (tCAN->TEST & CAN_TEST_BASIC_Msk);

    if((tCAN->CON & CAN_CON_TEST_Msk) && u32Tmp)
    {
        rev = CAN_BasicSendMsg(tCAN, pCanMsg);
    }
    else
    {
        if(CAN_SetTxMsg(tCAN, u32MsgNum, pCanMsg) == FALSE)
        {
            rev = (int32_t)FALSE;
        }
        else
        {
            CAN_TriggerTxMsg(tCAN, u32MsgNum);
        }
    }

    return rev;
}


int32_t CAN_Receive(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T* pCanMsg)
{
    int32_t rev = (int32_t)TRUE;
    uint32_t u32Tmp;

    u32Tmp = (tCAN->TEST & CAN_TEST_BASIC_Msk);

    if((tCAN->CON & CAN_CON_TEST_Msk) && u32Tmp)
    {
        rev = CAN_BasicReceiveMsg(tCAN, pCanMsg);
    }
    else
    {
        rev = CAN_ReadMsgObj(tCAN, (uint8_t)u32MsgNum, (uint8_t)TRUE, pCanMsg);
    }

    return rev;
}

void CAN_CLR_INT_PENDING_BIT(CAN_T *tCAN, uint8_t u32MsgNum)
{
    uint32_t u32MsgIfNum;

    if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
    {
        u32MsgIfNum = 0ul;
    }
    else
    {
    }

    tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_CLRINTPND_Msk | CAN_IF_CMASK_TXRQSTNEWDAT_Msk;
    tCAN->IF[u32MsgIfNum].CREQ = 1ul + u32MsgNum;

    ReleaseIF(tCAN, u32MsgIfNum);
}

 /* end of group CAN_EXPORTED_FUNCTIONS */
 /* end of group CAN_Driver */
 /* end of group Standard_Driver */

/*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/