Can_api

Data Structures
struct	tCANMsgObject
struct	tCANBitClkParms

Macros
#define	CAN_MAX_11BIT_MSG_ID   0x7ff
#define	CAN_MAX_BIT_DIVISOR   19
#define	CAN_MIN_BIT_DIVISOR   4
#define	CAN_MAX_PRE_DIVISOR   1024
#define	CAN_MIN_PRE_DIVISOR   1
#define	CAN_BIT_VALUE(seg1, seg2, sjw)
#define	MSG_OBJ_TX_INT_ENABLE   0x00000001
	This indicates that transmit interrupts are enabled. More...
#define	MSG_OBJ_RX_INT_ENABLE   0x00000002
	This indicates that receive interrupts are enabled. More...
#define	MSG_OBJ_EXTENDED_ID   0x00000004
	This indicates that a message object is using an extended identifier. More...
#define	MSG_OBJ_USE_ID_FILTER   0x00000008
#define	MSG_OBJ_NEW_DATA   0x00000080
	This indicates that new data was available in the message object. More...
#define	MSG_OBJ_DATA_LOST   0x00000100
#define	MSG_OBJ_USE_DIR_FILTER   (0x00000010 | MSG_OBJ_USE_ID_FILTER)
#define	MSG_OBJ_USE_EXT_FILTER   (0x00000020 | MSG_OBJ_USE_ID_FILTER)
#define	MSG_OBJ_REMOTE_FRAME   0x00000040
	This indicates that a message object is a remote frame. More...
#define	MSG_OBJ_FIFO   0x00000200
#define	MSG_OBJ_NO_FLAGS   0x00000000
	This indicates that a message object has no flags set. More...
#define	MSG_OBJ_STATUS_MASK   (MSG_OBJ_NEW_DATA | MSG_OBJ_DATA_LOST)
#define	CAN_INT_ERROR   0x00000008
#define	CAN_INT_STATUS   0x00000004
#define	CAN_INT_MASTER   0x00000002
#define	CAN_STATUS_BUS_OFF   0x00000080
	CAN controller has entered a Bus Off state. More...
#define	CAN_STATUS_EWARN   0x00000040
	CAN controller error level has reached warning level. More...
#define	CAN_STATUS_EPASS   0x00000020
	CAN controller error level has reached error passive level. More...
#define	CAN_STATUS_RXOK   0x00000010
	A message was received successfully since the last read of this status. More...
#define	CAN_STATUS_TXOK   0x00000008
#define	CAN_STATUS_LEC_MSK   0x00000007
	This is the mask for the last error code field. More...
#define	CAN_STATUS_LEC_NONE   0x00000000
	There was no error. More...
#define	CAN_STATUS_LEC_STUFF   0x00000001
	A bit stuffing error has occurred. More...
#define	CAN_STATUS_LEC_FORM   0x00000002
	A formatting error has occurred. More...
#define	CAN_STATUS_LEC_ACK   0x00000003
	An acknowledge error has occurred. More...
#define	CAN_STATUS_LEC_BIT1   0x00000004
	The bus remained a bit level of 1 for longer than is allowed. More...
#define	CAN_STATUS_LEC_BIT0   0x00000005
	The bus remained a bit level of 0 for longer than is allowed. More...
#define	CAN_STATUS_LEC_CRC   0x00000006
	A CRC error has occurred. More...
#define	CAN_STATUS_LEC_MASK   0x00000007
	This is the mask for the CAN Last Error Code (LEC). More...

Enumerations
enum	tCANIntStsReg { CAN_INT_STS_CAUSE, CAN_INT_STS_OBJECT }
enum	tCANStsReg { CAN_STS_CONTROL, CAN_STS_TXREQUEST, CAN_STS_NEWDAT, CAN_STS_MSGVAL }
enum	tMsgObjType {   MSG_OBJ_TYPE_TX, MSG_OBJ_TYPE_TX_REMOTE, MSG_OBJ_TYPE_RX, MSG_OBJ_TYPE_RX_REMOTE,   MSG_OBJ_TYPE_RXTX_REMOTE }

Functions
static uint_fast8_t	_CANIntNumberGet (uint32_t ui32Base)
static void	_CANDataRegWrite (uint8_t *pui8Data, uint32_t *pui32Register, uint32_t ui32Size)
static void	_CANDataRegRead (uint8_t *pui8Data, uint32_t *pui32Register, uint32_t ui32Size)
void	CANInit (uint32_t ui32Base)
void	CANEnable (uint32_t ui32Base)
void	CANDisable (uint32_t ui32Base)
void	CANBitTimingGet (uint32_t ui32Base, tCANBitClkParms *psClkParms)
uint32_t	CANBitRateSet (uint32_t ui32Base, uint32_t ui32SourceClock, uint32_t ui32BitRate)
void	CANBitTimingSet (uint32_t ui32Base, tCANBitClkParms *psClkParms)
void	CANIntRegister (uint32_t ui32Base, void(*pfnHandler)(void))
void	CANIntUnregister (uint32_t ui32Base)
void	CANIntEnable (uint32_t ui32Base, uint32_t ui32IntFlags)
void	CANIntDisable (uint32_t ui32Base, uint32_t ui32IntFlags)
uint32_t	CANIntStatus (uint32_t ui32Base, tCANIntStsReg eIntStsReg)
void	CANIntClear (uint32_t ui32Base, uint32_t ui32IntClr)
void	CANRetrySet (uint32_t ui32Base, bool bAutoRetry)
bool	CANRetryGet (uint32_t ui32Base)
uint32_t	CANStatusGet (uint32_t ui32Base, tCANStsReg eStatusReg)
bool	CANErrCntrGet (uint32_t ui32Base, uint32_t *pui32RxCount, uint32_t *pui32TxCount)
void	CANMessageSet (uint32_t ui32Base, uint32_t ui32ObjID, tCANMsgObject *psMsgObject, tMsgObjType eMsgType)
void	CANMessageGet (uint32_t ui32Base, uint32_t ui32ObjID, tCANMsgObject *psMsgObject, bool bClrPendingInt)
void	CANMessageClear (uint32_t ui32Base, uint32_t ui32ObjID)

Variables
static const uint16_t	g_ui16CANBitValues []

Detailed Description

Macro Definition Documentation

#define CAN_BIT_VALUE	(		seg1,
			seg2,
			sjw
	)

Value:

((((seg1 - 1) << CAN_BIT_TSEG1_S) &           \
                                  CAN_BIT_TSEG1_M) |                          \
                                 (((seg2 - 1) << CAN_BIT_TSEG2_S) &           \
                                  CAN_BIT_TSEG2_M) |                          \
                                 (((sjw - 1) << CAN_BIT_SJW_S) &              \
                                  CAN_BIT_SJW_M))

Definition at line 101 of file can.c.

#define CAN_INT_ERROR   0x00000008

This flag is used to allow a CAN controller to generate error interrupts.

Definition at line 277 of file can.h.

#define CAN_INT_MASTER   0x00000002

This flag is used to allow a CAN controller to generate any CAN interrupts. If this is not set, then no interrupts are generated by the CAN controller.

Definition at line 290 of file can.h.

#define CAN_INT_STATUS   0x00000004

This flag is used to allow a CAN controller to generate status interrupts.

Definition at line 283 of file can.h.

#define CAN_MAX_11BIT_MSG_ID   0x7ff

Definition at line 65 of file can.c.

Referenced by CANMessageSet().

#define CAN_MAX_BIT_DIVISOR   19

Definition at line 72 of file can.c.

Referenced by CANBitRateSet().

#define CAN_MAX_PRE_DIVISOR   1024

Definition at line 86 of file can.c.

Referenced by CANBitRateSet().

#define CAN_MIN_BIT_DIVISOR   4

Definition at line 79 of file can.c.

Referenced by CANBitRateSet().

#define CAN_MIN_PRE_DIVISOR   1

Definition at line 93 of file can.c.

Referenced by CANBitRateSet().

#define CAN_STATUS_BUS_OFF   0x00000080

CAN controller has entered a Bus Off state.

Definition at line 336 of file can.h.

#define CAN_STATUS_EPASS   0x00000020

CAN controller error level has reached error passive level.

Definition at line 346 of file can.h.

#define CAN_STATUS_EWARN   0x00000040

CAN controller error level has reached warning level.

Definition at line 341 of file can.h.

#define CAN_STATUS_LEC_ACK   0x00000003

An acknowledge error has occurred.

Definition at line 382 of file can.h.

#define CAN_STATUS_LEC_BIT0   0x00000005

The bus remained a bit level of 0 for longer than is allowed.

Definition at line 392 of file can.h.

#define CAN_STATUS_LEC_BIT1   0x00000004

The bus remained a bit level of 1 for longer than is allowed.

Definition at line 387 of file can.h.

#define CAN_STATUS_LEC_CRC   0x00000006

A CRC error has occurred.

Definition at line 397 of file can.h.

#define CAN_STATUS_LEC_FORM   0x00000002

A formatting error has occurred.

Definition at line 377 of file can.h.

#define CAN_STATUS_LEC_MASK   0x00000007

This is the mask for the CAN Last Error Code (LEC).

Definition at line 402 of file can.h.

#define CAN_STATUS_LEC_MSK   0x00000007

This is the mask for the last error code field.

Definition at line 362 of file can.h.

#define CAN_STATUS_LEC_NONE   0x00000000

There was no error.

Definition at line 367 of file can.h.

#define CAN_STATUS_LEC_STUFF   0x00000001

A bit stuffing error has occurred.

Definition at line 372 of file can.h.

#define CAN_STATUS_RXOK   0x00000010

A message was received successfully since the last read of this status.

Definition at line 351 of file can.h.

#define CAN_STATUS_TXOK   0x00000008

A message was transmitted successfully since the last read of this status.

Definition at line 357 of file can.h.

#define MSG_OBJ_DATA_LOST   0x00000100

This indicates that data was lost since this message object was last read.

Definition at line 104 of file can.h.

Referenced by CANMessageGet().

#define MSG_OBJ_EXTENDED_ID   0x00000004

This indicates that a message object is using an extended identifier.

Definition at line 87 of file can.h.

Referenced by CANMessageGet(), and CANMessageSet().

#define MSG_OBJ_FIFO   0x00000200

This indicates that this message object is part of a FIFO structure and not the final message object in a FIFO.

Definition at line 129 of file can.h.

Referenced by CANMessageSet().

#define MSG_OBJ_NEW_DATA   0x00000080

This indicates that new data was available in the message object.

Definition at line 98 of file can.h.

Referenced by CANMessageGet().

#define MSG_OBJ_NO_FLAGS   0x00000000

This indicates that a message object has no flags set.

Definition at line 134 of file can.h.

Referenced by CANMessageGet().

#define MSG_OBJ_REMOTE_FRAME   0x00000040

This indicates that a message object is a remote frame.

Definition at line 123 of file can.h.

Referenced by CANMessageGet().

#define MSG_OBJ_RX_INT_ENABLE   0x00000002

This indicates that receive interrupts are enabled.

Definition at line 82 of file can.h.

Referenced by CANMessageGet(), and CANMessageSet().

#define MSG_OBJ_STATUS_MASK   (MSG_OBJ_NEW_DATA | MSG_OBJ_DATA_LOST)

This define is used with the flag values to allow checking only status flags and not configuration flags.

Definition at line 142 of file can.h.

#define MSG_OBJ_TX_INT_ENABLE   0x00000001

This indicates that transmit interrupts are enabled.

Definition at line 77 of file can.h.

Referenced by CANMessageGet(), and CANMessageSet().

#define MSG_OBJ_USE_DIR_FILTER   (0x00000010 | MSG_OBJ_USE_ID_FILTER)

This indicates that a message object uses or is using filtering based on the direction of the transfer. If the direction filtering is used, then ID filtering must also be enabled.

Definition at line 111 of file can.h.

Referenced by CANMessageGet(), and CANMessageSet().

#define MSG_OBJ_USE_EXT_FILTER   (0x00000020 | MSG_OBJ_USE_ID_FILTER)

This indicates that a message object uses or is using message identifier filtering based on the extended identifier. If the extended identifier filtering is used, then ID filtering must also be enabled.

Definition at line 118 of file can.h.

Referenced by CANMessageGet(), and CANMessageSet().

#define MSG_OBJ_USE_ID_FILTER   0x00000008

This indicates that a message object is using filtering based on the object's message identifier.

Definition at line 93 of file can.h.

Referenced by CANMessageGet(), and CANMessageSet().

Enumeration Type Documentation

enum tCANIntStsReg

This data type is used to identify the interrupt status register. This is used when calling the CANIntStatus() function.

Enumerator
CAN_INT_STS_CAUSE	Read the CAN interrupt status information.
CAN_INT_STS_OBJECT	Read a message object's interrupt status.

Definition at line 222 of file can.h.

{
    //
    //
    CAN_INT_STS_CAUSE,

    //
    //
    CAN_INT_STS_OBJECT
}

enum tCANStsReg

This data type is used to identify which of several status registers to read when calling the CANStatusGet() function.

Enumerator
CAN_STS_CONTROL	Read the full CAN controller status.
CAN_STS_TXREQUEST	Read the full 32-bit mask of message objects with a transmit request set.
CAN_STS_NEWDAT	Read the full 32-bit mask of message objects with new data available.
CAN_STS_MSGVAL	Read the full 32-bit mask of message objects that are enabled.

Definition at line 242 of file can.h.

{
    //
    //
    CAN_STS_CONTROL,

    //
    //
    CAN_STS_TXREQUEST,

    //
    //
    CAN_STS_NEWDAT,

    //
    //
    CAN_STS_MSGVAL
}

enum tMsgObjType

This definition is used to determine the type of message object that is set up via a call to the CANMessageSet() API.

Enumerator
MSG_OBJ_TYPE_TX	Transmit message object.
MSG_OBJ_TYPE_TX_REMOTE	Transmit remote request message object.
MSG_OBJ_TYPE_RX	Receive message object.
MSG_OBJ_TYPE_RX_REMOTE	Receive remote request message object.
MSG_OBJ_TYPE_RXTX_REMOTE	Remote frame receive remote, with auto-transmit message object.

Definition at line 298 of file can.h.

{
    //
    //
    MSG_OBJ_TYPE_TX,

    //
    //
    MSG_OBJ_TYPE_TX_REMOTE,

    //
    //
    MSG_OBJ_TYPE_RX,

    //
    //
    MSG_OBJ_TYPE_RX_REMOTE,

    //
    //
    MSG_OBJ_TYPE_RXTX_REMOTE
}

Function Documentation

static void _CANDataRegRead ( uint8_t *  pui8Data, uint32_t *  pui32Register, uint32_t  ui32Size  )

static

Definition at line 278 of file can.c.

References HWREG.

Referenced by CANMessageGet().

{
    uint32_t ui32Idx, ui32Value;

    //
    // Loop always copies 1 or 2 bytes per iteration.
    //
    for(ui32Idx = 0; ui32Idx < ui32Size; )
    {
        //
        // Read out the data 16 bits at a time since this is how the registers
        // are aligned in memory.
        //
        ui32Value = HWREG(pui32Register++);

        //
        // Store the first byte.
        //
        pui8Data[ui32Idx++] = (uint8_t)ui32Value;

        //
        // Only read the second byte if needed.
        //
        if(ui32Idx < ui32Size)
        {
            pui8Data[ui32Idx++] = (uint8_t)(ui32Value >> 8);
        }
    }
}

Here is the caller graph for this function:

static void _CANDataRegWrite ( uint8_t *  pui8Data, uint32_t *  pui32Register, uint32_t  ui32Size  )

static

Definition at line 229 of file can.c.

References HWREG.

Referenced by CANMessageSet().

{
    uint32_t ui32Idx, ui32Value;

    //
    // Loop always copies 1 or 2 bytes per iteration.
    //
    for(ui32Idx = 0; ui32Idx < ui32Size; )
    {
        //
        // Write out the data 16 bits at a time since this is how the registers
        // are aligned in memory.
        //
        ui32Value = pui8Data[ui32Idx++];

        //
        // Only write the second byte if needed otherwise the value is zero.
        //
        if(ui32Idx < ui32Size)
        {
            ui32Value |= (pui8Data[ui32Idx++] << 8);
        }

        HWREG(pui32Register++) = ui32Value;
    }
}

Here is the caller graph for this function:

static uint_fast8_t _CANIntNumberGet ( uint32_t  ui32Base )

static

Returns the CAN controller interrupt number.

Parameters

ui32Base

is the base address of the selected CAN controller

This function returns the interrupt number for the CAN module with the base address passed in the ui32Base parameter.

Returns

Returns a CAN interrupt number or 0 if the interrupt does not exist.

Definition at line 170 of file can.c.

References ASSERT, CAN0_BASE, CAN1_BASE, CLASS_IS_TM4C123, CLASS_IS_TM4C129, INT_CAN0_TM4C123, INT_CAN0_TM4C129, INT_CAN1_TM4C123, and INT_CAN1_TM4C129.

Referenced by CANIntRegister(), and CANIntUnregister().

{
    uint_fast8_t ui8Int;

    ASSERT((ui32Base == CAN0_BASE) || (ui32Base == CAN1_BASE));

    ui8Int = 0;

    //
    // Find the valid interrupt number for this CAN controller.
    //
    if(CLASS_IS_TM4C123)
    {
        if(ui32Base == CAN0_BASE)
        {
            ui8Int = INT_CAN0_TM4C123;
        }
        else if(ui32Base == CAN1_BASE)
        {
            ui8Int = INT_CAN1_TM4C123;
        }
    }
    else if(CLASS_IS_TM4C129)
    {
        if(ui32Base == CAN0_BASE)
        {
            ui8Int = INT_CAN0_TM4C129;
        }
        else if(ui32Base == CAN1_BASE)
        {
            ui8Int = INT_CAN1_TM4C129;
        }
    }

    return(ui8Int);
}

Here is the caller graph for this function:

uint32_t CANBitRateSet	(	uint32_t	ui32Base,
		uint32_t	ui32SourceClock,
		uint32_t	ui32BitRate
	)

Sets the CAN bit timing values to a nominal setting based on a desired bit rate.

Parameters

ui32Base	is the base address of the CAN controller.
ui32SourceClock	is the system clock for the device in Hz.
ui32BitRate	is the desired bit rate.

This function sets the CAN bit timing for the bit rate passed in the ui32BitRate parameter based on the ui32SourceClock parameter. Because the CAN clock is based off of the system clock, the calling function must pass in the source clock rate either by retrieving it from SysCtlClockGet() or using a specific value in Hz. The CAN bit timing is calculated assuming a minimal amount of propagation delay, which works for most cases where the network length is short. If tighter timing requirements or longer network lengths are needed, then the CANBitTimingSet() function is available for full customization of all of the CAN bit timing values. Because not all bit rates can be matched exactly, the bit rate is set to the value closest to the desired bit rate without being higher than the ui32BitRate value.

Note

On some devices the source clock is fixed at 8MHz so the ui32SourceClock must be set to 8000000.

Returns

This function returns the bit rate that the CAN controller was configured to use or it returns 0 to indicate that the bit rate was not changed because the requested bit rate was not valid.

Definition at line 554 of file can.c.

References ASSERT, CAN_BIT_BRP_M, CAN_BRPE_BRPE_M, CAN_CTL_CCE, CAN_CTL_INIT, CAN_MAX_BIT_DIVISOR, CAN_MAX_PRE_DIVISOR, CAN_MIN_BIT_DIVISOR, CAN_MIN_PRE_DIVISOR, CAN_O_BIT, CAN_O_BRPE, CAN_O_CTL, g_ui16CANBitValues, and HWREG.

{
    uint32_t ui32DesiredRatio;
    uint32_t ui32CANBits;
    uint32_t ui32PreDivide;
    uint32_t ui32RegValue;
    uint16_t ui16CANCTL;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));
    ASSERT(ui32SourceClock);
    ASSERT(ui32BitRate);

    //
    // Calculate the desired clock rate.
    //
    ui32DesiredRatio = ui32SourceClock / ui32BitRate;

    //
    // Make sure that the ratio of CAN bit rate to processor clock is not too
    // small or too large.
    //
    ASSERT(ui32DesiredRatio <= (CAN_MAX_PRE_DIVISOR * CAN_MAX_BIT_DIVISOR));
    ASSERT(ui32DesiredRatio >= (CAN_MIN_PRE_DIVISOR * CAN_MIN_BIT_DIVISOR));

    //
    // Make sure that the Desired Ratio is not too large.  This enforces the
    // requirement that the bit rate is larger than requested.
    //
    if((ui32SourceClock / ui32DesiredRatio) > ui32BitRate)
    {
        ui32DesiredRatio += 1;
    }

    //
    // Check all possible values to find a matching value.
    //
    while(ui32DesiredRatio <= (CAN_MAX_PRE_DIVISOR * CAN_MAX_BIT_DIVISOR))
    {
        //
        // Loop through all possible CAN bit divisors.
        //
        for(ui32CANBits = CAN_MAX_BIT_DIVISOR;
            ui32CANBits >= CAN_MIN_BIT_DIVISOR; ui32CANBits--)
        {
            //
            // For a given CAN bit divisor save the pre divisor.
            //
            ui32PreDivide = ui32DesiredRatio / ui32CANBits;

            //
            // If the calculated divisors match the desired clock ratio then
            // return these bit rate and set the CAN bit timing.
            //
            if((ui32PreDivide * ui32CANBits) == ui32DesiredRatio)
            {
                //
                // Start building the bit timing value by adding the bit timing
                // in time quanta.
                //
                ui32RegValue = g_ui16CANBitValues[ui32CANBits -
                                                  CAN_MIN_BIT_DIVISOR];

                //
                // To set the bit timing register, the controller must be
                // placed in init mode (if not already), and also configuration
                // change bit enabled.  The state of the register must be
                // saved so it can be restored.
                //
                ui16CANCTL = HWREG(ui32Base + CAN_O_CTL);
                HWREG(ui32Base + CAN_O_CTL) = ui16CANCTL | CAN_CTL_INIT |
                                              CAN_CTL_CCE;

                //
                // Now add in the pre-scalar on the bit rate.
                //
                ui32RegValue |= ((ui32PreDivide - 1) & CAN_BIT_BRP_M);

                //
                // Set the clock bits in the and the lower bits of the
                // pre-scalar.
                //
                HWREG(ui32Base + CAN_O_BIT) = ui32RegValue;

                //
                // Set the divider upper bits in the extension register.
                //
                HWREG(ui32Base + CAN_O_BRPE) = ((ui32PreDivide - 1) >> 6) &
                                               CAN_BRPE_BRPE_M;

                //
                // Restore the saved CAN Control register.
                //
                HWREG(ui32Base + CAN_O_CTL) = ui16CANCTL;

                //
                // Return the computed bit rate.
                //
                return(ui32SourceClock / (ui32PreDivide * ui32CANBits));
            }
        }

        //
        // Move the divisor up one and look again.  Only in rare cases are
        // more than 2 loops required to find the value.
        //
        ui32DesiredRatio++;
    }

    //
    // A valid combination could not be found, so return 0 to indicate that the
    // bit rate was not changed.
    //
    return(0);
}

void CANBitTimingGet	(	uint32_t	ui32Base,
		tCANBitClkParms *	psClkParms
	)

Reads the current settings for the CAN controller bit timing.

Parameters

ui32Base	is the base address of the CAN controller.
psClkParms	is a pointer to a structure to hold the timing parameters.

This function reads the current configuration of the CAN controller bit clock timing and stores the resulting information in the structure supplied by the caller. Refer to CANBitTimingSet() for the meaning of the values that are returned in the structure pointed to by psClkParms.

Returns

None.

Definition at line 483 of file can.c.

References ASSERT, CAN_BIT_BRP_M, CAN_BIT_SJW_M, CAN_BIT_SJW_S, CAN_BIT_TSEG1_M, CAN_BIT_TSEG1_S, CAN_BIT_TSEG2_M, CAN_BIT_TSEG2_S, CAN_BRPE_BRPE_M, CAN_O_BIT, CAN_O_BRPE, HWREG, tCANBitClkParms::ui32Phase2Seg, tCANBitClkParms::ui32QuantumPrescaler, tCANBitClkParms::ui32SJW, and tCANBitClkParms::ui32SyncPropPhase1Seg.

{
    uint32_t ui32BitReg;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));
    ASSERT(psClkParms);

    //
    // Read out all the bit timing values from the CAN controller registers.
    //
    ui32BitReg = HWREG(ui32Base + CAN_O_BIT);

    //
    // Set the phase 2 segment.
    //
    psClkParms->ui32Phase2Seg =
        ((ui32BitReg & CAN_BIT_TSEG2_M) >> CAN_BIT_TSEG2_S) + 1;

    //
    // Set the phase 1 segment.
    //
    psClkParms->ui32SyncPropPhase1Seg =
        ((ui32BitReg & CAN_BIT_TSEG1_M) >> CAN_BIT_TSEG1_S) + 1;

    //
    // Set the synchronous jump width.
    //
    psClkParms->ui32SJW = ((ui32BitReg & CAN_BIT_SJW_M) >> CAN_BIT_SJW_S) + 1;

    //
    // Set the pre-divider for the CAN bus bit clock.
    //
    psClkParms->ui32QuantumPrescaler =
        ((ui32BitReg & CAN_BIT_BRP_M) |
         ((HWREG(ui32Base + CAN_O_BRPE) & CAN_BRPE_BRPE_M) << 6)) + 1;
}

void CANBitTimingSet	(	uint32_t	ui32Base,
		tCANBitClkParms *	psClkParms
	)

Configures the CAN controller bit timing.

Parameters

ui32Base	is the base address of the CAN controller.
psClkParms	points to the structure with the clock parameters.

Configures the various timing parameters for the CAN bus bit timing: Propagation segment, Phase Buffer 1 segment, Phase Buffer 2 segment, and the Synchronization Jump Width. The values for Propagation and Phase Buffer 1 segments are derived from the combination psClkParms->ui32SyncPropPhase1Seg parameter. Phase Buffer 2 is determined from the psClkParms->ui32Phase2Seg parameter. These two parameters, along with psClkParms->ui32SJW are based in units of bit time quanta. The actual quantum time is determined by the psClkParms->ui32QuantumPrescaler value, which specifies the divisor for the CAN module clock.

The total bit time, in quanta, is the sum of the two Seg parameters, as follows:

bit_time_q = ui32SyncPropPhase1Seg + ui32Phase2Seg + 1

Note that the Sync_Seg is always one quantum in duration, and is added to derive the correct duration of Prop_Seg and Phase1_Seg.

The equation to determine the actual bit rate is as follows:

CAN Clock / ((ui32SyncPropPhase1Seg + ui32Phase2Seg + 1) * (ui32QuantumPrescaler))

Thus with ui32SyncPropPhase1Seg = 4, ui32Phase2Seg = 1, ui32QuantumPrescaler = 2 and an 8 MHz CAN clock, the bit rate is (8 MHz) / ((5 + 2 + 1) * 2) or 500 Kbit/sec.

Returns

None.

Definition at line 713 of file can.c.

References ASSERT, CAN_BIT_BRP_M, CAN_BIT_SJW_M, CAN_BIT_SJW_S, CAN_BIT_TSEG1_M, CAN_BIT_TSEG1_S, CAN_BIT_TSEG2_M, CAN_BIT_TSEG2_S, CAN_BRPE_BRPE_M, CAN_CTL_CCE, CAN_CTL_INIT, CAN_O_BIT, CAN_O_BRPE, CAN_O_CTL, HWREG, tCANBitClkParms::ui32Phase2Seg, tCANBitClkParms::ui32QuantumPrescaler, tCANBitClkParms::ui32SJW, and tCANBitClkParms::ui32SyncPropPhase1Seg.

{
    uint32_t ui32BitReg, ui32SavedInit;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));
    ASSERT(psClkParms);

    //
    // The phase 1 segment must be in the range from 2 to 16.
    //
    ASSERT((psClkParms->ui32SyncPropPhase1Seg >= 2) &&
           (psClkParms->ui32SyncPropPhase1Seg <= 16));

    //
    // The phase 2 segment must be in the range from 1 to 8.
    //
    ASSERT((psClkParms->ui32Phase2Seg >= 1) &&
           (psClkParms->ui32Phase2Seg <= 8));

    //
    // The synchronous jump windows must be in the range from 1 to 4.
    //
    ASSERT((psClkParms->ui32SJW >= 1) && (psClkParms->ui32SJW <= 4));

    //
    // The CAN clock pre-divider must be in the range from 1 to 1024.
    //
    ASSERT((psClkParms->ui32QuantumPrescaler <= 1024) &&
           (psClkParms->ui32QuantumPrescaler >= 1));

    //
    // To set the bit timing register, the controller must be placed in init
    // mode (if not already), and also configuration change bit enabled.  State
    // of the init bit must be saved so it can be restored at the end.
    //
    ui32SavedInit = HWREG(ui32Base + CAN_O_CTL);
    HWREG(ui32Base + CAN_O_CTL) = ui32SavedInit | CAN_CTL_INIT | CAN_CTL_CCE;

    //
    // Set the bit fields of the bit timing register according to the parms.
    //
    ui32BitReg = (((psClkParms->ui32Phase2Seg - 1) << CAN_BIT_TSEG2_S) &
                  CAN_BIT_TSEG2_M);
    ui32BitReg |= (((psClkParms->ui32SyncPropPhase1Seg - 1) <<
                    CAN_BIT_TSEG1_S) & CAN_BIT_TSEG1_M);
    ui32BitReg |= ((psClkParms->ui32SJW - 1) << CAN_BIT_SJW_S) & CAN_BIT_SJW_M;
    ui32BitReg |= (psClkParms->ui32QuantumPrescaler - 1) & CAN_BIT_BRP_M;
    HWREG(ui32Base + CAN_O_BIT) = ui32BitReg;

    //
    // Set the divider upper bits in the extension register.
    //
    HWREG(ui32Base + CAN_O_BRPE) =
        ((psClkParms->ui32QuantumPrescaler - 1) >> 6) & CAN_BRPE_BRPE_M;

    //
    // Clear the config change bit, and restore the init bit.
    //
    ui32SavedInit &= ~CAN_CTL_CCE;

    //
    // If Init was not set before, then clear it.
    //
    if(ui32SavedInit & CAN_CTL_INIT)
    {
        ui32SavedInit &= ~CAN_CTL_INIT;
    }

    HWREG(ui32Base + CAN_O_CTL) = ui32SavedInit;
}

void CANDisable

(

uint32_t

ui32Base

)

Disables the CAN controller.

Parameters

ui32Base

is the base address of the CAN controller to disable.

Disables the CAN controller for message processing. When disabled, the controller no longer automatically processes data on the CAN bus. The controller can be restarted by calling CANEnable(). The state of the CAN controller and the message objects in the controller are left as they were before this call was made.

Returns

None.

Definition at line 453 of file can.c.

References ASSERT, CAN_CTL_INIT, CAN_O_CTL, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    //
    // Set the init bit in the control register.
    //
    HWREG(ui32Base + CAN_O_CTL) |= CAN_CTL_INIT;
}

void CANEnable

(

uint32_t

ui32Base

)

Enables the CAN controller.

Parameters

ui32Base

is the base address of the CAN controller to enable.

Enables the CAN controller for message processing. Once enabled, the controller automatically transmits any pending frames, and processes any received frames. The controller can be stopped by calling CANDisable(). Prior to calling CANEnable(), CANInit() must have been called to initialize the controller and the CAN bus clock must be configured by calling CANBitTimingSet().

Returns

None.

Definition at line 424 of file can.c.

References ASSERT, CAN_CTL_INIT, CAN_O_CTL, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    //
    // Clear the init bit in the control register.
    //
    HWREG(ui32Base + CAN_O_CTL) &= ~CAN_CTL_INIT;
}

bool CANErrCntrGet	(	uint32_t	ui32Base,
		uint32_t *	pui32RxCount,
		uint32_t *	pui32TxCount
	)

Reads the CAN controller error counter register.

Parameters

ui32Base	is the base address of the CAN controller.
pui32RxCount	is a pointer to storage for the receive error counter.
pui32TxCount	is a pointer to storage for the transmit error counter.

This function reads the error counter register and returns the transmit and receive error counts to the caller along with a flag indicating if the controller receive counter has reached the error passive limit. The values of the receive and transmit error counters are returned through the pointers provided as parameters.

After this call, *pui32RxCount holds the current receive error count and *pui32TxCount holds the current transmit error count.

Returns

Returns true if the receive error count has reached the error passive limit, and false if the error count is below the error passive limit.

Definition at line 1364 of file can.c.

References ASSERT, CAN_ERR_REC_M, CAN_ERR_REC_S, CAN_ERR_RP, CAN_ERR_TEC_M, CAN_ERR_TEC_S, CAN_O_ERR, and HWREG.

{
    uint32_t ui32CANError;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    //
    // Read the current count of transmit/receive errors.
    //
    ui32CANError = HWREG(ui32Base + CAN_O_ERR);

    //
    // Extract the error numbers from the register value.
    //
    *pui32RxCount = (ui32CANError & CAN_ERR_REC_M) >> CAN_ERR_REC_S;
    *pui32TxCount = (ui32CANError & CAN_ERR_TEC_M) >> CAN_ERR_TEC_S;

    if(ui32CANError & CAN_ERR_RP)
    {
        return(true);
    }
    return(false);
}

void CANInit

(

uint32_t

ui32Base

)

Initializes the CAN controller after reset.

Parameters

ui32Base

is the base address of the CAN controller.

After reset, the CAN controller is left in the disabled state. However, the memory used for message objects contains undefined values and must be cleared prior to enabling the CAN controller the first time. This prevents unwanted transmission or reception of data before the message objects are configured. This function must be called before enabling the controller the first time.

Returns

None.

Definition at line 325 of file can.c.

References ASSERT, CAN_CTL_INIT, CAN_IF1CMSK_ARB, CAN_IF1CMSK_CLRINTPND, CAN_IF1CMSK_CONTROL, CAN_IF1CMSK_NEWDAT, CAN_IF1CMSK_WRNRD, CAN_IF1CRQ_BUSY, CAN_O_CTL, CAN_O_IF1ARB2, CAN_O_IF1CMSK, CAN_O_IF1CRQ, CAN_O_IF1MCTL, CAN_O_STS, and HWREG.

{
    uint32_t ui32Msg;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    //
    // Place CAN controller in init state, regardless of previous state.  This
    // puts controller in idle, and allow the message object RAM to be
    // programmed.
    //
    HWREG(ui32Base + CAN_O_CTL) = CAN_CTL_INIT;

    //
    // Wait for busy bit to clear
    //
    while(HWREG(ui32Base + CAN_O_IF1CRQ) & CAN_IF1CRQ_BUSY)
    {
    }

    //
    // Clear the message value bit in the arbitration register.  This indicates
    // the message is not valid and is a "safe" condition to leave the message
    // object.  The same arb reg is used to program all the message objects.
    //
    HWREG(ui32Base + CAN_O_IF1CMSK) = (CAN_IF1CMSK_WRNRD | CAN_IF1CMSK_ARB |
                                       CAN_IF1CMSK_CONTROL);
    HWREG(ui32Base + CAN_O_IF1ARB2) = 0;
    HWREG(ui32Base + CAN_O_IF1MCTL) = 0;

    //
    // Loop through to program all 32 message objects
    //
    for(ui32Msg = 1; ui32Msg <= 32; ui32Msg++)
    {
        //
        // Wait for busy bit to clear
        //
        while(HWREG(ui32Base + CAN_O_IF1CRQ) & CAN_IF1CRQ_BUSY)
        {
        }

        //
        // Initiate programming the message object
        //
        HWREG(ui32Base + CAN_O_IF1CRQ) = ui32Msg;
    }

    //
    // Make sure that the interrupt and new data flags are updated for the
    // message objects.
    //
    HWREG(ui32Base + CAN_O_IF1CMSK) = (CAN_IF1CMSK_NEWDAT |
                                       CAN_IF1CMSK_CLRINTPND);

    //
    // Loop through to program all 32 message objects
    //
    for(ui32Msg = 1; ui32Msg <= 32; ui32Msg++)
    {
        //
        // Wait for busy bit to clear.
        //
        while(HWREG(ui32Base + CAN_O_IF1CRQ) & CAN_IF1CRQ_BUSY)
        {
        }

        //
        // Initiate programming the message object
        //
        HWREG(ui32Base + CAN_O_IF1CRQ) = ui32Msg;
    }

    //
    // Acknowledge any pending status interrupts.
    //
    HWREG(ui32Base + CAN_O_STS);
}

void CANIntClear	(	uint32_t	ui32Base,
		uint32_t	ui32IntClr
	)

Clears a CAN interrupt source.

Parameters

ui32Base	is the base address of the CAN controller.
ui32IntClr	is a value indicating which interrupt source to clear.

This function can be used to clear a specific interrupt source. The ui32IntClr parameter must be one of the following values:

• CAN_INT_INTID_STATUS - Clears a status interrupt.
• 1-32 - Clears the specified message object interrupt

It is not necessary to use this function to clear an interrupt. This function is only used if the application wants to clear an interrupt source without taking the normal interrupt action.

Normally, the status interrupt is cleared by reading the controller status using CANStatusGet(). A specific message object interrupt is normally cleared by reading the message object using CANMessageGet().

Note

Because there is a write buffer in the Cortex-M processor, it may take several clock cycles before the interrupt source is actually cleared. Therefore, it is recommended that the interrupt source be cleared early in the interrupt handler (as opposed to the very last action) to avoid returning from the interrupt handler before the interrupt source is actually cleared. Failure to do so may result in the interrupt handler being immediately reentered (because the interrupt controller still sees the interrupt source asserted).

Returns

None.

Definition at line 1084 of file can.c.

References ASSERT, CAN_IF1CMSK_CLRINTPND, CAN_IF1CRQ_BUSY, CAN_IF1CRQ_MNUM_M, CAN_INT_INTID_STATUS, CAN_O_IF1CMSK, CAN_O_IF1CRQ, CAN_O_STS, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));
    ASSERT((ui32IntClr == CAN_INT_INTID_STATUS) ||
           ((ui32IntClr >= 1) && (ui32IntClr <= 32)));

    if(ui32IntClr == CAN_INT_INTID_STATUS)
    {
        //
        // Simply read and discard the status to clear the interrupt.
        //
        HWREG(ui32Base + CAN_O_STS);
    }
    else
    {
        //
        // Wait to be sure that this interface is not busy.
        //
        while(HWREG(ui32Base + CAN_O_IF1CRQ) & CAN_IF1CRQ_BUSY)
        {
        }

        //
        // Only change the interrupt pending state by setting only the
        // CAN_IF1CMSK_CLRINTPND bit.
        //
        HWREG(ui32Base + CAN_O_IF1CMSK) = CAN_IF1CMSK_CLRINTPND;

        //
        // Send the clear pending interrupt command to the CAN controller.
        //
        HWREG(ui32Base + CAN_O_IF1CRQ) = ui32IntClr & CAN_IF1CRQ_MNUM_M;

        //
        // Wait to be sure that this interface is not busy.
        //
        while(HWREG(ui32Base + CAN_O_IF1CRQ) & CAN_IF1CRQ_BUSY)
        {
        }
    }
}

void CANIntDisable	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

Disables individual CAN controller interrupt sources.

Parameters

ui32Base	is the base address of the CAN controller.
ui32IntFlags	is the bit mask of the interrupt sources to be disabled.

Disables the specified CAN controller interrupt sources. Only enabled interrupt sources can cause a processor interrupt.

The ui32IntFlags parameter has the same definition as in the CANIntEnable() function.

Returns

None.

Definition at line 944 of file can.c.

References ASSERT, CAN_CTL_EIE, CAN_CTL_IE, CAN_CTL_SIE, CAN_O_CTL, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));
    ASSERT((ui32IntFlags & ~(CAN_CTL_EIE | CAN_CTL_SIE | CAN_CTL_IE)) == 0);

    //
    // Disable the specified interrupts.
    //
    HWREG(ui32Base + CAN_O_CTL) &= ~ui32IntFlags;
}

void CANIntEnable	(	uint32_t	ui32Base,
		uint32_t	ui32IntFlags
	)

Enables individual CAN controller interrupt sources.

Parameters

ui32Base	is the base address of the CAN controller.
ui32IntFlags	is the bit mask of the interrupt sources to be enabled.

This function enables specific interrupt sources of the CAN controller. Only enabled sources cause a processor interrupt.

The ui32IntFlags parameter is the logical OR of any of the following:

• CAN_INT_ERROR - a controller error condition has occurred
• CAN_INT_STATUS - a message transfer has completed, or a bus error has been detected
• CAN_INT_MASTER - allow CAN controller to generate interrupts

In order to generate any interrupts, CAN_INT_MASTER must be enabled. Further, for any particular transaction from a message object to generate an interrupt, that message object must have interrupts enabled (see CANMessageSet()). CAN_INT_ERROR generates an interrupt if the controller enters the ``bus off'' condition, or if the error counters reach a limit. CAN_INT_STATUS generates an interrupt under quite a few status conditions and may provide more interrupts than the application needs to handle. When an interrupt occurs, use CANIntStatus() to determine the cause.

Returns

None.

Definition at line 912 of file can.c.

References ASSERT, CAN_CTL_EIE, CAN_CTL_IE, CAN_CTL_SIE, CAN_O_CTL, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));
    ASSERT((ui32IntFlags & ~(CAN_CTL_EIE | CAN_CTL_SIE | CAN_CTL_IE)) == 0);

    //
    // Enable the specified interrupts.
    //
    HWREG(ui32Base + CAN_O_CTL) |= ui32IntFlags;
}

void CANIntRegister	(	uint32_t	ui32Base,
		void(*)(void)	pfnHandler
	)

Registers an interrupt handler for the CAN controller.

Parameters

ui32Base	is the base address of the CAN controller.
pfnHandler	is a pointer to the function to be called when the enabled CAN interrupts occur.

This function registers the interrupt handler in the interrupt vector table, and enables CAN interrupts on the interrupt controller; specific CAN interrupt sources must be enabled using CANIntEnable(). The interrupt handler being registered must clear the source of the interrupt using CANIntClear().

If the application is using a static interrupt vector table stored in flash, then it is not necessary to register the interrupt handler this way. Instead, IntEnable() is used to enable CAN interrupts on the interrupt controller.

See also

IntRegister() for important information about registering interrupt handlers.

Returns

None.

Definition at line 813 of file can.c.

References _CANIntNumberGet(), ASSERT, IntEnable(), and IntRegister().

{
    uint_fast8_t ui8IntNumber;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    //
    // Get the actual interrupt number for this CAN controller.
    //
    ui8IntNumber = _CANIntNumberGet(ui32Base);
    ASSERT(ui8IntNumber != 0);

    //
    // Register the interrupt handler.
    //
    IntRegister(ui8IntNumber, pfnHandler);

    //
    // Enable the Ethernet interrupt.
    //
    IntEnable(ui8IntNumber);
}

Here is the call graph for this function:

uint32_t CANIntStatus	(	uint32_t	ui32Base,
		tCANIntStsReg	eIntStsReg
	)

Returns the current CAN controller interrupt status.

Parameters

ui32Base	is the base address of the CAN controller.
eIntStsReg	indicates which interrupt status register to read

This function returns the value of one of two interrupt status registers. The interrupt status register read is determined by the eIntStsReg parameter, which can have one of the following values:

• CAN_INT_STS_CAUSE - indicates the cause of the interrupt
• CAN_INT_STS_OBJECT - indicates pending interrupts of all message objects

CAN_INT_STS_CAUSE returns the value of the controller interrupt register and indicates the cause of the interrupt. The value returned is CAN_INT_INTID_STATUS if the cause is a status interrupt. In this case, the status register is read with the CANStatusGet() function. Calling this function to read the status also clears the status interrupt. If the value of the interrupt register is in the range 1-32, then this indicates the number of the highest priority message object that has an interrupt pending. The message object interrupt can be cleared by using the CANIntClear() function, or by reading the message using CANMessageGet() in the case of a received message. The interrupt handler can read the interrupt status again to make sure all pending interrupts are cleared before returning from the interrupt.

CAN_INT_STS_OBJECT returns a bit mask indicating which message objects have pending interrupts. This value can be used to discover all of the pending interrupts at once, as opposed to repeatedly reading the interrupt register by using CAN_INT_STS_CAUSE.

Returns

Returns the value of one of the interrupt status registers.

Definition at line 995 of file can.c.

References ASSERT, CAN_INT_STS_CAUSE, CAN_INT_STS_OBJECT, CAN_MSG1INT_INTPND_M, CAN_O_INT, CAN_O_MSG1INT, CAN_O_MSG2INT, and HWREG.

{
    uint32_t ui32Status;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    //
    // See which status the caller is looking for.
    //
    switch(eIntStsReg)
    {
        //
        // The caller wants the global interrupt status for the CAN controller
        // specified by ui32Base.
        //
        case CAN_INT_STS_CAUSE:
        {
            ui32Status = HWREG(ui32Base + CAN_O_INT);
            break;
        }

        //
        // The caller wants the current message status interrupt for all
        // messages.
        //
        case CAN_INT_STS_OBJECT:
        {
            //
            // Read and combine both 16 bit values into one 32bit status.
            //
            ui32Status = (HWREG(ui32Base + CAN_O_MSG1INT) &
                          CAN_MSG1INT_INTPND_M);
            ui32Status |= (HWREG(ui32Base + CAN_O_MSG2INT) << 16);
            break;
        }

        //
        // Request was for unknown status so just return 0.
        //
        default:
        {
            ui32Status = 0;
            break;
        }
    }

    //
    // Return the interrupt status value
    //
    return(ui32Status);
}

void CANIntUnregister

(

uint32_t

ui32Base

)

Unregisters an interrupt handler for the CAN controller.

Parameters

ui32Base

is the base address of the controller.

This function unregisters the previously registered interrupt handler and disables the interrupt in the interrupt controller.

See also

IntRegister() for important information about registering interrupt handlers.

Returns

None.

Definition at line 855 of file can.c.

References _CANIntNumberGet(), ASSERT, IntDisable(), and IntUnregister().

{
    uint_fast8_t ui8IntNumber;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    //
    // Get the actual interrupt number for this CAN controller.
    //
    ui8IntNumber = _CANIntNumberGet(ui32Base);
    ASSERT(ui8IntNumber != 0);

    //
    // Disable the CAN interrupt.
    //
    IntDisable(ui8IntNumber);

    //
    // Register the interrupt handler.
    //
    IntUnregister(ui8IntNumber);
}

Here is the call graph for this function:

void CANMessageClear	(	uint32_t	ui32Base,
		uint32_t	ui32ObjID
	)

Clears a message object so that it is no longer used.

Parameters

ui32Base	is the base address of the CAN controller.
ui32ObjID	is the message object number to disable (1-32).

This function frees the specified message object from use. Once a message object has been ``cleared,'' it no longer automatically sends or receives messages, nor does it generate interrupts.

Returns

None.

Definition at line 2083 of file can.c.

References ASSERT, CAN_IF1CMSK_ARB, CAN_IF1CMSK_WRNRD, CAN_IF1CRQ_BUSY, CAN_IF1CRQ_MNUM_M, CAN_O_IF1ARB1, CAN_O_IF1ARB2, CAN_O_IF1CMSK, CAN_O_IF1CRQ, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));
    ASSERT((ui32ObjID >= 1) && (ui32ObjID <= 32));

    //
    // Wait for busy bit to clear
    //
    while(HWREG(ui32Base + CAN_O_IF1CRQ) & CAN_IF1CRQ_BUSY)
    {
    }

    //
    // Clear the message value bit in the arbitration register.  This indicates
    // the message is not valid.
    //
    HWREG(ui32Base + CAN_O_IF1CMSK) = CAN_IF1CMSK_WRNRD | CAN_IF1CMSK_ARB;
    HWREG(ui32Base + CAN_O_IF1ARB1) = 0;
    HWREG(ui32Base + CAN_O_IF1ARB2) = 0;

    //
    // Initiate programming the message object
    //
    HWREG(ui32Base + CAN_O_IF1CRQ) = ui32ObjID & CAN_IF1CRQ_MNUM_M;
}

void CANMessageGet	(	uint32_t	ui32Base,
		uint32_t	ui32ObjID,
		tCANMsgObject *	psMsgObject,
		bool	bClrPendingInt
	)

Reads a CAN message from one of the message object buffers.

Parameters

ui32Base	is the base address of the CAN controller.
ui32ObjID	is the object number to read (1-32).
psMsgObject	points to a structure containing message object fields.
bClrPendingInt	indicates whether an associated interrupt should be cleared.

This function is used to read the contents of one of the 32 message objects in the CAN controller and return it to the caller. The data returned is stored in the fields of the caller-supplied structure pointed to by psMsgObject. The data consists of all of the parts of a CAN message, plus some control and status information.

Normally, this function is used to read a message object that has received and stored a CAN message with a certain identifier. However, this function could also be used to read the contents of a message object in order to load the fields of the structure in case only part of the structure must be changed from a previous setting.

When using CANMessageGet(), all of the same fields of the structure are populated in the same way as when the CANMessageSet() function is used, with the following exceptions:

psMsgObject->ui32Flags:

• MSG_OBJ_NEW_DATA indicates if this data is new since the last time it was read
• MSG_OBJ_DATA_LOST indicates that at least one message was received on this message object and not read by the host before being overwritten.

Returns

None.

Definition at line 1838 of file can.c.

References _CANDataRegRead(), ASSERT, CAN_IF1ARB2_DIR, CAN_IF1ARB2_ID_M, CAN_IF1ARB2_XTD, CAN_IF1CMSK_ARB, CAN_IF1CMSK_CLRINTPND, CAN_IF1CMSK_CONTROL, CAN_IF1CMSK_DATAA, CAN_IF1CMSK_DATAB, CAN_IF1CMSK_MASK, CAN_IF1CMSK_NEWDAT, CAN_IF1CRQ_BUSY, CAN_IF1CRQ_MNUM_M, CAN_IF1MCTL_DLC_M, CAN_IF1MCTL_MSGLST, CAN_IF1MCTL_NEWDAT, CAN_IF1MCTL_RXIE, CAN_IF1MCTL_TXIE, CAN_IF1MCTL_TXRQST, CAN_IF1MCTL_UMASK, CAN_IF1MSK2_IDMSK_M, CAN_IF1MSK2_MDIR, CAN_IF1MSK2_MXTD, CAN_O_IF2ARB1, CAN_O_IF2ARB2, CAN_O_IF2CMSK, CAN_O_IF2CRQ, CAN_O_IF2DA1, CAN_O_IF2MCTL, CAN_O_IF2MSK1, CAN_O_IF2MSK2, HWREG, MSG_OBJ_DATA_LOST, MSG_OBJ_EXTENDED_ID, MSG_OBJ_NEW_DATA, MSG_OBJ_NO_FLAGS, MSG_OBJ_REMOTE_FRAME, MSG_OBJ_RX_INT_ENABLE, MSG_OBJ_TX_INT_ENABLE, MSG_OBJ_USE_DIR_FILTER, MSG_OBJ_USE_EXT_FILTER, MSG_OBJ_USE_ID_FILTER, tCANMsgObject::pui8MsgData, tCANMsgObject::ui32Flags, tCANMsgObject::ui32MsgID, tCANMsgObject::ui32MsgIDMask, and tCANMsgObject::ui32MsgLen.

{
    uint16_t ui16CmdMaskReg;
    uint16_t ui16MaskReg0, ui16MaskReg1;
    uint16_t ui16ArbReg0, ui16ArbReg1;
    uint16_t ui16MsgCtrl;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));
    ASSERT((ui32ObjID <= 32) && (ui32ObjID != 0));

    //
    // This is always a read to the Message object as this call is setting a
    // message object.
    //
    ui16CmdMaskReg = (CAN_IF1CMSK_DATAA | CAN_IF1CMSK_DATAB |
                      CAN_IF1CMSK_CONTROL | CAN_IF1CMSK_MASK |
                      CAN_IF1CMSK_ARB);

    //
    // Clear a pending interrupt and new data in a message object.
    //
    if(bClrPendingInt)
    {
        ui16CmdMaskReg |= CAN_IF1CMSK_CLRINTPND;
    }

    //
    // Set up the request for data from the message object.
    //
    HWREG(ui32Base + CAN_O_IF2CMSK) = ui16CmdMaskReg;

    //
    // Transfer the message object to the message object specified by
    // ui32ObjID.
    //
    HWREG(ui32Base + CAN_O_IF2CRQ) = ui32ObjID & CAN_IF1CRQ_MNUM_M;

    //
    // Wait for busy bit to clear
    //
    while(HWREG(ui32Base + CAN_O_IF2CRQ) & CAN_IF1CRQ_BUSY)
    {
    }

    //
    // Read out the IF Registers.
    //
    ui16MaskReg0 = HWREG(ui32Base + CAN_O_IF2MSK1);
    ui16MaskReg1 = HWREG(ui32Base + CAN_O_IF2MSK2);
    ui16ArbReg0 = HWREG(ui32Base + CAN_O_IF2ARB1);
    ui16ArbReg1 = HWREG(ui32Base + CAN_O_IF2ARB2);
    ui16MsgCtrl = HWREG(ui32Base + CAN_O_IF2MCTL);

    psMsgObject->ui32Flags = MSG_OBJ_NO_FLAGS;

    //
    // Determine if this is a remote frame by checking the TXRQST and DIR bits.
    //
    if((!(ui16MsgCtrl & CAN_IF1MCTL_TXRQST) &&
        (ui16ArbReg1 & CAN_IF1ARB2_DIR)) ||
       ((ui16MsgCtrl & CAN_IF1MCTL_TXRQST) &&
        (!(ui16ArbReg1 & CAN_IF1ARB2_DIR))))
    {
        psMsgObject->ui32Flags |= MSG_OBJ_REMOTE_FRAME;
    }

    //
    // Get the identifier out of the register, the format depends on size of
    // the mask.
    //
    if(ui16ArbReg1 & CAN_IF1ARB2_XTD)
    {
        //
        // Set the 29 bit version of the Identifier for this message object.
        //
        psMsgObject->ui32MsgID = (((ui16ArbReg1 & CAN_IF1ARB2_ID_M) << 16) |
                                  ui16ArbReg0);

        psMsgObject->ui32Flags |= MSG_OBJ_EXTENDED_ID;
    }
    else
    {
        //
        // The Identifier is an 11 bit value.
        //
        psMsgObject->ui32MsgID = (ui16ArbReg1 & CAN_IF1ARB2_ID_M) >> 2;
    }

    //
    // Indicate that we lost some data.
    //
    if(ui16MsgCtrl & CAN_IF1MCTL_MSGLST)
    {
        psMsgObject->ui32Flags |= MSG_OBJ_DATA_LOST;
    }

    //
    // Set the flag to indicate if ID masking was used.
    //
    if(ui16MsgCtrl & CAN_IF1MCTL_UMASK)
    {
        if(ui16ArbReg1 & CAN_IF1ARB2_XTD)
        {
            //
            // The Identifier Mask is assumed to also be a 29 bit value.
            //
            psMsgObject->ui32MsgIDMask =
                ((ui16MaskReg1 & CAN_IF1MSK2_IDMSK_M) << 16) | ui16MaskReg0;

            //
            // If this is a fully specified Mask and a remote frame then don't
            // set the MSG_OBJ_USE_ID_FILTER because the ID was not really
            // filtered.
            //
            if((psMsgObject->ui32MsgIDMask != 0x1fffffff) ||
               ((psMsgObject->ui32Flags & MSG_OBJ_REMOTE_FRAME) == 0))
            {
                psMsgObject->ui32Flags |= MSG_OBJ_USE_ID_FILTER;
            }
        }
        else
        {
            //
            // The Identifier Mask is assumed to also be an 11 bit value.
            //
            psMsgObject->ui32MsgIDMask =
                (ui16MaskReg1 & CAN_IF1MSK2_IDMSK_M) >> 2;

            //
            // If this is a fully specified Mask and a remote frame then don't
            // set the MSG_OBJ_USE_ID_FILTER because the ID was not really
            // filtered.
            //
            if((psMsgObject->ui32MsgIDMask != 0x7ff) ||
               ((psMsgObject->ui32Flags & MSG_OBJ_REMOTE_FRAME) == 0))
            {
                psMsgObject->ui32Flags |= MSG_OBJ_USE_ID_FILTER;
            }
        }

        //
        // Indicate if the extended bit was used in filtering.
        //
        if(ui16MaskReg1 & CAN_IF1MSK2_MXTD)
        {
            psMsgObject->ui32Flags |= MSG_OBJ_USE_EXT_FILTER;
        }

        //
        // Indicate if direction filtering was enabled.
        //
        if(ui16MaskReg1 & CAN_IF1MSK2_MDIR)
        {
            psMsgObject->ui32Flags |= MSG_OBJ_USE_DIR_FILTER;
        }
    }

    //
    // Set the interrupt flags.
    //
    if(ui16MsgCtrl & CAN_IF1MCTL_TXIE)
    {
        psMsgObject->ui32Flags |= MSG_OBJ_TX_INT_ENABLE;
    }
    if(ui16MsgCtrl & CAN_IF1MCTL_RXIE)
    {
        psMsgObject->ui32Flags |= MSG_OBJ_RX_INT_ENABLE;
    }

    //
    // See if there is new data available.
    //
    if(ui16MsgCtrl & CAN_IF1MCTL_NEWDAT)
    {
        //
        // Get the amount of data needed to be read.
        //
        psMsgObject->ui32MsgLen = (ui16MsgCtrl & CAN_IF1MCTL_DLC_M);

        //
        // Don't read any data for a remote frame, there is nothing valid in
        // that buffer anyway.
        //
        if((psMsgObject->ui32Flags & MSG_OBJ_REMOTE_FRAME) == 0)
        {
            //
            // Read out the data from the CAN registers.
            //
            _CANDataRegRead(psMsgObject->pui8MsgData,
                            (uint32_t *)(ui32Base + CAN_O_IF2DA1),
                            psMsgObject->ui32MsgLen);
        }

        //
        // Now clear out the new data flag.
        //
        HWREG(ui32Base + CAN_O_IF2CMSK) = CAN_IF1CMSK_NEWDAT;

        //
        // Transfer the message object to the message object specified by
        // ui32ObjID.
        //
        HWREG(ui32Base + CAN_O_IF2CRQ) = ui32ObjID & CAN_IF1CRQ_MNUM_M;

        //
        // Wait for busy bit to clear
        //
        while(HWREG(ui32Base + CAN_O_IF2CRQ) & CAN_IF1CRQ_BUSY)
        {
        }

        //
        // Indicate that there is new data in this message.
        //
        psMsgObject->ui32Flags |= MSG_OBJ_NEW_DATA;
    }
    else
    {
        //
        // Along with the MSG_OBJ_NEW_DATA not being set the amount of data
        // needs to be set to zero if none was available.
        //
        psMsgObject->ui32MsgLen = 0;
    }
}

Here is the call graph for this function:

void CANMessageSet	(	uint32_t	ui32Base,
		uint32_t	ui32ObjID,
		tCANMsgObject *	psMsgObject,
		tMsgObjType	eMsgType
	)

Configures a message object in the CAN controller.

Parameters

ui32Base	is the base address of the CAN controller.
ui32ObjID	is the object number to configure (1-32).
psMsgObject	is a pointer to a structure containing message object settings.
eMsgType	indicates the type of message for this object.

This function is used to configure any one of the 32 message objects in the CAN controller. A message object can be configured to be any type of CAN message object as well as to use automatic transmission and reception. This call also allows the message object to be configured to generate interrupts on completion of message receipt or transmission. The message object can also be configured with a filter/mask so that actions are only taken when a message that meets certain parameters is seen on the CAN bus.

The eMsgType parameter must be one of the following values:

• MSG_OBJ_TYPE_TX - CAN transmit message object.
• MSG_OBJ_TYPE_TX_REMOTE - CAN transmit remote request message object.
• MSG_OBJ_TYPE_RX - CAN receive message object.
• MSG_OBJ_TYPE_RX_REMOTE - CAN receive remote request message object.
• MSG_OBJ_TYPE_RXTX_REMOTE - CAN remote frame receive remote, then transmit message object.

The message object pointed to by psMsgObject must be populated by the caller, as follows:

• ui32MsgID - contains the message ID, either 11 or 29 bits.
• ui32MsgIDMask - mask of bits from ui32MsgID that must match if identifier filtering is enabled.
• ui32Flags
  • Set MSG_OBJ_TX_INT_ENABLE flag to enable interrupt on transmission.
  • Set MSG_OBJ_RX_INT_ENABLE flag to enable interrupt on receipt.
  • Set MSG_OBJ_USE_ID_FILTER flag to enable filtering based on the identifier mask specified by ui32MsgIDMask.
• ui32MsgLen - the number of bytes in the message data. This parameter must be non-zero even for a remote frame; it must match the expected bytes of data in the responding data frame.
• pui8MsgData - points to a buffer containing up to 8 bytes of data for a data frame.

Example: To send a data frame or remote frame (in response to a remote request), take the following steps:

1. Set eMsgType to MSG_OBJ_TYPE_TX.
2. Set psMsgObject->ui32MsgID to the message ID.
3. Set psMsgObject->ui32Flags. Make sure to set MSG_OBJ_TX_INT_ENABLE to allow an interrupt to be generated when the message is sent.
4. Set psMsgObject->ui32MsgLen to the number of bytes in the data frame.
5. Set psMsgObject->pui8MsgData to point to an array containing the bytes to send in the message.
6. Call this function with ui32ObjID set to one of the 32 object buffers.

Example: To receive a specific data frame, take the following steps:

1. Set eMsgObjType to MSG_OBJ_TYPE_RX.
2. Set psMsgObject->ui32MsgID to the full message ID, or a partial mask to use partial ID matching.
3. Set psMsgObject->ui32MsgIDMask bits that are used for masking during comparison.
4. Set psMsgObject->ui32Flags as follows:
   • Set MSG_OBJ_RX_INT_ENABLE flag to be interrupted when the data frame is received.
   • Set MSG_OBJ_USE_ID_FILTER flag to enable identifier-based filtering.
5. Set psMsgObject->ui32MsgLen to the number of bytes in the expected data frame.
6. The buffer pointed to by psMsgObject->pui8MsgData is not used by this call as no data is present at the time of the call.
7. Call this function with ui32ObjID set to one of the 32 object buffers.

If you specify a message object buffer that already contains a message definition, it is overwritten.

Returns

None.

Definition at line 1477 of file can.c.

References _CANDataRegWrite(), ASSERT, CAN_IF1ARB1_ID_M, CAN_IF1ARB2_DIR, CAN_IF1ARB2_ID_M, CAN_IF1ARB2_MSGVAL, CAN_IF1ARB2_XTD, CAN_IF1CMSK_ARB, CAN_IF1CMSK_CONTROL, CAN_IF1CMSK_DATAA, CAN_IF1CMSK_DATAB, CAN_IF1CMSK_MASK, CAN_IF1CMSK_WRNRD, CAN_IF1CRQ_BUSY, CAN_IF1CRQ_MNUM_M, CAN_IF1MCTL_DLC_M, CAN_IF1MCTL_EOB, CAN_IF1MCTL_RMTEN, CAN_IF1MCTL_RXIE, CAN_IF1MCTL_TXIE, CAN_IF1MCTL_TXRQST, CAN_IF1MCTL_UMASK, CAN_IF1MSK1_IDMSK_M, CAN_IF1MSK2_IDMSK_M, CAN_IF1MSK2_MDIR, CAN_IF1MSK2_MXTD, CAN_MAX_11BIT_MSG_ID, CAN_O_IF1ARB1, CAN_O_IF1ARB2, CAN_O_IF1CMSK, CAN_O_IF1CRQ, CAN_O_IF1DA1, CAN_O_IF1MCTL, CAN_O_IF1MSK1, CAN_O_IF1MSK2, HWREG, MSG_OBJ_EXTENDED_ID, MSG_OBJ_FIFO, MSG_OBJ_RX_INT_ENABLE, MSG_OBJ_TX_INT_ENABLE, MSG_OBJ_TYPE_RX, MSG_OBJ_TYPE_RX_REMOTE, MSG_OBJ_TYPE_RXTX_REMOTE, MSG_OBJ_TYPE_TX, MSG_OBJ_TYPE_TX_REMOTE, MSG_OBJ_USE_DIR_FILTER, MSG_OBJ_USE_EXT_FILTER, MSG_OBJ_USE_ID_FILTER, tCANMsgObject::pui8MsgData, tCANMsgObject::ui32Flags, tCANMsgObject::ui32MsgID, tCANMsgObject::ui32MsgIDMask, and tCANMsgObject::ui32MsgLen.

{
    uint16_t ui16CmdMaskReg;
    uint16_t ui16MaskReg0, ui16MaskReg1;
    uint16_t ui16ArbReg0, ui16ArbReg1;
    uint16_t ui16MsgCtrl;
    bool bTransferData;
    bool bUseExtendedID;

    bTransferData = 0;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));
    ASSERT((ui32ObjID <= 32) && (ui32ObjID != 0));
    ASSERT((eMsgType == MSG_OBJ_TYPE_TX) ||
           (eMsgType == MSG_OBJ_TYPE_TX_REMOTE) ||
           (eMsgType == MSG_OBJ_TYPE_RX) ||
           (eMsgType == MSG_OBJ_TYPE_RX_REMOTE) ||
           (eMsgType == MSG_OBJ_TYPE_TX_REMOTE) ||
           (eMsgType == MSG_OBJ_TYPE_RXTX_REMOTE));

    //
    // Wait for busy bit to clear
    //
    while(HWREG(ui32Base + CAN_O_IF1CRQ) & CAN_IF1CRQ_BUSY)
    {
    }

    //
    // See if we need to use an extended identifier or not.
    //
    if((psMsgObject->ui32MsgID > CAN_MAX_11BIT_MSG_ID) ||
       (psMsgObject->ui32Flags & MSG_OBJ_EXTENDED_ID))
    {
        bUseExtendedID = 1;
    }
    else
    {
        bUseExtendedID = 0;
    }

    //
    // This is always a write to the Message object as this call is setting a
    // message object.  This call always sets all size bits so it sets
    // both data bits.  The call uses the CONTROL register to set control
    // bits so this bit needs to be set as well.
    //
    ui16CmdMaskReg = (CAN_IF1CMSK_WRNRD | CAN_IF1CMSK_DATAA |
                      CAN_IF1CMSK_DATAB | CAN_IF1CMSK_CONTROL);

    //
    // Initialize the values to a known state before filling them in based on
    // the type of message object that is being configured.
    //
    ui16ArbReg0 = 0;
    ui16ArbReg1 = 0;
    ui16MsgCtrl = 0;
    ui16MaskReg0 = 0;
    ui16MaskReg1 = 0;

    switch(eMsgType)
    {
        //
        // Transmit message object.
        //
        case MSG_OBJ_TYPE_TX:
        {
            //
            // Set the TXRQST bit and the reset the rest of the register.
            //
            ui16MsgCtrl |= CAN_IF1MCTL_TXRQST;
            ui16ArbReg1 = CAN_IF1ARB2_DIR;
            bTransferData = 1;
            break;
        }

        //
        // Transmit remote request message object
        //
        case MSG_OBJ_TYPE_TX_REMOTE:
        {
            //
            // Set the TXRQST bit and the reset the rest of the register.
            //
            ui16MsgCtrl |= CAN_IF1MCTL_TXRQST;
            ui16ArbReg1 = 0;
            break;
        }

        //
        // Receive message object.
        //
        case MSG_OBJ_TYPE_RX:
        {
            //
            // This clears the DIR bit along with everything else.  The TXRQST
            // bit was cleared by defaulting ui16MsgCtrl to 0.
            //
            ui16ArbReg1 = 0;
            break;
        }

        //
        // Receive remote request message object.
        //
        case MSG_OBJ_TYPE_RX_REMOTE:
        {
            //
            // The DIR bit is set to one for remote receivers.  The TXRQST bit
            // was cleared by defaulting ui16MsgCtrl to 0.
            //
            ui16ArbReg1 = CAN_IF1ARB2_DIR;

            //
            // Set this object so that it only indicates that a remote frame
            // was received and allow for software to handle it by sending back
            // a data frame.
            //
            ui16MsgCtrl = CAN_IF1MCTL_UMASK;

            //
            // Use the full Identifier by default.
            //
            ui16MaskReg0 = 0xffff;
            ui16MaskReg1 = 0x1fff;

            //
            // Make sure to send the mask to the message object.
            //
            ui16CmdMaskReg |= CAN_IF1CMSK_MASK;
            break;
        }

        //
        // Remote frame receive remote, with auto-transmit message object.
        //
        case MSG_OBJ_TYPE_RXTX_REMOTE:
        {
            //
            // Oddly the DIR bit is set to one for remote receivers.
            //
            ui16ArbReg1 = CAN_IF1ARB2_DIR;

            //
            // Set this object to auto answer if a matching identifier is seen.
            //
            ui16MsgCtrl = CAN_IF1MCTL_RMTEN | CAN_IF1MCTL_UMASK;

            //
            // The data to be returned needs to be filled in.
            //
            bTransferData = 1;
            break;
        }

        //
        // This case never happens due to the ASSERT statement at the
        // beginning of this function.
        //
        default:
        {
            return;
        }
    }

    //
    // Configure the Mask Registers.
    //
    if(psMsgObject->ui32Flags & MSG_OBJ_USE_ID_FILTER)
    {
        if(bUseExtendedID)
        {
            //
            // Set the 29 bits of Identifier mask that were requested.
            //
            ui16MaskReg0 = psMsgObject->ui32MsgIDMask & CAN_IF1MSK1_IDMSK_M;
            ui16MaskReg1 = ((psMsgObject->ui32MsgIDMask >> 16) &
                            CAN_IF1MSK2_IDMSK_M);
        }
        else
        {
            //
            // Lower 16 bit are unused so set them to zero.
            //
            ui16MaskReg0 = 0;

            //
            // Put the 11 bit Mask Identifier into the upper bits of the field
            // in the register.
            //
            ui16MaskReg1 = ((psMsgObject->ui32MsgIDMask << 2) &
                            CAN_IF1MSK2_IDMSK_M);
        }
    }

    //
    // If the caller wants to filter on the extended ID bit then set it.
    //
    if((psMsgObject->ui32Flags & MSG_OBJ_USE_EXT_FILTER) ==
       MSG_OBJ_USE_EXT_FILTER)
    {
        ui16MaskReg1 |= CAN_IF1MSK2_MXTD;
    }

    //
    // The caller wants to filter on the message direction field.
    //
    if((psMsgObject->ui32Flags & MSG_OBJ_USE_DIR_FILTER) ==
       MSG_OBJ_USE_DIR_FILTER)
    {
        ui16MaskReg1 |= CAN_IF1MSK2_MDIR;
    }

    if(psMsgObject->ui32Flags &
       (MSG_OBJ_USE_ID_FILTER | MSG_OBJ_USE_DIR_FILTER |
        MSG_OBJ_USE_EXT_FILTER))
    {
        //
        // Set the UMASK bit to enable using the mask register.
        //
        ui16MsgCtrl |= CAN_IF1MCTL_UMASK;

        //
        // Set the MASK bit so that this gets transferred to the Message
        // Object.
        //
        ui16CmdMaskReg |= CAN_IF1CMSK_MASK;
    }

    //
    // Set the Arb bit so that this gets transferred to the Message object.
    //
    ui16CmdMaskReg |= CAN_IF1CMSK_ARB;

    //
    // Configure the Arbitration registers.
    //
    if(bUseExtendedID)
    {
        //
        // Set the 29 bit version of the Identifier for this message object.
        //
        ui16ArbReg0 |= psMsgObject->ui32MsgID & CAN_IF1ARB1_ID_M;
        ui16ArbReg1 |= (psMsgObject->ui32MsgID >> 16) & CAN_IF1ARB2_ID_M;

        //
        // Mark the message as valid and set the extended ID bit.
        //
        ui16ArbReg1 |= CAN_IF1ARB2_MSGVAL | CAN_IF1ARB2_XTD;
    }
    else
    {
        //
        // Set the 11 bit version of the Identifier for this message object.
        // The lower 18 bits are set to zero.
        //
        ui16ArbReg1 |= (psMsgObject->ui32MsgID << 2) & CAN_IF1ARB2_ID_M;

        //
        // Mark the message as valid.
        //
        ui16ArbReg1 |= CAN_IF1ARB2_MSGVAL;
    }

    //
    // Set the data length since this is set for all transfers.  This is also a
    // single transfer and not a FIFO transfer so set EOB bit.
    //
    ui16MsgCtrl |= (psMsgObject->ui32MsgLen & CAN_IF1MCTL_DLC_M);

    //
    // Mark this as the last entry if this is not the last entry in a FIFO.
    //
    if((psMsgObject->ui32Flags & MSG_OBJ_FIFO) == 0)
    {
        ui16MsgCtrl |= CAN_IF1MCTL_EOB;
    }

    //
    // Enable transmit interrupts if they should be enabled.
    //
    if(psMsgObject->ui32Flags & MSG_OBJ_TX_INT_ENABLE)
    {
        ui16MsgCtrl |= CAN_IF1MCTL_TXIE;
    }

    //
    // Enable receive interrupts if they should be enabled.
    //
    if(psMsgObject->ui32Flags & MSG_OBJ_RX_INT_ENABLE)
    {
        ui16MsgCtrl |= CAN_IF1MCTL_RXIE;
    }

    //
    // Write the data out to the CAN Data registers if needed.
    //
    if(bTransferData)
    {
        _CANDataRegWrite(psMsgObject->pui8MsgData,
                         (uint32_t *)(ui32Base + CAN_O_IF1DA1),
                         psMsgObject->ui32MsgLen);
    }

    //
    // Write out the registers to program the message object.
    //
    HWREG(ui32Base + CAN_O_IF1CMSK) = ui16CmdMaskReg;
    HWREG(ui32Base + CAN_O_IF1MSK1) = ui16MaskReg0;
    HWREG(ui32Base + CAN_O_IF1MSK2) = ui16MaskReg1;
    HWREG(ui32Base + CAN_O_IF1ARB1) = ui16ArbReg0;
    HWREG(ui32Base + CAN_O_IF1ARB2) = ui16ArbReg1;
    HWREG(ui32Base + CAN_O_IF1MCTL) = ui16MsgCtrl;

    //
    // Transfer the message object to the message object specified by
    // ui32ObjID.
    //
    HWREG(ui32Base + CAN_O_IF1CRQ) = ui32ObjID & CAN_IF1CRQ_MNUM_M;
}

Here is the call graph for this function:

bool CANRetryGet

(

uint32_t

ui32Base

)

Returns the current setting for automatic retransmission.

Parameters

ui32Base

is the base address of the CAN controller.

This function reads the current setting for automatic retransmission in the CAN controller and returns it to the caller.

Returns

Returns true if automatic retransmission is enabled, false otherwise.

Definition at line 1193 of file can.c.

References ASSERT, CAN_CTL_DAR, CAN_O_CTL, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    //
    // Read the disable automatic retry setting from the CAN controller.
    //
    if(HWREG(ui32Base + CAN_O_CTL) & CAN_CTL_DAR)
    {
        //
        // Automatic data retransmission is not enabled.
        //
        return(false);
    }

    //
    // Automatic data retransmission is enabled.
    //
    return(true);
}

void CANRetrySet	(	uint32_t	ui32Base,
		bool	bAutoRetry
	)

Sets the CAN controller automatic retransmission behavior.

Parameters

ui32Base	is the base address of the CAN controller.
bAutoRetry	enables automatic retransmission.

This function enables or disables automatic retransmission of messages with detected errors. If bAutoRetry is true, then automatic retransmission is enabled, otherwise it is disabled.

Returns

None.

Definition at line 1144 of file can.c.

References ASSERT, CAN_CTL_DAR, CAN_O_CTL, and HWREG.

{
    uint32_t ui32CtlReg;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    ui32CtlReg = HWREG(ui32Base + CAN_O_CTL);

    //
    // Conditionally set the DAR bit to enable/disable auto-retry.
    //
    if(bAutoRetry)
    {
        //
        // Clearing the DAR bit tells the controller to not disable the
        // auto-retry of messages which were not transmitted or received
        // correctly.
        //
        ui32CtlReg &= ~CAN_CTL_DAR;
    }
    else
    {
        //
        // Setting the DAR bit tells the controller to disable the auto-retry
        // of messages which were not transmitted or received correctly.
        //
        ui32CtlReg |= CAN_CTL_DAR;
    }

    HWREG(ui32Base + CAN_O_CTL) = ui32CtlReg;
}

uint32_t CANStatusGet	(	uint32_t	ui32Base,
		tCANStsReg	eStatusReg
	)

Reads one of the controller status registers.

Parameters

ui32Base	is the base address of the CAN controller.
eStatusReg	is the status register to read.

This function reads a status register of the CAN controller and returns it to the caller. The different status registers are:

• CAN_STS_CONTROL - the main controller status
• CAN_STS_TXREQUEST - bit mask of objects pending transmission
• CAN_STS_NEWDAT - bit mask of objects with new data
• CAN_STS_MSGVAL - bit mask of objects with valid configuration

When reading the main controller status register, a pending status interrupt is cleared. This parameter is used in the interrupt handler for the CAN controller if the cause is a status interrupt. The controller status register fields are as follows:

• CAN_STATUS_BUS_OFF - controller is in bus-off condition
• CAN_STATUS_EWARN - an error counter has reached a limit of at least 96
• CAN_STATUS_EPASS - CAN controller is in the error passive state
• CAN_STATUS_RXOK - a message was received successfully (independent of any message filtering).
• CAN_STATUS_TXOK - a message was successfully transmitted
• CAN_STATUS_LEC_MSK - mask of last error code bits (3 bits)
• CAN_STATUS_LEC_NONE - no error
• CAN_STATUS_LEC_STUFF - stuffing error detected
• CAN_STATUS_LEC_FORM - a format error occurred in the fixed format part of a message
• CAN_STATUS_LEC_ACK - a transmitted message was not acknowledged
• CAN_STATUS_LEC_BIT1 - dominant level detected when trying to send in recessive mode
• CAN_STATUS_LEC_BIT0 - recessive level detected when trying to send in dominant mode
• CAN_STATUS_LEC_CRC - CRC error in received message

The remaining status registers consist of 32-bit-wide bit maps to the message objects. They can be used to quickly obtain information about the status of all the message objects without needing to query each one. They contain the following information:

• CAN_STS_TXREQUEST - if a message object's TXRQST bit is set, a transmission is pending on that object. The application can use this information to determine which objects are still waiting to send a message.
• CAN_STS_NEWDAT - if a message object's NEWDAT bit is set, a new message has been received in that object, and has not yet been picked up by the host application
• CAN_STS_MSGVAL - if a message object's MSGVAL bit is set, the object has a valid configuration programmed. The host application can use this information to determine which message objects are empty/unused.

Returns

Returns the value of the status register.

Definition at line 1276 of file can.c.

References ASSERT, CAN_O_MSG1VAL, CAN_O_MSG2VAL, CAN_O_NWDA1, CAN_O_NWDA2, CAN_O_STS, CAN_O_TXRQ1, CAN_O_TXRQ2, CAN_STS_CONTROL, CAN_STS_LEC_M, CAN_STS_MSGVAL, CAN_STS_NEWDAT, CAN_STS_RXOK, CAN_STS_TXOK, CAN_STS_TXREQUEST, and HWREG.

{
    uint32_t ui32Status;

    //
    // Check the arguments.
    //
    ASSERT(_CANBaseValid(ui32Base));

    switch(eStatusReg)
    {
        //
        // Just return the global CAN status register since that is what was
        // requested.
        //
        case CAN_STS_CONTROL:
        {
            ui32Status = HWREG(ui32Base + CAN_O_STS);
            HWREG(ui32Base + CAN_O_STS) = ~(CAN_STS_RXOK | CAN_STS_TXOK |
                                            CAN_STS_LEC_M);
            break;
        }

        //
        // Combine the Transmit status bits into one 32bit value.
        //
        case CAN_STS_TXREQUEST:
        {
            ui32Status = HWREG(ui32Base + CAN_O_TXRQ1);
            ui32Status |= HWREG(ui32Base + CAN_O_TXRQ2) << 16;
            break;
        }

        //
        // Combine the New Data status bits into one 32bit value.
        //
        case CAN_STS_NEWDAT:
        {
            ui32Status = HWREG(ui32Base + CAN_O_NWDA1);
            ui32Status |= HWREG(ui32Base + CAN_O_NWDA2) << 16;
            break;
        }

        //
        // Combine the Message valid status bits into one 32bit value.
        //
        case CAN_STS_MSGVAL:
        {
            ui32Status = HWREG(ui32Base + CAN_O_MSG1VAL);
            ui32Status |= HWREG(ui32Base + CAN_O_MSG2VAL) << 16;
            break;
        }

        //
        // Unknown CAN status requested so return 0.
        //
        default:
        {
            ui32Status = 0;
            break;
        }
    }
    return(ui32Status);
}

Variable Documentation

const uint16_t g_ui16CANBitValues[]

static

Initial value:

=
{
    (((( 2  - 1) <<  8 ) &    0x00000F00 ) |   ((( 1  - 1) <<  12 ) &    0x00007000 ) |   ((( 1  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 3  - 1) <<  8 ) &    0x00000F00 ) |   ((( 1  - 1) <<  12 ) &    0x00007000 ) |   ((( 1  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 3  - 1) <<  8 ) &    0x00000F00 ) |   ((( 2  - 1) <<  12 ) &    0x00007000 ) |   ((( 2  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 4  - 1) <<  8 ) &    0x00000F00 ) |   ((( 2  - 1) <<  12 ) &    0x00007000 ) |   ((( 2  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 4  - 1) <<  8 ) &    0x00000F00 ) |   ((( 3  - 1) <<  12 ) &    0x00007000 ) |   ((( 3  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 5  - 1) <<  8 ) &    0x00000F00 ) |   ((( 3  - 1) <<  12 ) &    0x00007000 ) |   ((( 3  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 5  - 1) <<  8 ) &    0x00000F00 ) |   ((( 4  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 6  - 1) <<  8 ) &    0x00000F00 ) |   ((( 4  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 6  - 1) <<  8 ) &    0x00000F00 ) |   ((( 5  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 7  - 1) <<  8 ) &    0x00000F00 ) |   ((( 5  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 7  - 1) <<  8 ) &    0x00000F00 ) |   ((( 6  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 8  - 1) <<  8 ) &    0x00000F00 ) |   ((( 6  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 8  - 1) <<  8 ) &    0x00000F00 ) |   ((( 7  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 9  - 1) <<  8 ) &    0x00000F00 ) |   ((( 7  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 9  - 1) <<  8 ) &    0x00000F00 ) |   ((( 8  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 )),     
    (((( 10  - 1) <<  8 ) &    0x00000F00 ) |   ((( 8  - 1) <<  12 ) &    0x00007000 ) |   ((( 4  - 1) <<  6 ) &    0x000000C0 ))     
}

Definition at line 115 of file can.c.

Referenced by CANBitRateSet().