Arduino CAN OBD-II Tutorial: Beginner's Guide to CAN Shield Communication

Understanding and utilizing the Controller Area Network (CAN) bus is increasingly important in modern automotive diagnostics and embedded systems. For enthusiasts and professionals alike, interfacing with a vehicle’s CAN bus opens up a world of possibilities for custom projects, data analysis, and diagnostics. This tutorial will guide you through the basics of using an Arduino with a CAN shield to communicate over a CAN bus, focusing on practical steps and addressing common challenges.

Introduction to CAN Bus and OBD-II

The CAN bus is a robust and efficient communication protocol widely used in vehicles to allow different electronic control units (ECUs) to communicate with each other without a central host computer. It’s designed to be reliable in electrically noisy environments and is crucial for real-time control and data exchange within a car.

OBD-II (On-Board Diagnostics II) is a standardized system used in most modern vehicles for diagnostics and monitoring. While OBD-II encompasses several communication protocols, CAN bus (specifically ISO 15765-4) is the most prevalent in modern cars. Accessing OBD-II data via CAN bus allows you to read real-time parameters like engine speed, coolant temperature, sensor readings, and diagnostic trouble codes (DTCs).

Using an Arduino and a CAN shield provides a cost-effective and accessible way to tap into this data stream. This tutorial focuses on setting up your Arduino with a CAN shield and establishing basic CAN communication, which is the foundation for more advanced projects like OBD-II data logging or custom automotive interfaces.

Essential Hardware for Arduino CAN Bus Communication

To get started with this tutorial, you will need the following hardware components:

Arduino Uno (or compatible): The microcontroller board that will process data and control the CAN shield. Arduino Uno is a popular and beginner-friendly choice.
CAN Bus Shield: This shield interfaces with the Arduino and provides the physical CAN bus communication capabilities. Popular shields often utilize the MCP2515 CAN controller and TJA1050 transceiver chips. Ensure your shield is compatible with your Arduino.
CAN Bus Connector/Wiring: You’ll need a way to connect to a CAN bus. For basic testing between two Arduinos, you can use jumper wires. For connecting to a vehicle’s OBD-II port, you’ll need an OBD-II connector and wiring to connect to your CAN shield.
Two Arduino Boards (for basic testing – optional but recommended): Having two Arduinos and CAN shields is highly recommended for initial testing. This allows you to set up a simple CAN network and verify communication before connecting to a vehicle.

Alt text: Arduino Uno microcontroller board stacked with a CAN Bus Shield, demonstrating the hardware setup for CAN communication.

Setting Up Your Arduino CAN Shield: Wiring and Connections

Connecting your CAN shield to the Arduino is typically straightforward as it’s designed to stack directly onto the Arduino Uno. However, understanding the CAN bus wiring is crucial for successful communication.

Key CAN Bus Connections:

CAN_H (CAN High): This pin carries the dominant differential signal of the CAN bus.
CAN_L (CAN Low): This pin carries the recessive differential signal of the CAN bus.
GND (Ground): Ground reference for the CAN bus network.

Connecting Two Arduinos with CAN Shields (for testing):

To test basic CAN communication between two Arduinos, you will connect them directly:

Connect the CAN_H pin of the first CAN shield to the CAN_H pin of the second CAN shield.
Connect the CAN_L pin of the first CAN shield to the CAN_L pin of the second CAN shield.
Connect the GND pin of the first CAN shield to the GND pin of the second CAN shield.

Termination Resistors:

For reliable CAN bus communication, especially over longer distances or at higher speeds, termination resistors are essential. CAN bus requires a termination resistor of 120 ohms at each end of the bus. Many CAN shields come with a built-in 120-ohm resistor that can be enabled or disabled via a jumper. For a simple two-node setup as described above, ensure that one of your CAN shields (or both, if they have switchable termination) has the termination resistor enabled. If your shields do not have built-in termination, you can add external 120-ohm resistors between the CAN_H and CAN_L lines at the ends of your CAN bus.

Arduino CAN Bus Library and Software Setup

To program your Arduino to communicate over CAN bus, you will need a suitable Arduino CAN library. A popular and well-maintained library is the “mcp_can” library, specifically designed for CAN shields using the MCP2515 CAN controller chip.

Installing the mcp_can Library:

Open your Arduino IDE.
Go to Sketch > Include Library > Manage Libraries…
In the Library Manager, search for “mcp_can“.
Find the “mcp_can” library by Cory Fowler and install the latest version.

Basic Arduino CAN Send and Receive Code Examples:

Here are basic code examples to send and receive CAN messages between two Arduinos using the mcp_can library.

Sender Arduino Code:

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

// Define CS pin for CAN shield (check your shield's documentation)
const int SPI_CS_PIN = 10;

MCP_CAN CAN(SPI_CS_PIN); // Set CS pin

void setup() {
  Serial.begin(115200);

CAN_BEGIN:
  if (CAN.begin(CAN_500KBPS) == CAN_OK) { // Initialize CAN at 500kbps
    Serial.println("CAN BUS Shield init ok!");
  } else {
    Serial.println("Can init fail, retry...");
    delay(100);
    goto CAN_BEGIN;
  }
}

void loop() {
  // Send CAN message every second
  unsigned char data[8] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}; // Example data
  CAN.sendMsgBuf(0x123, 0, 8, data); // Send message with ID 0x123, DLC 8, and data

  Serial.println("Message sent");
  delay(1000);
}

Receiver Arduino Code:

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

// Define CS pin for CAN shield (check your shield's documentation)
const int SPI_CS_PIN = 10;

MCP_CAN CAN(SPI_CS_PIN); // Set CS pin

void setup() {
  Serial.begin(115200);

CAN_BEGIN:
  if (CAN.begin(CAN_500KBPS) == CAN_OK) { // Initialize CAN at 500kbps
    Serial.println("CAN BUS Shield init ok!");
  } else {
    Serial.println("Can init fail, retry...");
    delay(100);
    goto CAN_BEGIN;
  }
}

void loop() {
  unsigned char len = 0;
  unsigned char buf[8];
  unsigned long canId;

  if (CAN_MSGAVAIL == CAN.checkReceive()) { // Check if a message is available
    CAN.readMsgBuf(&canId, &len, buf);    // Read message

    Serial.print("Received message with ID: 0x");
    Serial.println(canId, HEX);
    Serial.print("Data: ");
    for (int i = 0; i < len; i++) {
      Serial.print(buf[i], HEX);
      Serial.print(" ");
    }
    Serial.println();
  }
}

Explanation of the Code:

#include <mcp_can.h> and #include <SPI.h>: Include necessary libraries.
const int SPI_CS_PIN = 10;: Defines the Chip Select (CS) pin for the SPI communication with the CAN shield. Important: Check your CAN shield’s documentation to confirm the correct CS pin. Pin 10 is common, but some shields might use a different pin.
MCP_CAN CAN(SPI_CS_PIN);: Creates an instance of the MCP_CAN object, specifying the CS pin.
CAN.begin(CAN_500KBPS): Initializes the CAN bus communication at a specified baud rate (here, 500 kbps – a common rate for automotive CAN). Other common baud rates include 125 kbps, 250 kbps, and 1 Mbps. Ensure both sender and receiver Arduinos are set to the same baud rate.
CAN.sendMsgBuf(0x123, 0, 8, data); (Sender): Sends a CAN message.
- 0x123: CAN message ID (11-bit standard frame in this example).
- 0: Message type flag (0 for standard frame).
- 8: Data Length Code (DLC), indicating 8 bytes of data.
- data: The byte array containing the message data.
CAN.checkReceive() and CAN.readMsgBuf(...) (Receiver): Checks for and reads incoming CAN messages.

Running the Code and Troubleshooting:

Upload the sender code to one Arduino and the receiver code to the other Arduino.
Connect the two Arduinos with CAN shields as described in the “Wiring” section, ensuring proper CAN_H, CAN_L, and GND connections. Double-check termination resistors if needed.
Open the Serial Monitor in the Arduino IDE for both Arduinos, set to the baud rate of 115200.
If everything is set up correctly, you should see “CAN BUS Shield init ok!” printed on the Serial Monitor of both Arduinos. The sender Arduino should print “Message sent” every second, and the receiver Arduino should print “Received message with ID… Data…” displaying the data bytes.

Common Troubleshooting Steps:

“Can init fail” or “Enter setting mode fall Can init fail”: This error usually indicates a problem with CAN shield initialization.
- Check SPI CS Pin: Verify that the SPI_CS_PIN in your code matches the CS pin of your CAN shield.
- Wiring: Double-check all wiring connections, especially the SPI connections between the Arduino and CAN shield, and the CAN bus wiring (CAN_H, CAN_L, GND) between the two shields.
- Library Installation: Ensure the mcp_can library is correctly installed in your Arduino IDE.
- Shield Compatibility: Confirm that your CAN shield is compatible with the Arduino Uno and that you are using the correct library for your shield’s CAN controller (MCP2515 is common).
- Baud Rate Mismatch: Make sure the baud rate in CAN.begin() is the same in both sender and receiver code. 500 kbps is a reasonable starting point.
- Termination Resistors: If you are still experiencing issues, especially with longer wires, ensure proper 120-ohm termination at each end of the CAN bus.

Alt text: Diagram illustrating proper CAN bus wiring with termination resistors at both ends of the bus for signal integrity.

Moving Towards OBD-II and Vehicle Communication

Once you have successfully established basic CAN communication between two Arduinos, you are ready to explore connecting to a vehicle’s OBD-II port.

Connecting to OBD-II:

OBD-II Connector: Obtain an OBD-II connector (typically a J1962 female connector).
Wiring to OBD-II Connector: Identify the CAN_H (Pin 14) and CAN_L (Pin 6) pins on the OBD-II connector. Connect these pins to the CAN_H and CAN_L pins of your CAN shield, respectively. Connect OBD-II ground (Pin 4 or 5) to your CAN shield’s GND.
Vehicle Power: OBD-II connectors typically provide power (Pin 16). However, do not directly connect OBD-II power to your Arduino or CAN shield unless you are absolutely certain about voltage compatibility and current limits. It’s generally safer to power your Arduino and CAN shield separately, especially during initial testing.

OBD-II Library and Data Interpretation:

To effectively read OBD-II data, you may want to use an OBD-II specific Arduino library, although the mcp_can library itself provides the fundamental CAN communication. OBD-II data is transmitted in specific CAN message formats (PIDs – Parameter IDs). You will need to understand OBD-II standards or use an OBD-II library to interpret the raw CAN data into meaningful parameters like engine temperature, speed, etc.

Important Considerations for Vehicle Communication:

Vehicle Compatibility: Ensure your vehicle uses CAN bus for OBD-II communication (most modern vehicles do, but check your vehicle’s documentation).
Safety First: Exercise caution when connecting to a vehicle’s OBD-II port. Incorrect wiring or code could potentially interfere with vehicle systems. Start with read-only operations and avoid sending commands to the vehicle unless you fully understand the implications.
Research OBD-II PIDs: To read specific OBD-II parameters, you need to know the corresponding PIDs and how to request them via CAN messages. OBD-II PID documentation is readily available online.

Conclusion

This tutorial has provided a foundational understanding of using Arduino with a CAN shield for CAN bus communication. By following these steps, you should be able to set up basic CAN communication between two Arduinos and troubleshoot common initialization issues. This knowledge is your starting point for exploring more advanced automotive projects, including reading OBD-II data and developing custom vehicle interfaces. Remember to proceed with caution and thorough research when interfacing with real vehicles.

Arduino CAN OBD-II Tutorial: Beginner’s Guide to CAN Shield Communication