OBD2 Extended IDs: no data received and error on dashboard

Hi everybody,

I'm writing because I can't read messages from my OBD2 CAN-Bus socket in the car.
Thanks to ELM327 OBDII, I could check the protocol used by ECM: CAN Extended 29 bits,500kb ISO 15765-4.
(link: https://www.amazon.it/Ellenne-DIAGNOSTICA-Scanner-Bluetooth-Compatibile/dp/B08954ZRK7/ref=asc_df_B08954ZRK7/?tag=googshopit-21&linkCode=df0&hvadid=459268562771&hvpos=&hvnetw=g&hvrand=16439785881293494442&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=1008141&hvtargid=pla-1157134366989&psc=1)

I attached the code and libraries used.
I set the correct standard for MCP2515-TJA1050 (as in code, defined standard 0 means functional_id request 0x18DB33F1, --> I saw in the original code the functional id was 0x98DB33F1

but is it correct?)

I connected MCP2515 in this way:

MCP2515 CAN H --> pin 6 obd2 socket
MCP2515 CAN L --> pin 14 obd2 socket

obd2 socket pin 4 --> GND arduino UNO board
obd2 socket pin 5 --> GND arduino UNO board

MCP2515 Vcc --> 5V arduino UNO board
MCP2515 GND --> GND arduino UNO board
MCP2515 CS --> pin 9 arduino UNO board
MCP2515 INT --> pin 2 arduino UNO board
MCP2515 SCK --> pin 13 arduino UNO board
MCP2515 SO --> pin 12 arduino UNO board

MCP2515 is terminated with a jumper on J1 (120 Ohm, as specification describes).
MCP2515 is configured for 500 kb and 8Mhz.

#include <mcp_can_dfs.h>

/* CAN OBD & UDS Simple PID Request
 *  Currently requests PID 0x00 at a 1 second interval and
 *  displays all received CAN traffic to the terminal at 115200.
 *  Written By: Cory J. Fowler  April 5th, 2017
 *  (Disclaimer: Standard IDs are currently UNTESTED against a vehicle)

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

#define standard 0
// 7E0/8 = Engine ECM
// 7E1/9 = Transmission ECM
#if standard == 1
  #define LISTEN_ID 0x7EA
  #define REPLY_ID 0x7E0
  #define FUNCTIONAL_ID 0x7DF
  #define LISTEN_ID 0x18DAF101
  #define REPLY_ID 0x18DA01F1
  #define FUNCTIONAL_ID 0x18DB33F1

// CAN TX Variables
unsigned long prevTx = 0;
unsigned int invlTx = 1000;
byte txData[] = {0x02,0x01,0x00,0x55,0x55,0x55,0x55,0x55};

// CAN RX Variables
unsigned long rxID;
byte dlc;
byte rxBuf[8];
char msgString[128];                        // Array to store serial string

// CAN Interrupt and Chip Select Pins
#define CAN0_INT 2                              /* Set INT to pin 2 (This rarely changes)   */
MCP_CAN CAN0(9);                                /* Set CS to pin 9 (Old shields use pin 10) */

void setup(){

  // Initialize MCP2515 running at 16MHz with a baudrate of 500kb/s and the masks and filters disabled.
  if(CAN0.begin(MCP_STDEXT, CAN_500KBPS, MCP_8MHZ) == CAN_OK)
    Serial.println("MCP2515 Initialized Successfully!");
    Serial.println("Error Initializing MCP2515... Permanent failure!  Check your code & connections");

  // Allow all Standard IDs
  CAN0.init_Mask(0,0x00000000);                // Init first mask...
  CAN0.init_Filt(0,0x00000000);                // Init first filter...
  CAN0.init_Filt(1,0x00000000);                // Init second filter...
  // Allow all Extended IDs
  CAN0.init_Mask(1,0x80000000);                // Init second mask...
  CAN0.init_Filt(2,0x80000000);                // Init third filter...
  CAN0.init_Filt(3,0x80000000);                // Init fourth filter...
  CAN0.init_Filt(4,0x80000000);                // Init fifth filter...
  CAN0.init_Filt(5,0x80000000);                // Init sixth filter...

//#if standard == 1
//  // Standard ID Filters
//  CAN0.init_Mask(0,0x7F00000);                // Init first mask...
//  CAN0.init_Filt(0,0x7DF0000);                // Init first filter...
//  CAN0.init_Filt(1,0x7E10000);                // Init second filter...
//  CAN0.init_Mask(1,0x7F00000);                // Init second mask...
//  CAN0.init_Filt(2,0x7DF0000);                // Init third filter...
//  CAN0.init_Filt(3,0x7E10000);                // Init fourth filter...
//  CAN0.init_Filt(4,0x7DF0000);                // Init fifth filter...
//  CAN0.init_Filt(5,0x7E10000);                // Init sixth filter...
//  // Extended ID Filters
//  CAN0.init_Mask(0,0x90FF0000);                // Init first mask...
//  CAN0.init_Filt(0,0x90DA0000);                // Init first filter...
//  CAN0.init_Filt(1,0x90DB0000);                // Init second filter...
//  CAN0.init_Mask(1,0x90FF0000);                // Init second mask...
//  CAN0.init_Filt(2,0x90DA0000);                // Init third filter...
//  CAN0.init_Filt(3,0x90DB0000);                // Init fourth filter...
//  CAN0.init_Filt(4,0x90DA0000);                // Init fifth filter...
//  CAN0.init_Filt(5,0x90DB0000);                // Init sixth filter...

  CAN0.setMode(MCP_NORMAL);                      // Set operation mode to normal so the MCP2515 sends acks to received data.

  // Having problems?  ======================================================
  // If you are not receiving any messages, uncomment the setMode line below
  // to test the wiring between the Ardunio and the protocol controller.
  // The message that this sketch sends should be instantly received.
  // ========================================================================

  pinMode(CAN0_INT, INPUT);                          // Configuring pin for /INT input
  Serial.println("Simple CAN OBD-II PID Request");

void loop(){

  if(!digitalRead(CAN0_INT)){                         // If CAN0_INT pin is low, read receive buffer
    CAN0.readMsgBuf(&rxID, &dlc, rxBuf);             // Get CAN data
    // Display received CAN data as we receive it.
    if((rxID & 0x80000000) == 0x80000000)     // Determine if ID is standard (11 bits) or extended (29 bits)
      sprintf(msgString, "Extended ID: 0x%.8lX  DLC: %1d  Data:", (rxID & 0x1FFFFFFF), dlc);
      sprintf(msgString, "Standard ID: 0x%.3lX       DLC: %1d  Data:", rxID, dlc);
    if((rxID & 0x40000000) == 0x40000000){    // Determine if message is a remote request frame.
      sprintf(msgString, " REMOTE REQUEST FRAME");
    } else {
      for(byte i = 0; i<dlc; i++){
        sprintf(msgString, " 0x%.2X", rxBuf[i]);
  /* Every 1000ms (One Second) send a request for PID 00           *
   * This PID responds back with 4 data bytes indicating the PIDs  *
   * between 0x01 and 0x20 that are supported by the vehicle.      */
  if((millis() - prevTx) >= invlTx){
    prevTx = millis();
    if(CAN0.sendMsgBuf(FUNCTIONAL_ID ,8, txData) == CAN_OK){
      Serial.println("Message Sent Successfully!");
    } else {
      Serial.println("Error Sending Message...");

The code works properly in simulation mode (I used a CAN device VN1610 using a IG_Node).
But I noticed, after CAN pin 6-14 to the OBD2 socket connection, several errors appear on the dashboard.
The errors disappear after a KL15 key-cycle.
The errors change everytime, it seems to dipend on the functional_ID is used.

Could someone help me please? Just any advice to understand why it doesn't work.
Thank you so much in advance

Sorry, I forgot a note:
I did a check for ID defined (18DB33F1 or 98DB33F1) and I noticed that '9' at the beginning of the second one is used inside function "sendMsgbuf" to send as 18DB33F1. If '1' is at the beginning of ID, when sendmsgbuf is called, it's necessary to put inside brakets the "ID_format".

CAN0.sendMsgBuf(FUNCTIONAL_ID , **1**, 8, txData) 

insted of

CAN0.sendMsgBuf(FUNCTIONAL_ID , 8, txData) 

Probably this "hack" allows to not specialized the code for each kind of sendmsg data.
Is my assumption correct?

I'm having problems using mcp2515, are you using coryjfowler's lib? I'm trying to access data through obd2. Could you share electrical schematic and code?

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.