Arduino and CAN Bus: Wiring, Code, and Debugging Primer

Connecting an Arduino and CAN bus is the ultimate upgrade when your project outgrows the 1-meter range of I2C or the noise sensitivity of standard UART. Controller Area Network (CAN) uses differential signaling to reject electromagnetic interference (EMI), making it the standard for automotive and industrial environments. However, because CAN is a multi-master, message-oriented protocol, it requires specific physical layer components and strict termination rules to function.

To interface an Arduino with a CAN network, you cannot just wire GPIO pins to the bus. You need a CAN controller (like the Microchip MCP2515) to handle the protocol framing via SPI, and a CAN transceiver (like the TJA1050 or SN65HVD230) to convert the logic-level SPI signals into the differential voltages (CANH and CANL) that travel over the twisted-pair wire.

Physical Layer: Wiring the Transceiver and Termination

The most common point of failure when integrating an Arduino and CAN bus happens before a single line of code is compiled: the physical layer. The transceiver bridges your microcontroller's SPI bus to the physical twisted-pair cable.

The Termination Resistor Rule

High-speed CAN (ISO 11898-2) requires a 120Ω termination resistor at each physical end of the bus. This prevents signal reflections that corrupt data at high baud rates. When measuring across CANH and CANL with a multimeter on a properly terminated, powered-down bus, you should read exactly 60Ω (two 120Ω resistors in parallel).

• Reading ~120Ω: You are missing a termination resistor on one end of the bus.
• Reading ~40Ω: You have too many termination resistors (a common mistake when using multiple pre-populated breakout boards).
• Reading 0Ω: CANH and CANL are shorted together.

Note: Many cheap $3 MCP2515 clone modules from online marketplaces come with a 120Ω surface-mount resistor pre-soldered. If you are building a multi-node network, you must desolder or cut the trace on all modules except the two at the extreme ends of the physical cable.

Bus Mechanics: Protocol Selection and Limits

Which protocol fits your distance, speed, and device count? While I2C and SPI are fine for sensors on a single PCB, they collapse over distance. RS485 is great for long distances but requires a master-slave polling architecture. CAN offers a multi-master, collision-resolving architecture that scales beautifully.

For a deeper dive into the electrical characteristics of the physical layer, the Texas Instruments CAN Physical Layer Application Report (SLYA049) provides excellent eye-diagram analysis and cable capacitance guidelines.

Minimal Working Exchange: Sending and Receiving

To get an Arduino and CAN bus communicating, we will use the ubiquitous MCP2515 controller. Below is the hardware mapping and the minimal code required to transmit a payload.

SPI Pin Mapping (Arduino Uno / Nano)

Transmitter Code (MCP_CAN Library)

Install the mcp_can library via the Arduino Library Manager. The most critical parameter is the crystal oscillator frequency. Most inexpensive breakout boards use an 8MHz crystal, but the library defaults to 16MHz. If you do not explicitly declare MCP_8MHz, your baud rate will be exactly half of what you intend, causing silent bus failures.

#include <mcp_can.h>
#include <SPI.h>

#define SPI_CS_PIN 10
#define CAN_INT_PIN 2

MCP_CAN CAN0(SPI_CS_PIN);

void setup() {
  Serial.begin(115200);
  // Initialize MCP2515 at 500kbps with an 8MHz crystal
  if (CAN0.begin(MCP_ANY, CAN_500KBPS, MCP_8MHz) == CAN_OK) {
    Serial.println("MCP2515 Initialized Successfully");
    CAN0.setMode(MCP_NORMAL); // Set operation mode to normal
  } else {
    Serial.println("Error Initializing MCP2515");
  }
  pinMode(CAN_INT_PIN, INPUT);
}

void loop() {
  unsigned char stmp[8] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80};
  // Send data: ID = 0x100, Standard Frame, Data Length = 8, Data = stmp
  byte sndStat = CAN0.sendMsgBuf(0x100, 0, 8, stmp);
  if (sndStat == CAN_OK) {
    Serial.println("Message Sent Successfully");
  } else {
    Serial.println("Error Sending Message");
  }
  delay(100);
}

Debugging and Classic Failures

When your Arduino and CAN bus refuse to talk, the issue almost always falls into one of three classic failure modes. Here is how to isolate them.

1. The 'Missing Pull-Up' (Termination) Confusion

Makers coming from I2C often ask, 'Where are the pull-up resistors on the CAN bus?' Standard high-speed CAN does not use pull-up resistors on the data lines; it uses 120Ω termination resistors across CANH and CANL. However, if you are using Single-Wire CAN (SWC) or Fault-Tolerant CAN (ISO 11519-2), the transceivers do require specific pull-up and pull-down biasing resistors to establish the recessive state. Ensure you are using the correct transceiver topology for your termination scheme.

2. Baud Rate Mismatch and the SJW Trap

If Node A is transmitting at 500kbps and Node B is listening at 500kbps, but they are using different microcontrollers (e.g., an Arduino Uno and an STM32), they might still fail to communicate. This is often due to the Synchronization Jump Width (SJW) or slight clock drift from using the internal RC oscillator instead of an external quartz crystal. According to the Microchip MCP2515 Datasheet, the SJW must be configured to absorb phase errors between nodes. Always use external crystals for CAN nodes, and ensure the SJW is set to at least 2 or 3 time quanta (TQ) on both ends.

3. Address Clash and Arbitration Corruption

CAN uses non-destructive bitwise arbitration. If two nodes transmit the exact same 11-bit ID at the same time, they will both win arbitration. If their data payloads differ in the subsequent bytes, they will drive the bus to opposite logic states simultaneously, triggering a form error and causing both nodes to increment their Transmit Error Counter (TEC) until they enter a 'Bus Off' state. Never assign duplicate CAN IDs to different sensor nodes.

How to Sniff the Bus

Do not rely solely on Serial.print() for debugging. To truly see the traffic, use a dedicated USB-to-CAN sniffer like the CANable (an open-source $25 adapter) or a commercial tool like the PCAN-USB. Connect the sniffer to your PC, use software like BusMaster or SavvyCAN, and watch the raw hex frames. If you see a sea of 'Error Frames', your physical layer (termination or wiring) is compromised.

Arduino and CAN Bus FAQ