CAN Bus Sensor Module: Reading Vehicle Data with Arduino

The Controller Area Network (CAN) bus is the communication backbone of virtually every modern automobile. Developed in the 1980s by Bosch, it allows dozens of electronic control units (ECUs) — from the engine management system to the ABS and airbag controllers — to communicate with each other over a single pair of wires. For electronics hobbyists and engineers, tapping into this network opens up a world of real-time vehicle data: engine RPM, coolant temperature, vehicle speed, throttle position, fuel level, and much more. In this comprehensive tutorial, we will walk you through everything you need to know about using a CAN bus sensor module with Arduino to read live vehicle data.

1. What Is the CAN Bus?

The CAN (Controller Area Network) bus is a robust, multi-master serial communication protocol designed for reliable operation in noisy electrical environments — precisely the kind of environment found inside a vehicle. Unlike simple point-to-point UART connections or I2C/SPI buses (which have a single master), CAN allows multiple nodes to communicate with each other without a central host computer.

CAN uses two wires: CAN_H (CAN High) and CAN_L (CAN Low). These form a differential pair, meaning the voltage difference between them encodes the data. This differential signalling gives CAN exceptional noise immunity. Common CAN bus speeds in vehicles are 125 kbps (comfort systems), 250 kbps (powertrain), and 500 kbps (high-speed chassis systems). In newer vehicles, CAN FD (Flexible Data-rate) can run up to 5 Mbps for data-heavy ECUs.

Every message on the CAN bus has an identifier (11-bit standard or 29-bit extended) and carries up to 8 bytes of payload. All nodes receive every message; they choose to act on messages whose identifiers are relevant to them. This broadcast architecture is what makes OBD-II diagnostics possible — the OBD scanner simply sends a request frame with a known identifier, and the relevant ECU responds.

2. Popular CAN Bus Modules for Arduino

The most affordable and widely used CAN bus module for Arduino projects is based on the Microchip MCP2515 CAN controller paired with a TJA1050 or SN65HVD230 CAN transceiver. The MCP2515 communicates with the Arduino over SPI, making it compatible with virtually every Arduino board.

• MCP2515 Module (TJA1050): The most common option. Works at 5V logic. Widely supported by the MCP_CAN library. Supports standard and extended frame formats.
• SN65HVD230 Module: A 3.3V transceiver, ideal for ESP32 or Raspberry Pi projects. The MCP2515 chip itself handles the protocol layer.
• CAN-BUS Shield (Seeed Studio): Arduino shield form factor with an SD card slot and DB9 connector — great for professional-looking builds.

For most hobbyist vehicle data projects, the bare MCP2515 breakout module costing a few hundred rupees is all you need.

Benewake AD2-S-X3 Automotive-Grade LiDAR

A high-performance automotive-grade LiDAR sensor that integrates over CAN bus — perfect for advanced vehicle sensing projects alongside your OBD-II reader.

View on Zbotic

3. Hardware You Will Need

Gather the following components before you start:

• Arduino Uno, Nano, or Mega (5V logic)
• MCP2515 CAN bus module (with TJA1050 transceiver)
• OBD-II male connector (or an OBD-II extension cable to splice into)
• Breadboard and jumper wires
• USB cable for Arduino programming
• A vehicle with an OBD-II port (all cars sold after 2000 in India have this)
• Optional: 16×2 LCD or 0.96″ OLED display for real-time readout

The OBD-II port in your car provides both CAN bus access and a 12V power supply (on pin 16), so you can power your Arduino directly from the car once the circuit is working. Always use a proper automotive-grade voltage regulator if powering from the OBD port.

4. Wiring the MCP2515 Module to Arduino

The MCP2515 module communicates via SPI. Here is the pin mapping for an Arduino Uno:

The CAN_H and CAN_L pins of the module connect to the corresponding OBD-II connector pins. On the standard OBD-II pinout, CAN_H is on pin 6 and CAN_L is on pin 14 (for the high-speed powertrain bus). Pin 4 is chassis ground and pin 16 supplies 12V battery power.

Important: The 120-ohm termination resistors should be present at both ends of the CAN bus. Many MCP2515 modules have a solder jumper for termination — check whether it needs to be enabled for your setup. Inside the vehicle harness, termination is already provided by the ECUs, so you may not need to add another resistor when connecting to the OBD-II port.

5. Understanding the OBD-II Connector

OBD-II (On-Board Diagnostics version 2) is a standardised automotive diagnostic system mandated in the USA since 1996 and effectively required in all modern vehicles worldwide. The 16-pin OBD-II port is typically located beneath the dashboard on the driver’s side.

OBD-II defines several communication protocols. Most modern cars use ISO 15765-4 (CAN), which is what we target with the MCP2515 module. The diagnostic protocol uses a request/response model:

1. The tester (Arduino) sends a request frame to the vehicle’s functional address (0x7DF for broadcast, or 0x7E0–0x7E7 for specific ECUs).
2. The ECU responds from its response address (0x7E8 for the engine ECU).
3. The request payload specifies the service mode (Mode 01 for current data, Mode 02 for freeze frame, Mode 03 for fault codes) and the Parameter ID (PID).

Common Mode 01 PIDs include: 0x0C (Engine RPM), 0x0D (Vehicle Speed), 0x05 (Coolant Temperature), 0x04 (Calculated Engine Load), 0x11 (Throttle Position), and 0x2F (Fuel Tank Level Input).

6. Software Setup and Libraries

Open the Arduino IDE and install the MCP_CAN library by Cory Fowler (available directly from the Library Manager — search for “MCP_CAN”). This library handles all low-level SPI communication with the MCP2515, frame assembly, and reception.

Once installed, include it in your sketch:

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

#define CAN_CS_PIN 10
MCP_CAN CAN(CAN_CS_PIN);

void setup() {
  Serial.begin(115200);
  if (CAN.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ) == CAN_OK) {
    Serial.println("CAN bus initialized at 500 kbps");
  } else {
    Serial.println("CAN bus initialization FAILED");
    while (1);
  }
  CAN.setMode(MCP_NORMAL);
}

The second argument to CAN.begin() sets the bus speed. Use CAN_500KBPS for most modern vehicles. Older vehicles may use 250 kbps. The third argument is your MCP2515 oscillator crystal frequency — 8 MHz or 16 MHz depending on your module. Check the crystal on your PCB.

7. Reading OBD-II PID Data

OBD-II PID requests follow a specific format. The CAN frame payload is 8 bytes. For a single-byte PID request, the format is:

• Byte 0: Number of additional bytes (usually 0x02)
• Byte 1: Service mode (0x01 for current data)
• Byte 2: PID number (e.g., 0x0C for RPM)
• Bytes 3–7: Padding (0x00 or 0x55)

Here is a complete sketch to read engine RPM and vehicle speed:

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

#define CAN_CS_PIN 10
MCP_CAN CAN(CAN_CS_PIN);

void requestPID(byte pid) {
  byte data[8] = {0x02, 0x01, pid, 0x00, 0x00, 0x00, 0x00, 0x00};
  CAN.sendMsgBuf(0x7DF, 0, 8, data); // Broadcast OBD-II request
}

void setup() {
  Serial.begin(115200);
  CAN.begin(MCP_ANY, CAN_500KBPS, MCP_8MHZ);
  CAN.setMode(MCP_NORMAL);
  // Set mask and filter to accept only OBD-II response frames
  CAN.init_Mask(0, 0, 0xFFFF0000);
  CAN.init_Filt(0, 0, 0x7E80000);
  Serial.println("OBD-II Reader Ready");
}

void loop() {
  long unsigned int rxId;
  unsigned char len;
  unsigned char rxBuf[8];

  // Request RPM (PID 0x0C)
  requestPID(0x0C);
  delay(100);
  if (CAN.checkReceive() == CAN_MSGAVAIL) {
    CAN.readMsgBuf(&rxId, &len, rxBuf);
    if (rxId == 0x7E8 && rxBuf[2] == 0x0C) {
      int rpm = ((rxBuf[3] * 256) + rxBuf[4]) / 4;
      Serial.print("RPM: "); Serial.println(rpm);
    }
  }

  // Request Speed (PID 0x0D)
  requestPID(0x0D);
  delay(100);
  if (CAN.checkReceive() == CAN_MSGAVAIL) {
    CAN.readMsgBuf(&rxId, &len, rxBuf);
    if (rxId == 0x7E8 && rxBuf[2] == 0x0D) {
      int speed = rxBuf[3]; // km/h
      Serial.print("Speed: "); Serial.print(speed); Serial.println(" km/h");
    }
  }

  delay(500);
}

The RPM calculation uses the formula ((A * 256) + B) / 4 where A and B are the third and fourth response bytes. Speed is simply byte A (in km/h for ISO metric). Always consult the official OBD-II PID table for conversion formulas — each PID has its own scale and offset.

8. Displaying Data on Serial Monitor or LCD

The Serial Monitor is fine for debugging, but for a real in-car gauge, you will want a display. A 16×2 LCD with I2C backpack keeps wiring simple. Install the LiquidCrystal_I2C library and add these lines to your sketch:

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

// In setup():
lcd.init();
lcd.backlight();

// In loop() after reading RPM:
lcd.setCursor(0, 0);
lcd.print("RPM: ");
lcd.print(rpm);
lcd.print("    "); // clear leftover chars

For a more polished dashboard, consider a colour TFT display like the ST7789 or ILI9341. These allow you to draw gauge arcs, colour-coded zones, and multiple data fields simultaneously — creating a full aftermarket instrument cluster.

ACS712 20A Current Sensor Module

Pair this current sensor with your CAN bus reader to monitor real-time battery drain alongside OBD-II vehicle data for comprehensive automotive diagnostics.

View on Zbotic

9. Advanced Project Ideas

Once you can read basic PIDs, a whole ecosystem of projects opens up:

• Fuel Economy Logger: Combine MAF sensor readings (PID 0x10) and vehicle speed to calculate instantaneous fuel economy (litres per 100 km). Log to an SD card for trip analysis.
• DTC Reader and Clearer: Use Mode 03 to read Diagnostic Trouble Codes (DTCs) and Mode 04 to clear them — build your own OBD-II scanner.
• Turbo Boost Gauge: Read the MAP sensor or boost pressure PID (vehicle-specific PIDs differ from standard OBD-II PIDs) for performance monitoring.
• Data Logger with GPS: Combine CAN bus data with a GPS module to geo-tag vehicle performance metrics. Great for track day analysis.
• Custom CAN Networks: Design your own CAN node network for a go-kart, electric vehicle conversion, or robotics platform. Use the same MCP2515 module but write custom message identifiers and payloads.
• OTA Diagnostics over WiFi: Replace the Arduino with an ESP32. Send CAN data over WiFi to a web dashboard or cloud platform for remote vehicle monitoring.

10. Troubleshooting Common Issues

CAN bus initialization fails: Check wiring, especially CS pin. Verify the oscillator frequency matches your module (8 MHz or 16 MHz crystal visible on the PCB). Ensure the SPI pins are correct for your Arduino board variant.

No response from vehicle: Confirm you are using the correct bus speed for your vehicle (try 250 kbps if 500 kbps fails). Make sure CAN_H and CAN_L are not swapped. Ensure the ignition is in the ON (not START) position when querying.

Garbled or incorrect data: Double-check termination resistor settings. If there are only two nodes (Arduino + ECU), one termination at each end is required. Verify your PID conversion formula against the OBD-II specification.

Module gets hot: If the MCP2515 or TJA1050 runs warm, check for a short on CAN_H/CAN_L. These chips are hardy but will be damaged by sustained bus faults.

Works in car park, fails while driving: This is usually a ground loop issue. Use a dedicated ground wire from the Arduino GND to pin 4 of the OBD-II port. Do not rely on chassis ground through the connector body alone.

Frequently Asked Questions