can Class Reference

#include <canpp.hpp>

Inheritance diagram for can:

Collaboration diagram for can:

Public Member Functions
	can ()
	can (memory_address_t can_base, uint32_t can_interrupt, bool can_sender, uint32_t msg_length)
virtual void	start (void)
virtual void	stop (void)
virtual uint32_t	ack (void)
void	pack (uint8_t *dest, uint32_t data, uint8_t offset=0)
void	transmit (uint8_t *data, uint32_t length, uint32_t id=1)
void	get (uint8_t *data)
void	error_tx (void)
Public Member Functions inherited from interruptable
	interruptable ()

Public Attributes
semaphore	recv_sem

Private Member Functions
void	set_timing (void)
void	init (void)
uint32_t	count_message (void)

Private Attributes
memory_address_t	base
uint32_t	interrupt
bool	sender
tCANMsgObject	sCANMessage
uint32_t	errors_tx
uint32_t	errors_rx
uint32_t	messages_sent
uint32_t	messages_received

Detailed Description

Definition at line 21 of file canpp.hpp.

Constructor & Destructor Documentation

can::can

(

)

Definition at line 39 of file canpp.cpp.

{}

can::can	(	memory_address_t	can_base,
		uint32_t	can_interrupt,
		bool	can_sender,
		uint32_t	msg_length
	)

Initialize a can node.

Definition at line 41 of file canpp.cpp.

References base, CAN_MSG_OBJ, can_sender, init(), interrupt, sCANMessage, and sender.

                                               {

    sender = can_sender;
    base = can_base;
    interrupt = can_interrupt;

    init();

    switch(can_sender) {
    case true:
        sCANMessage.ui32MsgID = 1;
        sCANMessage.ui32MsgIDMask = 0;
        sCANMessage.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
        sCANMessage.ui32MsgLen = msg_length;
        break;
    case false:
        // Initialize a message object to be used for receiving CAN messages with
        // any CAN ID.  In order to receive any CAN ID, the ID and mask must both
        // be set to 0, and the ID filter enabled.
        sCANMessage.ui32MsgID = 0;
        sCANMessage.ui32MsgIDMask = 0;
        sCANMessage.ui32Flags = MSG_OBJ_RX_INT_ENABLE | MSG_OBJ_USE_ID_FILTER;
        sCANMessage.ui32MsgLen = msg_length;
        // Load the message object into the CAN peripheral.  Once
        // loaded the CAN will receive any message on the bus, and an
        // interrupt will occur.  Use message object 1 for receiving
        // messages (this is distinct from the CAN ID).
        CANMessageSet(base, CAN_MSG_OBJ, &sCANMessage, MSG_OBJ_TYPE_RX);
        break;
    default: while(1) {}
    }
}

Here is the call graph for this function:

Member Function Documentation

uint32_t can::ack ( void  )

virtual

Acknowledge CAN interrupt

Implements interruptable.

Definition at line 146 of file canpp.cpp.

References base, and count_message().

Referenced by CAN0_Handler().

                  {

    /* Read the CAN interrupt status to find the cause of the interrupt */
    uint32_t ui32Status = CANIntStatus(base, CAN_INT_STS_CAUSE);
    CANIntClear(base, ui32Status);
    count_message();
    return ui32Status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_t can::count_message ( void  )

private

Add a message to the global count.

Definition at line 135 of file canpp.cpp.

References messages_received, messages_sent, and sender.

Referenced by ack().

                            {

    uint32_t ret;
    switch(sender) {
    case true:  ret = ++messages_sent; break;
    case false: ret = ++messages_received; break;
    default: while(1) {}
    }
    return ret;
}

Here is the caller graph for this function:

void can::error_tx

(

void

)

Register a tx error.

Definition at line 97 of file canpp.cpp.

References errors_tx.

Referenced by CAN0_Handler().

                   {

    ++errors_tx;
}

Here is the caller graph for this function:

void can::get

(

uint8_t *

data

)

Set mailbox for received can message data.

Definition at line 102 of file canpp.cpp.

References base, errors_rx, and sCANMessage.

Referenced by can_handler().

                           {

    sCANMessage.pui8MsgData = data;
    CANMessageGet(base, 1, &sCANMessage, 0);
    if(sCANMessage.ui32Flags & MSG_OBJ_DATA_LOST) {
        ++errors_rx;
    }
}

Here is the caller graph for this function:

void can::init ( void  )

private

Shared init between constructors.

Definition at line 17 of file canpp.cpp.

References base, ctlsys::enable_periph(), errors_rx, errors_tx, interrupt, messages_received, messages_sent, recv_sem, and start().

Referenced by can().

               {

    errors_rx = 0;
    errors_tx = 0;
    messages_sent = 0;
    messages_received = 0;

    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
    ctlsys::enable_periph(base);
    GPIOPinConfigure(GPIO_PB4_CAN0RX);
    GPIOPinConfigure(GPIO_PB5_CAN0TX);
    GPIOPinTypeCAN(GPIO_PORTB_BASE, GPIO_PIN_4 | GPIO_PIN_5);

    CANInit(base);

    recv_sem = semaphore();

    CANBitRateSet(base, SysCtlClockGet(), 500000);
    IntEnable(interrupt);
    start();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void can::pack	(	uint8_t *	dest,
		uint32_t	data,
		uint8_t	offset = 0
	)

Definition at line 111 of file canpp.cpp.

                                                           {

    uint8_t i;
    for(i=0; i<sizeof(data); ++i) {
        /* todo: perfect the endian-swap */
        *(dest+offset) = (uint8_t) (data & (0xFF << (i*4)));
    }
}

void can::set_timing ( void  )

private

Configure CAN for 1 Mbit operation – http://bit.ly/1CW7hUO

Definition at line 75 of file canpp.cpp.

References base.

                     {

    tCANBitClkParms psClkParms;
    psClkParms.ui32SyncPropPhase1Seg = 5; /* from 2 to 16   */
    psClkParms.ui32Phase2Seg = 2;         /* from 1 to 8    */
    psClkParms.ui32QuantumPrescaler = 1;  /* from 1 to 1023 */
    psClkParms.ui32SJW = 2;               /* from 1 to 4    */
    CANBitTimingSet(base, &psClkParms);
}

void can::start ( void  )

virtual

Start CAN transmissions.

Implements interruptable.

Definition at line 85 of file canpp.cpp.

References base.

Referenced by init().

                {

    CANIntEnable(base, CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS);
    CANEnable(base);
}

Here is the caller graph for this function:

void can::stop ( void  )

virtual

Stop CAN transmissions.

Implements interruptable.

Definition at line 91 of file canpp.cpp.

References base.

               {

    CANIntDisable(base, CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS);
    CANDisable(base);
}

void can::transmit	(	uint8_t *	data,
		uint32_t	length,
		uint32_t	id = 1
	)

Transmit a message via CAN.

note this function will cause the message to be transmtted immediately.

Definition at line 122 of file canpp.cpp.

References base, CAN_MSG_OBJ, and sCANMessage.

Referenced by can_transmitter().

                                                              {

    sCANMessage.ui32MsgID = id;
    sCANMessage.ui32MsgIDMask = 0;
    sCANMessage.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
    sCANMessage.ui32MsgLen = length;
    sCANMessage.pui8MsgData = data;

    CANMessageSet(base, CAN_MSG_OBJ, &sCANMessage, MSG_OBJ_TYPE_TX);

    /* todo: resend if errors occured */
}

Here is the caller graph for this function:

Member Data Documentation

memory_address_t can::base

private

Definition at line 23 of file canpp.hpp.

Referenced by ack(), can(), get(), init(), set_timing(), start(), stop(), and transmit().

uint32_t can::errors_rx

private

Definition at line 30 of file canpp.hpp.

Referenced by get(), and init().

uint32_t can::errors_tx

private

Definition at line 29 of file canpp.hpp.

Referenced by error_tx(), and init().

uint32_t can::interrupt

private

Definition at line 24 of file canpp.hpp.

Referenced by can(), and init().

uint32_t can::messages_received

private

Definition at line 32 of file canpp.hpp.

Referenced by count_message(), and init().

uint32_t can::messages_sent

private

Definition at line 31 of file canpp.hpp.

Referenced by count_message(), and init().

semaphore can::recv_sem

Definition at line 69 of file canpp.hpp.

Referenced by CAN0_Handler(), can_handler(), and init().

tCANMsgObject can::sCANMessage

private

Definition at line 27 of file canpp.hpp.

Referenced by can(), get(), and transmit().

bool can::sender

private

Definition at line 25 of file canpp.hpp.

Referenced by can(), and count_message().

---

The documentation for this class was generated from the following files:

• board-progs/autonomous-racer/common/canpp.hpp
• board-progs/autonomous-racer/common/canpp.cpp