How to Use Adafruit CAN Pal Breakout: Examples, Pinouts, and Specs

The Adafruit CAN Pal Breakout (Manufacturer Part ID: 5708) is a compact and versatile breakout board designed for interfacing with CAN (Controller Area Network) devices. It features an onboard CAN transceiver, making it ideal for reliable communication in automotive, industrial, and embedded systems. The breakout simplifies the process of integrating CAN communication into your projects, offering a robust and user-friendly solution.

• Automotive systems (e.g., ECU communication, diagnostics)
• Industrial automation and control
• Robotics and sensor networks
• IoT devices requiring CAN communication
• Data logging and monitoring systems

The Adafruit CAN Pal Breakout is built to meet the demands of modern CAN-based systems. Below are its key technical details:

• Operating Voltage: 3.3V or 5V logic levels (selectable)
• CAN Transceiver: MCP25625 (integrated CAN controller and transceiver)
• Communication Protocol: SPI (Serial Peripheral Interface)
• CAN Bus Speed: Up to 1 Mbps
• Operating Temperature: -40°C to +125°C
• Dimensions: 25.4mm x 25.4mm (1" x 1")
• Mounting: Standard 0.1" header pins for breadboard compatibility

The breakout board features a total of 8 pins. Below is the pinout and description:

The Adafruit CAN Pal Breakout is straightforward to use in a variety of projects. Below are the steps and best practices for integrating it into your circuit.

1. Power the Board: Connect the VIN pin to a 3.3V or 5V power source, and connect GND to the ground of your circuit.
2. Connect SPI Pins:
   • Connect SCK, MISO, MOSI, and CS to the corresponding SPI pins on your microcontroller.
   • Ensure the SPI clock speed is compatible with the MCP25625 (typically up to 10 MHz).
3. Interrupt and Reset:
   • Connect the INT pin to a GPIO pin on your microcontroller to handle interrupts.
   • Optionally, connect the RST pin to a GPIO pin for resetting the CAN controller.
4. CAN Bus Connection:
   • Use the onboard screw terminals to connect the CAN High (CANH) and CAN Low (CANL) lines to your CAN bus.
   • Ensure proper termination resistors (120Ω) are present at both ends of the CAN bus.

• Logic Level Selection: Ensure the microcontroller logic level matches the breakout board's logic level (3.3V or 5V).
• Termination Resistors: If the breakout board is at the end of the CAN bus, add a 120Ω resistor across CANH and CANL.
• SPI Configuration: Configure your microcontroller's SPI settings to match the MCP25625 requirements (Mode 0 or Mode 3).
• Interrupt Handling: Use the INT pin to efficiently handle incoming CAN messages or errors.

Below is an example of how to use the Adafruit CAN Pal Breakout with an Arduino UNO. This code initializes the CAN bus and sends a test message.

#include <SPI.h>
#include <Adafruit_MCP2515.h> // Library for MCP25625 CAN controller

// Create an MCP2515 instance
Adafruit_MCP2515 CAN(10); // CS pin connected to pin 10 on Arduino UNO

void setup() {
  Serial.begin(115200);
  while (!Serial); // Wait for Serial Monitor to open

  // Initialize the CAN controller
  if (!CAN.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ)) {
    Serial.println("CAN initialization failed!");
    while (1);
  }
  Serial.println("CAN initialized successfully!");

  // Set the CAN controller to normal mode
  CAN.setMode(MCP_NORMAL);
  Serial.println("CAN controller set to normal mode.");
}

void loop() {
  // Create a CAN message
  CANMessage message;
  message.id = 0x100; // Standard ID
  message.extended = false; // Standard frame
  message.len = 8; // Data length
  message.data[0] = 0x01; // Example data
  message.data[1] = 0x02;
  message.data[2] = 0x03;
  message.data[3] = 0x04;
  message.data[4] = 0x05;
  message.data[5] = 0x06;
  message.data[6] = 0x07;
  message.data[7] = 0x08;

  // Send the CAN message
  if (CAN.sendMessage(&message)) {
    Serial.println("Message sent successfully!");
  } else {
    Serial.println("Error sending message.");
  }

  delay(1000); // Wait 1 second before sending the next message
}

1. CAN Initialization Fails:

   • Cause: Incorrect SPI connections or mismatched logic levels.
   • Solution: Double-check the wiring and ensure the logic level matches the microcontroller.

2. No Communication on CAN Bus:

   • Cause: Missing or incorrect termination resistors.
   • Solution: Ensure 120Ω resistors are present at both ends of the CAN bus.

3. Interrupts Not Triggering:

   • Cause: INT pin not connected or not configured in the microcontroller.
   • Solution: Verify the INT pin connection and configure the GPIO pin as an input.

4. Data Corruption or Errors:

   • Cause: Noise or incorrect baud rate.
   • Solution: Use shielded cables for the CAN bus and ensure the baud rate matches all devices on the bus.

• Can I use this breakout with a 3.3V microcontroller? Yes, the breakout supports both 3.3V and 5V logic levels. Ensure the VIN pin is supplied with the appropriate voltage.

• What is the maximum CAN bus length? The maximum length depends on the baud rate. For example, at 1 Mbps, the maximum length is approximately 40 meters.

• Do I need external libraries for Arduino? Yes, you need the Adafruit_MCP2515 library, which can be installed via the Arduino Library Manager.

• Can I use multiple CAN Pal Breakouts on the same SPI bus? Yes, but each breakout must have a unique CS pin connection to the microcontroller.

This concludes the documentation for the Adafruit CAN Pal Breakout. For further assistance, refer to the official Adafruit guide or community forums.