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

The CAN is a very robust protocol that has error detection and signalization, self–checking and fault confinement. Faulty CAN data and remote frames are re-transmitted automatically, similar to the Ethernet.

In the mikroBasic PRO for PIC, each routine of the CAN library has its own CANSPI counterpart with identical syntax. For more information on Controller Area Network, consult the CAN Library. Note that an effective communication speed depends on SPI and certainly is slower than "real" CAN.

CAN supports two message formats:

• Standard format, with 11 identifier bits and
• Extended format, with 29 identifier bits

  Important :

• Consult the CAN standard about CAN bus termination resistance.
• An effective CANSPI communication speed depends on SPI and certainly is slower than “real” CAN.
• The library uses the SPI module for communication. User must initialize appropriate SPI module before using the CANSPI Library.
• For MCUs with two SPI modules it is possible to initialize both of them and then switch by using the SPI_Set_Active routine.
• CANSPI module refers to mikroElektronika's CANSPI Add-on board connected to SPI module of MCU.

Library Dependency Tree

External dependencies of CANSPI Library

Library Routines

• CANSPISetOperationMode
• CANSPIGetOperationMode
• CANSPIInitialize
• CANSPISetBaudRate
• CANSPISetMask
• CANSPISetFilter
• CANSPIread
• CANSPIWrite

CANSPISetOperationMode

' set the CANSPI module into configuration mode (wait inside CANSPISetOperationMode until this mode is set)
CANSPISetOperationMode(_CANSPI_MODE_CONFIG, 0xFF)

CANSPIGetOperationMode

' check whether the CANSPI module is in Normal mode and if it is do something.
if (CANSPIGetOperationMode() = _CANSPI_MODE_NORMAL) then
  ...
end if 
  

CANSPIInitialize

' CANSPI module connections
dim CanSpi_CS     as sbit at  RC0_bit
    CanSpi_CS_Direction  as sbit at TRISC0_bit
    CanSpi_Rst  as sbit at RC2_bit
    CanSpi_Rst_Direction  as sbit at TRISC2_bit
' End CANSPI module connections  

...

dim CanSPI_Init_Flags as byte
  ...  
  CanSPI_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE and  ' form value to be used
                   _CANSPI_CONFIG_PHSEG2_PRG_ON and  ' with CANSPIInitialize
                   _CANSPI_CONFIG_XTD_MSG       and
                   _CANSPI_CONFIG_DBL_BUFFER_ON and
                   _CANSPI_CONFIG_VALID_XTD_MSG
  ...
  SPI1_Init()                                  ' initialize SPI module
  CANSPIInitialize(1,3,3,3,1,CanSPI_Init_Flags)  ' initialize external CANSPI module

CANSPISetBaudRate

' set required baud rate and sampling rules
dim canspi_config_flags as byte
...  
CANSPISetOperationMode(_CANSPI_MODE_CONFIG, 0xFF)              ' set CONFIGURATION mode (CANSPI module mast be in config mode for baud rate settings)
can_config_flags = _CANSPI_CONFIG_SAMPLE_THRICE and
                   _CANSPI_CONFIG_PHSEG2_PRG_ON and
                   _CANSPI_CONFIG_STD_MSG       and
                   _CANSPI_CONFIG_DBL_BUFFER_ON and
                   _CANSPI_CONFIG_VALID_XTD_MSG and
                   _CANSPI_CONFIG_LINE_FILTER_OFF
CANSPISetBaudRate(1, 1, 3, 3, 1, canspi_config_flags)

CANSPISetMask

' 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 and _CANSPI_CONFIG_XTD_MSG)

CANSPISetFilter

' 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)

CANSPIRead

' check the CANSPI module for received messages. If any was received do something. 
dim msg_rcvd, rx_flags, data_len as byte
 rd_data as byte[8]
 msg_id as longint
...
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, rd_data, data_len, rx_flags) 
  ...
end if

CANSPIWrite

' send message extended CAN message with the appropriate ID and data
dim tx_flags as byte
 rd_data as byte[8]
 msg_id as longint
...
CANSPISetOperationMode(_CANSPI_MODE_NORMAL, 0xFF)                  ' set NORMAL mode (CANSPI must be in mode in which transmission is possible)

tx_flags = _CANSPI_TX_PRIORITY_0 ands _CANSPI_TX_XTD_FRAME             ' set message flags
CANSPIWrite(msg_id, rd_data, 2, tx_flags)

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

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

const
    _CANSPI_MODE_BITS   as byte = 0xE0    Use this to access opmode  bits
    _CANSPI_MODE_NORMAL as byte = 0x00
    _CANSPI_MODE_SLEEP  as byte = 0x20
    _CANSPI_MODE_LOOP   as byte = 0x40
    _CANSPI_MODE_LISTEN as byte = 0x60
    _CANSPI_MODE_CONFIG as byte = 0x80

CANSPI_CONFIG_FLAGS

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

const
    _CANSPI_CONFIG_DEFAULT        as byte  = 0xFF   ' 11111111

    _CANSPI_CONFIG_PHSEG2_PRG_BIT as byte  = 0x01
    _CANSPI_CONFIG_PHSEG2_PRG_ON  as byte  = 0xFF   ' XXXXXXX1
    _CANSPI_CONFIG_PHSEG2_PRG_OFF as byte  = 0xFE   ' XXXXXXX0

    _CANSPI_CONFIG_LINE_FILTER_BIT as byte = 0x02
    _CANSPI_CONFIG_LINE_FILTER_ON  as byte = 0xFF   ' XXXXXX1X
    _CANSPI_CONFIG_LINE_FILTER_OFF as byte = 0xFD   ' XXXXXX0X

    _CANSPI_CONFIG_SAMPLE_BIT      as byte = 0x04
    _CANSPI_CONFIG_SAMPLE_ONCE     as byte = 0xFF   ' XXXXX1XX
    _CANSPI_CONFIG_SAMPLE_THRICE   as byte = 0xFB   ' XXXXX0XX

    _CANSPI_CONFIG_MSG_TYPE_BIT    as byte = 0x08
    _CANSPI_CONFIG_STD_MSG         as byte = 0xFF   ' XXXX1XXX
    _CANSPI_CONFIG_XTD_MSG         as byte = 0xF7   ' XXXX0XXX

    _CANSPI_CONFIG_DBL_BUFFER_BIT  as byte = 0x10
    _CANSPI_CONFIG_DBL_BUFFER_ON   as byte = 0xFF   ' XXX1XXXX
    _CANSPI_CONFIG_DBL_BUFFER_OFF  as byte = 0xEF   ' XXX0XXXX

    _CANSPI_CONFIG_MSG_BITS        as byte = 0x60
    _CANSPI_CONFIG_ALL_MSG         as byte = 0xFF   ' X11XXXXX
    _CANSPI_CONFIG_VALID_XTD_MSG   as byte = 0xDF   ' X10XXXXX
    _CANSPI_CONFIG_VALID_STD_MSG   as byte = 0xBF   ' X01XXXXX
    _CANSPI_CONFIG_ALL_VALID_MSG   as byte = 0x9F   ' X00XXXXX

You may use bitwise and to form config byte out of these values. For example:

Copy Code To Clipboard

init  = _CANSPI_CONFIG_SAMPLE_THRICE    and
        _CANSPI_CONFIG_PHSEG2_PRG_ON    and
        _CANSPI_CONFIG_STD_MSG          and
        _CANSPI_CONFIG_DBL_BUFFER_ON    and
        _CANSPI_CONFIG_VALID_XTD_MSG    and
        _CANSPI_CONFIG_LINE_FILTER_OFF
...
CANSPIInit(1, 1, 3, 3, 1, init)   ' initialize CANSPI

CANSPI_TX_MSG_FLAGS

CANSPI_TX_MSG_FLAGS are flags related to transmission of a CANSPI message:

 const
    _CANSPI_TX_PRIORITY_BITS as byte = 0x03
    _CANSPI_TX_PRIORITY_0    as byte = 0xFC   ' XXXXXX00
    _CANSPI_TX_PRIORITY_1    as byte = 0xFD   ' XXXXXX01
    _CANSPI_TX_PRIORITY_2    as byte = 0xFE   ' XXXXXX10
    _CANSPI_TX_PRIORITY_3    as byte = 0xFF   ' XXXXXX11

    _CANSPI_TX_FRAME_BIT     as byte = 0x08
    _CANSPI_TX_STD_FRAME     as byte = 0xFF   ' XXXXX1XX
    _CANSPI_TX_XTD_FRAME     as byte = 0xF7   ' XXXXX0XX

    _CANSPI_TX_RTR_BIT       as byte = 0x40
    _CANSPI_TX_NO_RTR_FRAME  as byte = 0xFF   ' X1XXXXXX
    _CANSPI_TX_RTR_FRAME     as byte = 0xBF   ' X0XXXXXX

You may use bitwise and to adjust the appropriate flags. For example:

Copy Code To Clipboard

' form value to be used with CANSendMessage:
send_config  = _CANSPI_TX_PRIORITY_0    and
               _CANSPI_TX_XTD_FRAME     and
               _CANSPI_TX_NO_RTR_FRAME
...
CANSPIWrite(id, data, 1, send_config)

CANSPI_RX_MSG_FLAGS

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

const
    _CANSPI_RX_FILTER_BITS  as byte = 0x07   ' Use this to access filter bits
    _CANSPI_RX_FILTER_1     as byte = 0x00
    _CANSPI_RX_FILTER_2     as byte = 0x01
    _CANSPI_RX_FILTER_3     as byte = 0x02
    _CANSPI_RX_FILTER_4     as byte = 0x03
    _CANSPI_RX_FILTER_5     as byte = 0x04
    _CANSPI_RX_FILTER_6     as byte = 0x05

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

You may use bitwise and to adjust the appropriate flags. For example:

Copy Code To Clipboard

if (MsgFlag and _CANSPI_RX_OVERFLOW) <> 0 then
  ...
  ' Receiver overflow has occurred.
  ' We have lost our previous message.
end if

CANSPI_MASK

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

const
     _CANSPI_MASK_B1 as byte = 0
     _CANSPI_MASK_B2 as byte = 1

CANSPI_FILTER

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

const
    _CANSPI_FILTER_B1_F1 as byte = 0
    _CANSPI_FILTER_B1_F2 as byte = 1
    _CANSPI_FILTER_B2_F1 as byte = 2
    _CANSPI_FILTER_B2_F2 as byte = 3
    _CANSPI_FILTER_B2_F3 as byte = 4
    _CANSPI_FILTER_B2_F4 as byte = 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:

Copy Code To Clipboard

program Can_Spi_1st

dim Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags as byte   ' can flags
    Rx_Data_Len as byte                                     ' received data length in bytes
    RxTx_Data   as byte[8]                                  ' can rx/tx data buffer
    Msg_Rcvd as byte                                        ' reception flag
    Tx_ID, Rx_ID as longint                                 ' can rx and tx ID

' CANSPI module connections
dim CanSpi_CS as sbit at RC0_bit
    CanSpi_CS_Direction as sbit at TRISC0_bit
    CanSpi_Rst as sbit at RC2_bit
    CanSpi_Rst_Direction as sbit at TRISC2_bit
' End CANSPI module connections

main:
  ANSEL  = 0                       ' Configure AN pins as digital I/O
  ANSELH = 0
  PORTB = 0
  TRISB = 0

  Can_Init_Flags = 0                                      '
  Can_Send_Flags = 0                                      ' clear flags
  Can_Rcv_Flags  = 0                                      '

  Can_Send_Flags = _CANSPI_TX_PRIORITY_0 and              ' form value to be used
                    _CANSPI_TX_XTD_FRAME and              '     with CANSPIWrite
                    _CANSPI_TX_NO_RTR_FRAME

  Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE and       ' form value to be used
                    _CANSPI_CONFIG_PHSEG2_PRG_ON and      ' with CANSPIInit
                    _CANSPI_CONFIG_XTD_MSG and
                    _CANSPI_CONFIG_DBL_BUFFER_ON and
                    _CANSPI_CONFIG_VALID_XTD_MSG

  SPI1_Init()                                                      ' initialize SPI1 module
  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,3,_CANSPI_CONFIG_XTD_MSG)   ' set id of filter B1_F1 to 3

  CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF)                 ' set NORMAL mode

  RxTx_Data[0] = 9                                                 ' set initial data to be sent

  Tx_ID = 12111                                                    ' set transmit ID

  CANSPIWrite(Tx_ID, RxTx_Data, 1, Can_Send_Flags)                 ' send initial message
  while TRUE                                                       ' endless loop
    Msg_Rcvd = CANSPIRead(Rx_ID , RxTx_Data , Rx_Data_Len, Can_Rcv_Flags)   ' receive message
    if ((Rx_ID = 3) and Msg_Rcvd) then                                      ' if message received check id
      PORTB = RxTx_Data[0]                                                  ' id correct, output data at PORTC
      Inc(RxTx_Data[0])                                                     ' increment received data
      Delay_ms(10)
      CANSPIWrite(Tx_ID, RxTx_Data, 1, Can_Send_Flags)                      ' send incremented data back
    end if
  wend
end.

Code for the second CANSPI node:

Copy Code To Clipboard

program Can_Spi_2nd

dim Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags as byte  ' can flags
    Rx_Data_Len as byte                                    ' received data length in bytes
    RxTx_Data    as byte[8]                                ' CAN rx/tx data buffer
    Msg_Rcvd as byte                                       ' reception flag
    Tx_ID, Rx_ID as longint                                ' can rx and tx ID

' CANSPI module connections
dim CanSpi_CS as sbit at RC0_bit
    CanSpi_CS_Direction as sbit at TRISC0_bit
    CanSpi_Rst as sbit at PORTC.B2
    CanSpi_Rst_Direction as sbit at TRISC2_bit
' End CANSPI module connections

main:
  ANSEL  = 0                                               ' Configure AN pins as digital I/O
  ANSELH = 0
  PORTB = 0                                                ' clear PORTB
  TRISB = 0                                                ' set PORTB as output

  Can_Init_Flags = 0                                       '
  Can_Send_Flags = 0                                       ' clear flags
  Can_Rcv_Flags  = 0                                       '

  Can_Send_Flags = _CANSPI_TX_PRIORITY_0 and               ' form value to be used
                    _CANSPI_TX_XTD_FRAME and               '  with CANSPIWrite
                    _CANSPI_TX_NO_RTR_FRAME

  Can_Init_Flags = _CANSPI_CONFIG_SAMPLE_THRICE and        ' Form value to be used
                    _CANSPI_CONFIG_PHSEG2_PRG_ON and       '  with CANSPIInit
                    _CANSPI_CONFIG_XTD_MSG and
                    _CANSPI_CONFIG_DBL_BUFFER_ON and
                    _CANSPI_CONFIG_VALID_XTD_MSG and
                    _CANSPI_CONFIG_LINE_FILTER_OFF

  SPI1_Init()                                                              ' initialize SPI1 module
  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,12111,_CANSPI_CONFIG_XTD_MSG)       ' set id of filter B1_F1 to 3
  CANSPISetOperationMode(_CANSPI_MODE_NORMAL,0xFF)                         ' set NORMAL mode
  Tx_ID = 3                                                                ' set tx ID

  while TRUE                                                               ' endless loop
    Msg_Rcvd = CANSPIRead(Rx_ID , RxTx_Data , Rx_Data_Len, Can_Rcv_Flags)  ' receive message
    if ((Rx_ID = 12111) and Msg_Rcvd) then                                 ' if message received check id
      PORTB = RxTx_Data[0]                                                 ' id correct, output data at PORTC
      Inc(RxTx_Data[0])                                                    ' increment received data
      CANSPIWrite(Tx_ID, RxTx_Data, 1, Can_Send_Flags)                     ' send incremented data back
    end if
  wend
end.

HW Connection

Example of interfacing CAN transceiver MCP2510 with MCU via SPI interface

Want more examples and libraries? 
Find them on