MCP2515 CANbus library

NOTE: This was originally written as instructions for using the MCP2515 CAN controller with Macchina 1.X series

So you have some CAN devices, and a CAN controller sharing board space with a nice I/O-studded microcontroller, and a basic idea of what you might be looking for on the bus (see my previous topic here: http://rechargecar.com/forums/macchina-and-protocols/can-bus-basics ).

Now what?

Now you program. Luckily we've adapted a library that simplifies communication between the Atmel microcontroller and the Microchip CAN controller on the Macchina. It's open-source, and we host it on Github. Here are a few ways to view and download the library:
The Github project is located at: https://github.com/rechargecar/mcp2515
If you just want to download the code, you can click here: https://github.com/rechargecar/mcp2515/archive/master.zip
If you're familiar with Git, here's a path to the repository: https://github.com/rechargecar/mcp2515.git

THE LIBRARY
In order for the Arduino environment to find the library, you'll first need to "install" it. Instructions for library installation can be found here: http://arduino.cc/en/Guide/Libraries

The MCP2515 library is a pretty straightforward affair (at least as straightforward as an abstraction layer for a bidirectional CAN message buffer and transceiver can be) that lets you build up CAN messages and send them out on the bus, and read any waiting messages from the bus.

All of the control functions depend on a custom data structure that represents a CAN 2.0 B (or 2.0 A) message frame. The functions do a pretty good job of masking and unmasking some of the configuration bits and putting them in their own fields within the Frame struct. Below is the definition of that data structure:

typedef struct
{
	unsigned long id;	// EID if ide set, SID otherwise
	byte srr;		// Standard Frame Remote Transmit Request
	byte rtr;		// Remote Transmission Request
	byte ide;		// Extended ID flag
	byte dlc;		// Number of data bytes
	byte data[8];		// Data bytes
} Frame;

The fields in the Frame struct match up well with the sections of CAN frames ( documented here: http://en.wikipedia.org/wiki/CAN_bus#Frames ), but are made a little more accessible to you as the coder. The methods of the library's MCP2515 class take care of all of the bit masking based on the values in the Frame struct's fields.

There's an example Arduino project included in the library that provides a very basic example of reading messages from the CAN bus. It covers all the pin assignments and other setup you'll need to go through before using the MCP2515 features exposed by the library.

The first steps involve constructing an MCP2515 object, setting up the SPI peripheral, initializing the CAN interface before and in the setup() function.

#include <SPI.h> // Arduino SPI Library
#include <MCP2515.h>

// Pin definitions specific to how the MCP2515 is wired up.
#define CS_PIN 85
#define RESET_PIN 7
#define INT_PIN 84

// Create CAN object with pins as defined
MCP2515 CAN(CS_PIN, RESET_PIN, INT_PIN);

void setup() {
  Serial.begin(115200);
  
  Serial.println("Initializing ...");

  // Set up SPI Communication
  // dataMode can be SPI_MODE0 or SPI_MODE3 only for MCP2515
  SPI.setClockDivider(SPI_CLOCK_DIV2);
  SPI.setDataMode(SPI_MODE0);
  SPI.setBitOrder(MSBFIRST);
  SPI.begin();
  
  // Initialise MCP2515 CAN controller at the specified speed and clock frequency
  // In this case 125kbps with a 16MHz oscillator
  // (Note: This is the oscillator attached to the MCP2515, not the Arduino oscillaltor)
  if(CAN.Init(250,16))
  {
    Serial.println("MCP2515 Init OK ...");
  } else {
    Serial.println("MCP2515 Init Failed ...");
  }

  Serial.println("Ready ...");
}

Then the program settles into a loop where it checks the MCP2515's receive buffer for any new packets on the bus. If there are new packets, the program reads them into a Frame struct, and then outputs the Frame message's fields, including any data payload over the serial line. There is also a section that is commented out that will send any received packets back out onto the CAN bus, but with the ID and each data byte incremented by 1. This can be useful for debugging purposes, to make sure the interface is connected correctly.

byte i=0;

// CAN message frame (actually just the parts that are exposed by the MCP2515 RX/TX buffers)
Frame message;

void loop() {
  
  message.id = 0;
  
  // This implementation utilizes the MCP2515 INT pin to flag received messages or other events
  if(CAN.Interrupt()) {
    // determine which interrupt flags have been set
    byte interruptFlags = CAN.Read(CANINTF);
    
    if(interruptFlags & RX0IF) {
      // read from RX buffer 0
      message = CAN.ReadBuffer(RXB0);
    }
    if(interruptFlags & RX1IF) {
      // read from RX buffer 1
      message = CAN.ReadBuffer(RXB1);
      // (this is poor code as clearly if two messages are received then the second will overwrite the first)
    }
    if(interruptFlags & TX0IF) {
      // TX buffer 0 sent
    }
    if(interruptFlags & TX1IF) {
      // TX buffer 1 sent
    }
    if(interruptFlags & TX2IF) {
      // TX buffer 2 sent
    }
    if(interruptFlags & ERRIF) {
      // error handling code
    }
    if(interruptFlags & MERRF) {
      // error handling code
      // if TXBnCTRL.TXERR set then transmission error
      // if message is lost TXBnCTRL.MLOA will be set
    }
 }
  
  if(message.id>0) {
    // Print message
    Serial.print("ID: ");
    Serial.println(message.id,HEX);
    Serial.print("Extended: ");
    if(message.ide) {
      Serial.println("Yes");
    } else {
      Serial.println("No");
    }
    Serial.print("DLC: ");
    Serial.println(message.dlc,DEC);
    for(i=0;i<message.dlc;i++) {
      Serial.print(message.data[i],HEX);
      Serial.print(" ");
    }
    Serial.println();
    Serial.println();

    // Send out a return message for each one received
    // Simply increment message id and data bytes to show proper transmission
    // Note: Please see explanation at top of sketch. You might want to comment this out!
   // message.id++;
 // for(i=0;i<message.dlc;i++) {
  // message.data[i]++;
  // }
 // CAN.LoadBuffer(TXB0, message);
 // CAN.SendBuffer(TXB0);
  }
}

Here's a Gist with all the code from the example, but if you have the library, you already have the example: https://gist.github.com/4177820

Hopefully this can serve as a good start for finding out what's going on on your CAN bus, and sending your own messages out on it.

MCP2515 CANbus library

Contact Us

Community

Legal Docs