Trouble receiving Ext IDs with example programs

[mcha-gh]

When using a setup of 2x Arduino Uno R3 + Seeed studio CAN-BUS Shield, I am having trouble receiving any messages with extended frames. I am using the example code for receive_check and send. This is the same issue as described in issue #115 among others, as I understand it.

When I perform sendMsgBuf(0x00, 0, 8, data), on my sender, my receiver will receive and print the messages transmitted. When I change this command to take a 1, signaling the ID is extended, my receiver does not pick it up and returns NO_MSG from checkReceive().

These Arduinos are brand new and the shields are brand new.

[mcha-gh]

For completion's sake I am including the send and receive codes below, as well as my source
libraries which are attached.
src.zip

This is the example send code (The sixth line from the bottom indicates that this is sending ext IDs with CAN.sendMsgBuf(0x00, 1, 8, stmp); instead of CAN.sendMsgBuf(0x00, 0, 8, stmp);, which indicates standard IDs :

// demo: CAN-BUS Shield, send data
// loovee@seeed.cc


#include <SPI.h>

#define CAN_2515
// #define CAN_2518FD

// Set SPI CS Pin according to your hardware

#if defined(SEEED_WIO_TERMINAL) && defined(CAN_2518FD)
// For Wio Terminal w/ MCP2518FD RPi Hat：
// Channel 0 SPI_CS Pin: BCM 8
// Channel 1 SPI_CS Pin: BCM 7
// Interupt Pin: BCM25
const int SPI_CS_PIN  = BCM8;
const int CAN_INT_PIN = BCM25;
#else

// For Arduino MCP2515 Hat:
// the cs pin of the version after v1.1 is default to D9
// v0.9b and v1.0 is default D10
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
#endif


#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif

void setup() {
    SERIAL_PORT_MONITOR.begin(115200);
    while(!Serial){};

    while (CAN_OK != CAN.begin(CAN_250KBPS)) {             // init can bus : baudrate = 500k
        SERIAL_PORT_MONITOR.println("CAN init fail, retry...");
        delay(100);
    }
    SERIAL_PORT_MONITOR.println("CAN init ok!");
}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
    // send data:  id = 0x00, standrad frame, data len = 8, stmp: data buf
    stmp[7] = stmp[7] + 1;
    if (stmp[7] == 100) {
        stmp[7] = 0;
        stmp[6] = stmp[6] + 1;

        if (stmp[6] == 100) {
            stmp[6] = 0;
            stmp[5] = stmp[5] + 1;
        }
    }

    CAN.sendMsgBuf(0x00, 1, 8, stmp);
    delay(100);                       // send data per 100ms
    SERIAL_PORT_MONITOR.println("CAN BUS sendMsgBuf ok!");
}

// END FILE

This is the example receive code:

// demo: CAN-BUS Shield, receive data with check mode
// send data coming to fast, such as less than 10ms, you can use this way
// loovee, 2014-6-13
#include <SPI.h>

#define CAN_2515
// #define CAN_2518FD

// Set SPI CS Pin according to your hardware

#if defined(SEEED_WIO_TERMINAL) && defined(CAN_2518FD)
// For Wio Terminal w/ MCP2518FD RPi Hat：
// Channel 0 SPI_CS Pin: BCM 8
// Channel 1 SPI_CS Pin: BCM 7
// Interupt Pin: BCM25
const int SPI_CS_PIN  = BCM8;
const int CAN_INT_PIN = BCM25;
#else

// For Arduino MCP2515 Hat:
// the cs pin of the version after v1.1 is default to D9
// v0.9b and v1.0 is default D10
const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
#endif


#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif                           

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

    while (CAN_OK != CAN.begin(CAN_250KBPS)) {             // init can bus : baudrate = 500k
        SERIAL_PORT_MONITOR.println("CAN init fail, retry...");
        delay(100);
    }
    SERIAL_PORT_MONITOR.println("CAN init ok!");
}


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

    if (CAN_MSGAVAIL == CAN.checkReceive()) {         // check if data coming
        CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf

        unsigned long canId = CAN.getCanId();

        SERIAL_PORT_MONITOR.println("-----------------------------");
        SERIAL_PORT_MONITOR.print("Get data from ID: 0x");
        SERIAL_PORT_MONITOR.println(canId, HEX);

        for (int i = 0; i < len; i++) { // print the data
            SERIAL_PORT_MONITOR.print(buf[i], HEX);
            SERIAL_PORT_MONITOR.print("\t");
        }
        SERIAL_PORT_MONITOR.println();
    }
}

/*********************************************************************************************************
    END FILE
*********************************************************************************************************/

[AZKKXL]

1: This is my hardware setup. Since I lack a CAN-BUS Shield V2, I replaced it with the XIAO ESP32S3 (https://wiki.seeedstudio.com/xiao_esp32s3_getting_started/) as the main controller and the XIAO CAN Bus Expansion Board (https://wiki.seeedstudio.com/xiao-can-bus-expansion/#introduction), which is equipped with the MCP2515 chip. I am using this as the receiver. The transmitter is the CAN-BUS Shield + Seeeduino V4.2.

2: First, I used the CAN-BUS Shield + Seeeduino V4.2 as the receiver and used the code you provided for the receiver. My setup was used as the transmitter (I wrote my own code due to the different environment) to verify your receiver code. Your receiver code is also working, and I didn’t encounter the issues you mentioned. Here’s a screenshot as proof.

3: Then, I used the CAN-BUS Shield + Seeeduino V4.2 as the transmitter and used the code you provided for the transmitter. My setup was used as the receiver (I wrote my own receiver code due to the different environment). At this point, the issue you mentioned occurred. When using the function CAN.sendMsgBuf(0x00, 1, 8, stmp), the receiver didn’t respond.

4: Solution: In CAN bus communication, the second parameter of the CAN.sendMsgBuf function is typically used to indicate the frame type. 0 usually represents a standard frame, and 1 represents an extended frame. When you changed the second parameter of CAN.sendMsgBuf from 0 to 1 in the sending code, the receiving device didn’t respond. This may be because the receiver was not correctly configured to receive extended frames. You can modify the receiver code to enable it to receive extended frames. I added the necessary code, and this solved the problem.
// Set the filter to receive extended frames
CAN.init_Mask(0, 1, 0x1FFFFFFF); // Mask 0, extended frame
CAN.init_Filt(0, 1, 0x00000000); // Filter 0, extended frame

If this method doesn't work, please let me know if further verification with the same hardware is needed.

[mcha-gh]

Thanks for getting back to me, I see that this fixes some of the issue, unfortunately it does not look like this is the full solution.

I can verify that adding in these filters will allow my receiver to receive an "ext" frame with ID = 0.

I now see that if I change the ID to anything other than 0 (for example, 0x2, 0x1182201) then the receiver will again return NO_MSG.

[AZKKXL]

Sorry, I didn't consider this properly. The issue you mentioned does indeed exist, and it's mainly related to the mask and filter settings. Below, I will show a method for setting up with random values. The following code needs to be added, and as shown in the image, you can see that the sent ID is a random value
// Configure filter to accept all standard and extended frames
CAN.init_Mask(0, 0, 0x000);
// Filter for standard frames (accept all)
CAN.init_Filt(0, 0, 0x000);
// Mask for extended frames
CAN.init_Mask(1, 1, 0x1FFFFFFF);
// Filter for extended frames (accept all)
CAN.init_Filt(1, 1, 0x0000000);

If you don't need random values but instead need a specific list of IDs to listen to, you can set it up as follows. As shown in the image, you can see that the listening is done for a specified list of IDs, and both standard frames and extended frames are successfully sent and received

Below are the modifications I made to your code for your reference

`//send
// demo: CAN-BUS Shield, send data
// loovee@seeed.cc

#include <SPI.h>

#define CAN_2515
// #define CAN_2518FD

// Set SPI CS Pin according to your hardware

#if defined(SEEED_WIO_TERMINAL) && defined(CAN_2518FD)
const int SPI_CS_PIN = BCM8;
const int CAN_INT_PIN = BCM25;
#else

const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
#endif

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif

// Define the list of standard CAN IDs to receive
const unsigned long STANDARD_CAN_IDS[] = {0x123, 0x456};
const int STANDARD_CAN_ID_COUNT = sizeof(STANDARD_CAN_IDS) / sizeof(STANDARD_CAN_IDS[0]);

// Define the list of extended CAN IDs to receive
const unsigned long EXTENDED_CAN_IDS[] = {0x1234567, 0x89ABCDE};
const int EXTENDED_CAN_ID_COUNT = sizeof(EXTENDED_CAN_IDS) / sizeof(EXTENDED_CAN_IDS[0]);

void setup() {
SERIAL_PORT_MONITOR.begin(115200);
while(!Serial){};

while (CAN_OK != CAN.begin(CAN_250KBPS)) {             // init can bus : baudrate = 500k
    SERIAL_PORT_MONITOR.println("CAN init fail, retry...");
    delay(100);
}
SERIAL_PORT_MONITOR.println("CAN init ok!");

}

unsigned char stmp[8] = {0, 0, 0, 0, 0, 0, 0, 0};
void loop() {
// send data: id = 0x00, standrad frame, data len = 8, stmp: data buf
stmp[7] = stmp[7] + 1;
if (stmp[7] == 100) {
stmp[7] = 0;
stmp[6] = stmp[6] + 1;

    if (stmp[6] == 100) {
        stmp[6] = 0;
        stmp[5] = stmp[5] + 1;
    }
}

 for (int i = 0; i < STANDARD_CAN_ID_COUNT; i++) {
  CAN.sendMsgBuf(STANDARD_CAN_IDS[i], 0, 8, stmp);//using ID List ID 
  delay(100);    
}

for (int i = 0; i < EXTENDED_CAN_ID_COUNT; i++) {
  CAN.sendMsgBuf(EXTENDED_CAN_IDS[i], 1, 8, stmp);//using ID List ID 
  delay(100);    
}

}

// END FILE

recv
#include <SPI.h>

#define CAN_2515

#if defined(SEEED_WIO_TERMINAL) && defined(CAN_2518FD)
const int SPI_CS_PIN = BCM8;
const int CAN_INT_PIN = BCM25;
#else

const int SPI_CS_PIN = 9;
const int CAN_INT_PIN = 2;
#endif

#ifdef CAN_2518FD
#include "mcp2518fd_can.h"
mcp2518fd CAN(SPI_CS_PIN); // Set CS pin
#endif

#ifdef CAN_2515
#include "mcp2515_can.h"
mcp2515_can CAN(SPI_CS_PIN); // Set CS pin
#endif

// Define the list of standard CAN IDs to receive
const unsigned long STANDARD_CAN_IDS[] = {0x123, 0x456};
const int STANDARD_CAN_ID_COUNT = sizeof(STANDARD_CAN_IDS) / sizeof(STANDARD_CAN_IDS[0]);

// Define the list of extended CAN IDs to receive
const unsigned long EXTENDED_CAN_IDS[] = {0x1234567, 0x89ABCDE};
const int EXTENDED_CAN_ID_COUNT = sizeof(EXTENDED_CAN_IDS) / sizeof(EXTENDED_CAN_IDS[0]);

void setup() {
SERIAL_PORT_MONITOR.begin(115200);
while(!Serial){};

while (CAN_OK != CAN.begin(CAN_250KBPS)) {             // init can bus : baudrate = 250k
    SERIAL_PORT_MONITOR.println("CAN init fail, retry...");
    delay(100);
}
SERIAL_PORT_MONITOR.println("CAN init ok!");

// Configure the standard frame filters
for (int i = 0; i < STANDARD_CAN_ID_COUNT; i++) {
    CAN.init_Mask(i, 0, 0x7FF); // Check all 11 bits of the standard frame
    CAN.init_Filt(i, 0, STANDARD_CAN_IDS[i]);
}

// Configure the extended frame filters
for (int i = 0; i < EXTENDED_CAN_ID_COUNT; i++) {
    CAN.init_Mask(i + STANDARD_CAN_ID_COUNT, 1, 0x1FFFFFFF); // Check all 29 bits of the extended frame
    CAN.init_Filt(i + STANDARD_CAN_ID_COUNT, 1, EXTENDED_CAN_IDS[i]);
}

}

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

if (CAN_MSGAVAIL == CAN.checkReceive()) {         // check if data coming
    CAN.readMsgBuf(&len, buf);    // read data,  len: data length, buf: data buf

    unsigned long canId = CAN.getCanId();

    // Check if it is a standard CAN ID
    for (int i = 0; i < STANDARD_CAN_ID_COUNT; i++) {
        if (canId == STANDARD_CAN_IDS[i]) {
            SERIAL_PORT_MONITOR.println("-----------------------------");
            SERIAL_PORT_MONITOR.print("Get standard data from ID: 0x");
            SERIAL_PORT_MONITOR.println(canId, HEX);

            for (int j = 0; j < len; j++) { // print the data
                SERIAL_PORT_MONITOR.print(buf[j], HEX);
                SERIAL_PORT_MONITOR.print("\t");
            }
            SERIAL_PORT_MONITOR.println();
            break;
        }
    }

    // Check if it is an extended CAN ID
    for (int i = 0; i < EXTENDED_CAN_ID_COUNT; i++) {
        if (canId == EXTENDED_CAN_IDS[i]) {
            SERIAL_PORT_MONITOR.println("-----------------------------");
            SERIAL_PORT_MONITOR.print("Get extended data from ID: 0x");
            SERIAL_PORT_MONITOR.println(canId, HEX);

            for (int j = 0; j < len; j++) { // print the data
                SERIAL_PORT_MONITOR.print(buf[j], HEX);
                SERIAL_PORT_MONITOR.print("\t");
            }
            SERIAL_PORT_MONITOR.println();
            break;
        }
    }
}

}

`
If this method doesn't work, please let me know if further verification with the same hardware is needed

[AZKKXL]

Apologies again for not paying attention to the indentation format of the code. Below, I will send the code to you in the form of a compressed file.

SendAndRecv.zip

[mcha-gh]

This looks like it works, thank you!

I wonder if this is the intent of the libraries that they will not accept extended frames without these masks and filters being set. I am inclined to believe this is a bug due to the closing remarks of issue 115. It also seems like this has been a recurring issue that many others are experiencing i.e., issue 39, issue 114, etc.

[AZKKXL]

Dear user, regarding the issue you encountered when using two Arduino Uno R3 boards paired with Seeed studio CAN - BUS Shields to receive extended frame messages, after technical analysis, it has been found that this CAN communication library requires proper configuration of masks and filters when handling extended frame messages.
In a CAN network, the message filtering mechanism plays a crucial role. It ensures that nodes only receive messages that meet specific conditions, thereby enhancing the system's operational efficiency and security. Since the identifier (ID) of an extended frame has more bits compared to that of a standard frame, appropriate configuration of masks and filters is essential to accurately filter out the messages you expect to receive.
Upon thorough review, we've identified that the oversight in providing explicit guidance on mask and filter settings for extended frames in the previous routine might have contributed to the issues you faced. We sincerely apologize for any inconvenience this may have caused.
We've now proactively updated the routine. It not only includes detailed examples for sending and receiving extended frames but also offers clear instructions on how to correctly configure masks and filters. We're confident that these updates will effectively resolve the problems you encountered with extended frames.
If you have any further thoughts or concerns regarding this issue, or if you come across any new problems, we encourage you to submit an issue on GitHub. Your feedback is invaluable in helping us refine and enhance our library. Thank you for bringing this to our attention.

[mcha-gh]

Thank you Yuan, your help and responsiveness has been incredible!