CANSPI Library
  mikroC PRO for ARM Libraries > Hardware Libraries > 
  

CANSPI Library

The SPI module is available with a number of the ARM MCUs. The mikroC PRO for ARM provides a library (driver) for working with mikroElektronika's CANSPI Add-on boards (with MCP2515 or MCP2510) via SPI interface.

  Important :

Library Dependency Tree

CANSPI Library Dependency Tree

External dependencies of CANSPI Library

Stellaris

The following variables must be defined in all projects using CANSPI Library: Description : Example :
extern sfr sbit CanSpi_CS; Chip Select line. sbit CanSpi_CS at GPIO_PORTA_DATA0_bit;
extern sfr sbit CanSpi_Rst; Reset line. sbit CanSpi_Rst at GPIO_PORTA_DATA3_bit;
extern sfr sbit CanSpi_CS_Direction; Direction of the Chip Select pin. sbit CanSpi_CS_Direction at GPIO_PORTA_DIR0_bit;
extern sfr sbit CanSpi_Rst_Direction; Direction of the Reset pin. sbit CanSpi_Rst_Direction at GPIO_PORTA_DIR3_bit;

STM32

The following variables must be defined in all projects using CANSPI Library: Description : Example :
extern sfr sbit CanSpi_CS; Chip Select line. sbit CanSpi_CS at GPIOB_ODR.B0;
extern sfr sbit CanSpi_Rst; Reset line. sbit CanSpi_Rst at GPIOB_ODR.B2;

Library Routines

CANSPISetOperationMode

Prototype

void CANSPISetOperationMode(char mode, char WAIT);
Description

Sets the CANSPI module to requested mode.
Parameters
  • mode: CANSPI module operation mode. Valid values: CANSPI_OP_MODE constants. See CANSPI_OP_MODE constants.
  • WAIT: CANSPI mode switching verification request. If WAIT == 0, the call is non-blocking. The function does not verify if the CANSPI module is switched to requested mode or not. Caller must use CANSPIGetOperationMode to verify correct operation mode before performing mode specific operation. If WAIT != 0, the call is blocking – the function won’t “return” until the requested mode is set.
Returns

Nothing.
Requires

The CANSPI routines are supported only by MCUs with the SPI module.

MCU has to be properly connected to mikroElektronika's CANSPI Extra Board or similar hardware. See connection example at the bottom of this page.
Example 
// set the CANSPI module into configuration mode (wait inside CANSPISetOperationMode until this mode is set)
CANSPISetOperationMode(_CANSPI_MODE_CONFIG, 0xFF);
Notes

None.

CANSPIGetOperationMode

Prototype

char CANSPIGetOperationMode();
Description

The function returns current operation mode of the CANSPI module. Check CANSPI_OP_MODE constants or device datasheet for operation mode codes.
Parameters

None.
Returns

Current operation mode.
Requires

The CANSPI routines are supported only by MCUs with the SPI module.

MCU has to be properly connected to mikroElektronika's CANSPI Extra Board or similar hardware. See connection example at the bottom of this page.
Example 
// check whether the CANSPI module is in Normal mode and if it is do something.
if (CANSPIGetOperationMode() == _CANSPI_MODE_NORMAL) {
  ...
}
Notes

None.

CANSPIInitialize

Prototype

void CANSPIInitialize(char SJW, char BRP, char PHSEG1, char PHSEG2, char PROPSEG, char CANSPI_CONFIG_FLAGS);
Description

Initializes the CANSPI module.

Stand-Alone CAN controller in the CANSPI module is set to:

  • Disable CAN capture
  • Continue CAN operation in Idle mode
  • Do not abort pending transmissions
  • Fcan clock : 4*Tcy (Fosc)
  • Baud rate is set according to given parameters
  • CAN mode : Normal
  • Filter and mask registers IDs are set to zero
  • Filter and mask message frame type is set according to CANSPI_CONFIG_FLAGS value

SAM, SEG2PHTS, WAKFIL and DBEN bits are set according to CANSPI_CONFIG_FLAGS value.
Parameters
  • SJW as defined in MCU's datasheet (CAN Module)
  • BRP as defined in MCU's datasheet (CAN Module)
  • PHSEG1 as defined in MCU's datasheet (CAN Module)
  • PHSEG2 as defined in MCU's datasheet (CAN Module)
  • PROPSEG as defined in MCU's datasheet (CAN Module)
  • CANSPI_CONFIG_FLAGS is formed from predefined constants. See CANSPI_CONFIG_FLAGS constants.
Returns

Nothing.
Requires Global variables :
  • CanSpi_CS: Chip Select line
  • CanSpi_Rst: Reset line
  • CanSpi_CS_Direction: Direction of the Chip Select pin
  • CanSpi_Rst_Direction: Direction of the Reset pin
must be defined before using this function.

The CANSPI routines are supported only by MCUs with the SPI module.

The SPI module needs to be initialized. See the SPIx_Init and SPIx_Init_Advanced routines.

MCU has to be properly connected to mikroElektronika's CANSPI Extra Board or similar hardware. See connection example at the bottom of this page.
Example

Stellaris

// CANSPI module connections
sbit CanSpi_CS            at  GPIO_PORTA_DATA0_bit;
sbit CanSpi_Rst           at  GPIO_PORTA_DATA3_bit;

sbit CanSpi_CS_Direction  at  GPIO_PORTA_DIR0_bit;
sbit CanSpi_Rst_Direction at  GPIO_PORTA_DIR3_bit;
// End CANSPI module connections

// initialize the CANSPI module with the appropriate baud rate and message acceptance flags along with the sampling rules
char CANSPI_Init_Flags;
...  
CANSPI_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE &  // form value to be used
                      _CANSPI_CONFIG_PHSEG2_PRG_ON &  // with CANSPIInitialize
                      _CANSPI_CONFIG_XTD_MSG &
                      _CANSPI_CONFIG_DBL_BUFFER_ON &
                      _CANSPI_CONFIG_VALID_XTD_MSG;
...
SPI0_Init();                               // initialize SPI0 module
CANSPIInitialize(1,3,3,3,1,CANSPI_Init_Flags);   // initialize external CANSPI module

STM32

// CANSPI module connections
sbit CanSpi_CS            at  GPIOB_ODR.B0;
sbit CanSpi_Rst           at  GPIOB_ODR.B2;
// End CANSPI module connections

// initialize the CANSPI module with the appropriate baud rate and message acceptance flags along with the sampling rules
char CANSPI_Init_Flags;
...
Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE &             // form value to be used
                 _CANSPI_CONFIG_PHSEG2_PRG_ON &             // with CANSPIInit
                 _CANSPI_CONFIG_XTD_MSG &
                 _CANSPI_CONFIG_DBL_BUFFER_ON &
                 _CANSPI_CONFIG_VALID_XTD_MSG;
...
// Initialize SPI1 module
SPI1_Init_Advanced(_SPI_FPCLK_DIV8, _SPI_MASTER  | _SPI_8_BIT |
                   _SPI_CLK_IDLE_LOW | _SPI_FIRST_CLK_EDGE_TRANSITION |
                   _SPI_MSB_FIRST | _SPI_SS_DISABLE | _SPI_SSM_ENABLE | _SPI_SSI_1,
                   &_GPIO_MODULE_SPI1_PB345);

CANSPIInitialize(1,3,3,3,1,Can_Init_Flags);                            // initialize external CANSPI module
Notes
  • CANSPI mode NORMAL will be set on exit.

CANSPISetBaudRate

Prototype

void CANSPISetBaudRate(char SJW, char BRP, char PHSEG1, char PHSEG2, char PROPSEG, char CANSPI_CONFIG_FLAGS);
Returns

Nothing.
Description

Sets the CANSPI module baud rate. Due to complexity of the CAN protocol, you can not simply force a bps value. Instead, use this function when the CANSPI module is in Config mode.

SAM, SEG2PHTS and WAKFIL bits are set according to CANSPI_CONFIG_FLAGS value. Refer to datasheet for details.
Parameters
  • SJW as defined in MCU's datasheet (CAN Module)
  • BRP as defined in MCU's datasheet (CAN Module)
  • PHSEG1 as defined in MCU's datasheet (CAN Module)
  • PHSEG2 as defined in MCU's datasheet (CAN Module)
  • PROPSEG as defined in MCU's datasheet (CAN Module)
  • CANSPI_CONFIG_FLAGS is formed from predefined constants. See CANSPI_CONFIG_FLAGS constants.
Returns

Nothing.
Requires

The CANSPI module must be in Config mode, otherwise the function will be ignored. See CANSPISetOperationMode.

The CANSPI routines are supported only by MCUs with the SPI module.

MCU has to be properly connected to mikroElektronika's CANSPI Extra Board or similar hardware. See connection example at the bottom of this page.
Example 
// set required baud rate and sampling rules
char CANSPI_CONFIG_FLAGS;
...  
CANSPISetOperationMode(_CANSPI_MODE_CONFIG,0xFF);           // set CONFIGURATION mode (CANSPI module must be in config mode for baud rate settings)
CANSPI_CONFIG_FLAGS = _CANSPI_CONFIG_SAMPLE_THRICE &
                   _CANSPI_CONFIG_PHSEG2_PRG_ON &
                   _CANSPI_CONFIG_STD_MSG       &
                   _CANSPI_CONFIG_DBL_BUFFER_ON &
                   _CANSPI_CONFIG_VALID_XTD_MSG &
                   _CANSPI_CONFIG_LINE_FILTER_OFF;
CANSPISetBaudRate(1, 1, 3, 3, 1, CANSPI_CONFIG_FLAGS);
Notes

None.

CANSPISetMask

Prototype

void CANSPISetMask(unsigned short CANSPI_MASK, long value, unsigned short CANSPI_CONFIG_FLAGS);
Description

Configures mask for advanced filtering of messages. The parameter value is bit-adjusted to the appropriate mask registers.
Parameters
  • CANSPI_MASK: CAN module mask number. Valid values: CANSPI_MASK constants. See CANSPI_MASK constants.
  • val: mask register value. This value is bit-adjusted to appropriate buffer mask registers
  • CANSPI_CONFIG_FLAGS: selects type of message to filter. Valid values:
    • _CANSPI_CONFIG_ALL_VALID_MSG,
    • _CANSPI_CONFIG_MATCH_MSG_TYPE & _CANSPI_CONFIG_STD_MSG,
    • _CANSPI_CONFIG_MATCH_MSG_TYPE & _CANSPI_CONFIG_XTD_MSG.
    See CANSPI_CONFIG_FLAGS constants.
Returns

Nothing.
Requires

The CANSPI module must be in Config mode, otherwise the function will be ignored. See CANSPISetOperationMode.

The CANSPI routines are supported only by MCUs with the SPI module.

MCU has to be properly connected to mikroElektronika's CANSPI Extra Board or similar hardware. See connection example at the bottom of this page.
Example 
// set the appropriate filter mask and message type value
CANSPISetOperationMode(_CANSPI_MODE_CONFIG,0xFF);              // set CONFIGURATION mode (CANSPI module must be in config mode for mask settings)

// Set all B1 mask bits to 1 (all filtered bits are relevant):
// Note that -1 is just a cheaper way to write 0xFFFFFFFF.
// Complement will do the trick and fill it up with ones.
CANSPISetMask(_CANSPI_MASK_B1, -1, _CANSPI_CONFIG_MATCH_MSG_TYPE & _CANSPI_CONFIG_XTD_MSG);
Notes

None.

CANSPISetFilter

Prototype

void CANSPISetFilter(unsigned short CANSPI_FILTER, long value, unsigned short CANSPI_CONFIG_FLAGS);
Description

Configures message filter. The parameter value is bit-adjusted to the appropriate filter registers.
Parameters
  • CANSPI_FILTER: CAN module filter number. Valid values: CANSPI_FILTER constants. See CANSPI_FILTER constants.
  • val: filter register value. This value is bit-adjusted to appropriate filter registers
  • CANSPI_CONFIG_FLAGS: selects type of message to filter. Valid values: _CANSPI_CONFIG_STD_MSG and _CANSPI_CONFIG_XTD_MSG. See CANSPI_CONFIG_FLAGS constants.
Returns

Nothing.
Requires

The CANSPI module must be in Config mode, otherwise the function will be ignored. See CANSPISetOperationMode.

The CANSPI routines are supported only by MCUs with the SPI module.

MCU has to be properly connected to mikroElektronika's CANSPI Extra Board or similar hardware. See connection example at the bottom of this page.
Example 
// set the appropriate filter value and message type
CANSPISetOperationMode(_CANSPI_MODE_CONFIG,0xFF);                  // set CONFIGURATION mode (CANSPI module must be in config mode for filter settings)

// Set id of filter B1_F1 to 3 :
CANSPISetFilter(_CANSPI_FILTER_B1_F1, 3, _CANSPI_CONFIG_XTD_MSG);
Notes

None.

CANSPIRead

Prototype

unsigned short CANSPIRead(long *id, unsigned short *data, unsigned short *datalen, unsigned short *CANSPI_RX_MSG_FLAGS);
Description

If at least one full Receive Buffer is found, it will be processed in the following way:

  • Message ID is retrieved and stored to location provided by the id parameter
  • Message data is retrieved and stored to a buffer provided by the data parameter
  • Message length is retrieved and stored to location provided by the dataLen parameter
  • Message flags are retrieved and stored to location provided by the CANSPI_RX_MSG_FLAGS parameter
Parameters
  • id: message identifier address
  • data: an array of bytes up to 8 bytes in length
  • dataLen: data length address
  • CANSPI_RX_MSG_FLAGS: message flags address. For message receive flags format refer to CANSPI_RX_MSG_FLAGS constants. See CANSPI_RX_MSG_FLAGS constants.
Returns

  • 0 if nothing is received
  • 0xFFFF if one of the Receive Buffers is full (message received)
Requires

The CANSPI module must be in a mode in which receiving is possible. See CANSPISetOperationMode.

The CANSPI routines are supported only by MCUs with the SPI module.

MCU has to be properly connected to mikroElektronika's CANSPI Extra Board or similar hardware. See connection example at the bottom of this page.
Example 
// check the CANSPI module for received messages. If any was received do something. 
unsigned short msg_rcvd, rx_flags, data_len;
char data[8];
unsigned long msg_id;
...
CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF);                  // set NORMAL mode (CANSPI module must be in mode in which receive is possible)
...
rx_flags = 0;                                                // clear message flags
if (msg_rcvd = CANSPIRead(msg_id, data, data_len, rx_flags)) {
  ...
}
Notes

None.

CANSPIWrite

Prototype

unsigned short CANSPIWrite(long id, unsigned short *data, unsigned short datalen, unsigned short CANSPI_TX_MSG_FLAGS);
Description

If at least one empty Transmit Buffer is found, the function sends message in the queue for transmission.
Parameters
  • id: CAN message identifier. Valid values: 11 or 29 bit values, depending on message type (standard or extended)
  • Data: data to be sent
  • DataLen: data length. Valid values: 0..8
  • CANSPI_TX_MSG_FLAGS: message flags. Valid values: CANSPI_TX_MSG_FLAGS constants. See CANSPI_TX_MSG_FLAGS constants.
Returns

  • 0 if all Transmit Buffers are busy
  • 0xFFFF if at least one Transmit Buffer is available
Requires

The CANSPI module must be in mode in which transmission is possible. See CANSPISetOperationMode.

The CANSPI routines are supported only by MCUs with the SPI module.

MCU has to be properly connected to mikroElektronika's CANSPI Extra Board or similar hardware. See connection example at the bottom of this page.
Example 
// send message extended CAN message with the appropriate ID and data
unsigned short tx_flags;
char data[8];
long msg_id;
...
CANSPISetOperationMode(CANSPI_MODE_NORMAL,0xFF);                  // set NORMAL mode (CANSPI must be in mode in which transmission is possible)

tx_flags = _CANSPI_TX_PRIORITY_0 & _CANSPI_TX_XTD_FRAME;   // set message flags
CANSPIWrite(msg_id, data, 2, tx_flags);
Notes

None.

CANSPI Constants

There is a number of constants predefined in the CANSPI library. You need to be familiar with them in order to be able to use the library effectively. Check the example at the end of the chapter.

CANSPI_OP_MODE Constants

The CANSPI_OP_MODE constants define CANSPI operation mode. Function CANSPISetOperationMode expects one of these as it's argument:

Copy Code To ClipboardCopy Code To Clipboard 
const unsigned int
    _CANSPI_MODE_BITS   = 0xE0,   // Use this to access opmode  bits
    _CANSPI_MODE_NORMAL = 0x00,
    _CANSPI_MODE_SLEEP  = 0x20,
    _CANSPI_MODE_LOOP   = 0x40,
    _CANSPI_MODE_LISTEN = 0x60,
    _CANSPI_MODE_CONFIG = 0x80;

CANSPI_CONFIG_FLAGS Constants

The CANSPI_CONFIG_FLAGS constants define flags related to the CANSPI module configuration. The functions CANSPIInit, CANSPISetBaudRate, CANSPISetMask and CANSPISetFilter expect one of these (or a bitwise combination) as their argument:

Copy Code To ClipboardCopy Code To Clipboard 
const unsigned int
    _CANSPI_CONFIG_DEFAULT        = 0xFF,   // 11111111

    _CANSPI_CONFIG_PHSEG2_PRG_BIT = 0x01,
    _CANSPI_CONFIG_PHSEG2_PRG_ON  = 0xFF,   // XXXXXXX1
    _CANSPI_CONFIG_PHSEG2_PRG_OFF = 0xFE,   // XXXXXXX0

    _CANSPI_CONFIG_LINE_FILTER_BIT = 0x02,
    _CANSPI_CONFIG_LINE_FILTER_ON  = 0xFF,   // XXXXXX1X
    _CANSPI_CONFIG_LINE_FILTER_OFF = 0xFD,   // XXXXXX0X

    _CANSPI_CONFIG_SAMPLE_BIT      = 0x04,
    _CANSPI_CONFIG_SAMPLE_ONCE     = 0xFF,   // XXXXX1XX
    _CANSPI_CONFIG_SAMPLE_THRICE   = 0xFB,   // XXXXX0XX

    _CANSPI_CONFIG_MSG_TYPE_BIT    = 0x08,
    _CANSPI_CONFIG_STD_MSG         = 0xFF,   // XXXX1XXX
    _CANSPI_CONFIG_XTD_MSG         = 0xF7,   // XXXX0XXX

    _CANSPI_CONFIG_DBL_BUFFER_BIT  = 0x10,
    _CANSPI_CONFIG_DBL_BUFFER_ON   = 0xFF,   // XXX1XXXX
    _CANSPI_CONFIG_DBL_BUFFER_OFF  = 0xEF,   // XXX0XXXX

    _CANSPI_CONFIG_MSG_BITS        = 0x60,
    _CANSPI_CONFIG_ALL_MSG         = 0xFF,   // X11XXXXX
    _CANSPI_CONFIG_VALID_XTD_MSG   = 0xDF,   // X10XXXXX
    _CANSPI_CONFIG_VALID_STD_MSG   = 0xBF,   // X01XXXXX
    _CANSPI_CONFIG_ALL_VALID_MSG   = 0x9F;   // X00XXXXX

You may use bitwise AND (&) to form config byte out of these values. For example:

Copy Code To ClipboardCopy Code To Clipboard 
init = _CANSPI_CONFIG_SAMPLE_THRICE &
       _CANSPI_CONFIG_PHSEG2_PRG_ON &
       _CANSPI_CONFIG_STD_MSG       &
       _CANSPI_CONFIG_DBL_BUFFER_ON &
       _CANSPI_CONFIG_VALID_XTD_MSG &
       _CANSPI_CONFIG_LINE_FILTER_OFF;
...
CANSPIInit(1, 1, 3, 3, 1, init);   // initialize CANSPI

CANSPI_TX_MSG_FLAGS Constants

CANSPI_TX_MSG_FLAGS are flags related to transmission of a CANSPI message:

Copy Code To ClipboardCopy Code To Clipboard 
const unsigned int
    _CANSPI_TX_PRIORITY_BITS = 0x03,
    _CANSPI_TX_PRIORITY_0    = 0xFC,   // XXXXXX00
    _CANSPI_TX_PRIORITY_1    = 0xFD,   // XXXXXX01
    _CANSPI_TX_PRIORITY_2    = 0xFE,   // XXXXXX10
    _CANSPI_TX_PRIORITY_3    = 0xFF,   // XXXXXX11

    _CANSPI_TX_FRAME_BIT     = 0x08,
    _CANSPI_TX_STD_FRAME     = 0xFF,    // XXXXX1XX
    _CANSPI_TX_XTD_FRAME     = 0xF7,    // XXXXX0XX

    _CANSPI_TX_RTR_BIT       = 0x40,
    _CANSPI_TX_NO_RTR_FRAME  = 0xFF,    // X1XXXXXX
    _CANSPI_TX_RTR_FRAME     = 0xBF;    // X0XXXXXX

You may use bitwise AND (&) to adjust the appropriate flags. For example:

Copy Code To ClipboardCopy Code To Clipboard 
// form value to be used as sending message flag :
send_config = _CANSPI_TX_PRIORITY_0 &
              _CANSPI_TX_XTD_FRAME  &
              _CANSPI_TX_NO_RTR_FRAME;
...
CANSPIWrite(id, data, 1, send_config);

CANSPI_RX_MSG_FLAGS Constants

CANSPI_RX_MSG_FLAGS are flags related to reception of CANSPI message. If a particular bit is set then corresponding meaning is TRUE or else it will be FALSE.

Copy Code To ClipboardCopy Code To Clipboard 
const unsigned int
    _CANSPI_RX_FILTER_BITS  = 0x07,   // Use this to access filter bits
    _CANSPI_RX_FILTER_1     = 0x00,
    _CANSPI_RX_FILTER_2     = 0x01,
    _CANSPI_RX_FILTER_3     = 0x02,
    _CANSPI_RX_FILTER_4     = 0x03,
    _CANSPI_RX_FILTER_5     = 0x04,
    _CANSPI_RX_FILTER_6     = 0x05,

    _CANSPI_RX_OVERFLOW     = 0x08,   // Set if Overflowed else cleared
    _CANSPI_RX_INVALID_MSG  = 0x10,   // Set if invalid else cleared
    _CANSPI_RX_XTD_FRAME    = 0x20,   // Set if XTD message else cleared
    _CANSPI_RX_RTR_FRAME    = 0x40,  // Set if RTR message else cleared
    _CANSPI_RX_DBL_BUFFERED = 0x80;  // Set if this message was hardware double-buffered

You may use bitwise AND (&) to adjust the appropriate flags. For example:

Copy Code To ClipboardCopy Code To Clipboard 
if (MsgFlag & _CANSPI_RX_OVERFLOW != 0) {
  ...
  // Receiver overflow has occurred.
  // We have lost our previous message.
}

CANSPI_MASK Constants

The CANSPI_MASK constants define mask codes. Function CANSPISetMask expects one of these as it's argument:

Copy Code To ClipboardCopy Code To Clipboard 
const unsigned int
    _CANSPI_MASK_B1 = 0,
    _CANSPI_MASK_B2 = 1;

CANSPI_FILTER Constants

The CANSPI_FILTER constants define filter codes. Functions CANSPISetFilter expects one of these as it's argument:

Copy Code To ClipboardCopy Code To Clipboard 
const unsigned int
    _CANSPI_FILTER_B1_F1 = 0,
    _CANSPI_FILTER_B1_F2 = 1,
    _CANSPI_FILTER_B2_F1 = 2,
    _CANSPI_FILTER_B2_F2 = 3,
    _CANSPI_FILTER_B2_F3 = 4,
    _CANSPI_FILTER_B2_F4 = 5;

Library Example

This is a simple demonstration of CANSPI Library routines usage. First node initiates the communication with the second node by sending some data to its address. The second node responds by sending back the data incremented by 1. First node then does the same and sends incremented data back to second node, etc.

Code for the first CANSPI node:

Stellaris

Copy Code To ClipboardCopy Code To Clipboard 
unsigned char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len;                                   // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const long ID_1st = 12111, ID_2nd = 3;                       // node IDs
long Rx_ID;

// CANSPI module connections
sbit CanSpi_CS            at  GPIO_PORTA_DATA0_bit;
sbit CanSpi_Rst           at  GPIO_PORTA_DATA3_bit;

sbit CanSpi_CS_Direction  at  GPIO_PORTA_DIR0_bit;
sbit CanSpi_Rst_Direction at  GPIO_PORTA_DIR3_bit;
// End CANSPI module connections

void main() {

  // GPIO_PORTD output for LEDs
  GPIO_Digital_Output(&GPIO_PORTD, _GPIO_PINMASK_ALL);
  GPIO_PORTD_DATA = 0;

  Can_Init_Flags = 0;                                         //
  Can_Send_Flags = 0;                                         // clear flags
  Can_Rcv_Flags  = 0;                                         //

  Can_Send_Flags = _CANSPI_TX_PRIORITY_0 &                    // form value to be used
                   _CANSPI_TX_XTD_FRAME &                     // with CANSPIWrite
                   _CANSPI_TX_NO_RTR_FRAME;

  Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE &             // form value to be used
                   _CANSPI_CONFIG_PHSEG2_PRG_ON &             // with CANSPIInit
                   _CANSPI_CONFIG_XTD_MSG &
                   _CANSPI_CONFIG_DBL_BUFFER_ON &
                   _CANSPI_CONFIG_VALID_XTD_MSG;

  // Initialize SPI0 module
  SPI0_Init();

  CANSPIInitialize(1,3,3,3,1,Can_Init_Flags);                            // initialize external CANSPI module
  CANSPISetOperationMode(_CANSPI_MODE_CONFIG,0xFF);                      // set CONFIGURATION mode
  CANSPISetMask(_CANSPI_MASK_B1,-1,_CANSPI_CONFIG_XTD_MSG);              // set all mask1 bits to ones
  CANSPISetMask(_CANSPI_MASK_B2,-1,_CANSPI_CONFIG_XTD_MSG);              // set all mask2 bits to ones
  CANSPISetFilter(_CANSPI_FILTER_B2_F4,ID_2nd,_CANSPI_CONFIG_XTD_MSG);   // set id of filter B2_F4 to 2nd node ID

  CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF);                      // set NORMAL mode

  // Set initial data to be sent
  RxTx_Data[0] = 9;

  CANSPIWrite(ID_1st, RxTx_Data, 1, Can_Send_Flags);                            // send initial message

  while(1) {                                                                    // endless loop
    Msg_Rcvd = CANSPIRead(&Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags);   // receive message
    if ((Rx_ID == ID_2nd) && Msg_Rcvd) {                                        // if message received check id
      GPIO_PORTD_DATA = RxTx_Data[0];                                           // id correct, output data at GPIO_PORTD
      RxTx_Data[0]++ ;                                                          // increment received data
      Delay_ms(10);
      CANSPIWrite(ID_1st, RxTx_Data, 1, Can_Send_Flags);                        // send incremented data back
    }
  }
}

STM32

Copy Code To ClipboardCopy Code To Clipboard 
unsigned char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len;                                   // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const long ID_1st = 12111, ID_2nd = 3;                       // node IDs
long Rx_ID;

// CANSPI module connections
sbit CanSpi_CS            at  GPIOB_ODR.B0;
sbit CanSpi_Rst           at  GPIOB_ODR.B2;
// End CANSPI module connections

void main() {

  // PORTD output for LEDs
  GPIO_Digital_Output(&GPIOD_BASE, _GPIO_PINMASK_ALL);
  GPIOD_ODR = 0;

  Can_Init_Flags = 0;                                         //
  Can_Send_Flags = 0;                                         // clear flags
  Can_Rcv_Flags  = 0;                                         //

  Can_Send_Flags = _CANSPI_TX_PRIORITY_0 &                    // form value to be used
                   _CANSPI_TX_XTD_FRAME &                     // with CANSPIWrite
                   _CANSPI_TX_NO_RTR_FRAME;

  Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE &             // form value to be used
                   _CANSPI_CONFIG_PHSEG2_PRG_ON &             // with CANSPIInit
                   _CANSPI_CONFIG_XTD_MSG &
                   _CANSPI_CONFIG_DBL_BUFFER_ON &
                   _CANSPI_CONFIG_VALID_XTD_MSG;

  // Initialize SPI1 module
   SPI1_Init_Advanced(_SPI_FPCLK_DIV8, _SPI_MASTER  | _SPI_8_BIT |
                     _SPI_CLK_IDLE_LOW | _SPI_FIRST_CLK_EDGE_TRANSITION |
                     _SPI_MSB_FIRST | _SPI_SS_DISABLE | _SPI_SSM_ENABLE | _SPI_SSI_1,
                     &_GPIO_MODULE_SPI1_PB345);

  GPIO_Alternate_Function_Enable(&_GPIO_MODULE_SWJ_JTAGDISABLE);


  CANSPIInitialize(1,3,3,3,1,Can_Init_Flags);                            // initialize external CANSPI module
  CANSPISetOperationMode(_CANSPI_MODE_CONFIG,0xFF);                      // set CONFIGURATION mode
  CANSPISetMask(_CANSPI_MASK_B1,-1,_CANSPI_CONFIG_XTD_MSG);              // set all mask1 bits to ones
  CANSPISetMask(_CANSPI_MASK_B2,-1,_CANSPI_CONFIG_XTD_MSG);              // set all mask2 bits to ones
  CANSPISetFilter(_CANSPI_FILTER_B2_F4,ID_2nd,_CANSPI_CONFIG_XTD_MSG);   // set id of filter B2_F4 to 2nd node ID

  CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF);                      // set NORMAL mode

  // Set initial data to be sent
  RxTx_Data[0] = 9;

  CANSPIWrite(ID_1st, RxTx_Data, 1, Can_Send_Flags);                            // send initial message

  while(1) {                                                                    // endless loop
    Msg_Rcvd = CANSPIRead(&Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags);   // receive message
    if ((Rx_ID == ID_2nd) && Msg_Rcvd) {                                        // if message received check id
      GPIOD_ODR = RxTx_Data[0];                                                 // id correct, output data at PORTD
      RxTx_Data[0]++ ;                                                          // increment received data
      Delay_ms(10);
      CANSPIWrite(ID_1st, RxTx_Data, 1, Can_Send_Flags);                        // send incremented data back
    }
  }
}

Code for the second CANSPI node:

Stellaris

Copy Code To ClipboardCopy Code To Clipboard 
unsigned char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len;                                   // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const long ID_1st = 12111, ID_2nd = 3;                       // node IDs
long Rx_ID;

// CANSPI module connections
sbit CanSpi_CS            at  GPIO_PORTA_DATA0_bit;
sbit CanSpi_Rst           at  GPIO_PORTA_DATA3_bit;

sbit CanSpi_CS_Direction  at  GPIO_PORTA_DIR0_bit;
sbit CanSpi_Rst_Direction at  GPIO_PORTA_DIR3_bit;
// End CANSPI module connections

void main() {

  // GPIO_PORTD output for LEDs
  GPIO_Digital_Output(&GPIO_PORTD, _GPIO_PINMASK_ALL);
  GPIO_PORTD_DATA = 0;

  Can_Init_Flags = 0;                                         //
  Can_Send_Flags = 0;                                         // clear flags
  Can_Rcv_Flags  = 0;                                         //

  Can_Send_Flags = _CANSPI_TX_PRIORITY_0 &                    // form value to be used
                   _CANSPI_TX_XTD_FRAME &                     // with CANSPIWrite
                   _CANSPI_TX_NO_RTR_FRAME;

  Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE &             // form value to be used
                   _CANSPI_CONFIG_PHSEG2_PRG_ON &             // with CANSPIInit
                   _CANSPI_CONFIG_XTD_MSG &
                   _CANSPI_CONFIG_DBL_BUFFER_ON &
                   _CANSPI_CONFIG_VALID_XTD_MSG &
                   _CANSPI_CONFIG_LINE_FILTER_OFF;

  // Initialize SPI0 module
  SPI0_Init();

  CANSPIInitialize(1,3,3,3,1,Can_Init_Flags);                           // initialize external CANSPI module
  CANSPISetOperationMode(_CANSPI_MODE_CONFIG,0xFF);                     // set CONFIGURATION mode
  CANSPISetMask(_CANSPI_MASK_B1,-1,_CANSPI_CONFIG_XTD_MSG);             // set all mask1 bits to ones
  CANSPISetMask(_CANSPI_MASK_B2,-1,_CANSPI_CONFIG_XTD_MSG);             // set all mask2 bits to ones
  CANSPISetFilter(_CANSPI_FILTER_B2_F3,ID_1st,_CANSPI_CONFIG_XTD_MSG);  // set id of filter B2_F3 to 1st node ID

  CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF);                           // set NORMAL mode

  while (1) {                                                                 // endless loop
    Msg_Rcvd = CANSPIRead(&Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags); // receive message
    if ((Rx_ID == ID_1st) && Msg_Rcvd) {                                      // if message received check id
      GPIO_PORTD_DATA = RxTx_Data[0];                                         // id correct, output data at GPIO_PORTD
      RxTx_Data[0]++ ;                                                        // increment received data
      CANSPIWrite(ID_2nd, RxTx_Data, 1, Can_Send_Flags);                      // send incremented data back
    }
  }
}

STM32

Copy Code To ClipboardCopy Code To Clipboard 
unsigned char Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len;                                   // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const long ID_1st = 12111, ID_2nd = 3;                       // node IDs
long Rx_ID;

// CANSPI module connections
sbit CanSpi_CS            at  GPIOB_ODR.B0;
sbit CanSpi_Rst           at  GPIOB_ODR.B2;
// End CANSPI module connections

void main() {

  // PORTD output for LEDs
  GPIO_Digital_Output(&GPIOD_BASE, _GPIO_PINMASK_ALL);
  GPIOD_ODR = 0;

  Can_Init_Flags = 0;                                         //
  Can_Send_Flags = 0;                                         // clear flags
  Can_Rcv_Flags  = 0;                                         //

  Can_Send_Flags = _CANSPI_TX_PRIORITY_0 &                    // form value to be used
                   _CANSPI_TX_XTD_FRAME &                     // with CANSPIWrite
                   _CANSPI_TX_NO_RTR_FRAME;

  Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE &             // form value to be used
                   _CANSPI_CONFIG_PHSEG2_PRG_ON &             // with CANSPIInit
                   _CANSPI_CONFIG_XTD_MSG &
                   _CANSPI_CONFIG_DBL_BUFFER_ON &
                   _CANSPI_CONFIG_VALID_XTD_MSG &
                   _CANSPI_CONFIG_LINE_FILTER_OFF;

  // Initialize SPI1 module
   SPI1_Init_Advanced(_SPI_FPCLK_DIV8, _SPI_MASTER  | _SPI_8_BIT |
                     _SPI_CLK_IDLE_LOW | _SPI_FIRST_CLK_EDGE_TRANSITION |
                     _SPI_MSB_FIRST | _SPI_SS_DISABLE | _SPI_SSM_ENABLE | _SPI_SSI_1,
                     &_GPIO_MODULE_SPI1_PB345);

  GPIO_Alternate_Function_Enable(&_GPIO_MODULE_SWJ_JTAGDISABLE);


  CANSPIInitialize(1,3,3,3,1,Can_Init_Flags);                           // initialize external CANSPI module
  CANSPISetOperationMode(_CANSPI_MODE_CONFIG,0xFF);                     // set CONFIGURATION mode
  CANSPISetMask(_CANSPI_MASK_B1,-1,_CANSPI_CONFIG_XTD_MSG);             // set all mask1 bits to ones
  CANSPISetMask(_CANSPI_MASK_B2,-1,_CANSPI_CONFIG_XTD_MSG);             // set all mask2 bits to ones
  CANSPISetFilter(_CANSPI_FILTER_B2_F3,ID_1st,_CANSPI_CONFIG_XTD_MSG);  // set id of filter B2_F3 to 1st node ID

  CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF);                           // set NORMAL mode

  while (1) {                                                                 // endless loop
    Msg_Rcvd = CANSPIRead(&Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags); // receive message
    if ((Rx_ID == ID_1st) && Msg_Rcvd) {                                      // if message received check id
      GPIOD_ODR = RxTx_Data[0];                                         // id correct, output data at PORTD
      RxTx_Data[0]++ ;                                                        // increment received data
      CANSPIWrite(ID_2nd, RxTx_Data, 1, Can_Send_Flags);                      // send incremented data back
    }
  }
}
Copyright (c) 2002-2012 mikroElektronika. All rights reserved.
What do you think about this topic ? Send us feedback!
Want more examples and libraries? 
Find them on LibStock - A place for the code