SocketCAN ACK?

[richcj10]

Is there a way to turn off a listen only mode and ack frames for desk debugging?

[jgressmann]

You can re-init the device to switch between listen only and regular operating mode. I am uncertain if listen only is fully implemented in the firmware, though.On 26. Jan 2026, at 11:01, Richard C Johnson ***@***.***> wrote:richcj10 created an issue (jgressmann/supercan#20) Is there a way to turn off a listen only mode and ack frames for desk debugging? —Reply to this email directly, view it on GitHub, or unsubscribe.You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>

[richcj10]

Whats the process in doing it? In the mode it's in, it doesn't seem to Ack anything. I tried a few can IDs and it never responds to it. But the frames it does send my DUT will ack.

[richcj10]

I am using can++.

[jgressmann]

You just need to take the CAN interface online. Default mode will ACK any CAN frame on the bus. Thus, if your device is sending frames, you should be getting them on the interface. What is the command line you are using to bring up the interface online Linux?On 26. Jan 2026, at 19:47, Richard C Johnson ***@***.***> wrote:richcj10 left a comment (jgressmann/supercan#20) I am using can++. —Reply to this email directly, view it on GitHub, or unsubscribe.You are receiving this because you commented.Message ID: ***@***.***>

[jgressmann]

On, I see, you are on Windows then.I am not sure how exactly can++ sets up the bus as it is closed source. You could try the demo app that ships with the windows parts of the SuperCAN software package. It’s a cli application that you can use to dump the can traffic received by your interface. Just be sure, your issue is that you are not seeing CAN frames in can++ although your DUT is trying to send them?On 26. Jan 2026, at 19:47, Richard C Johnson ***@***.***> wrote:richcj10 left a comment (jgressmann/supercan#20) I am using can++. —Reply to this email directly, view it on GitHub, or unsubscribe.You are receiving this because you commented.Message ID: ***@***.***>

[TDahlmann]

Here is the code for setting up supercan in can++. It just follows Jean's example code and always was acking frames as far I remember. Is there a parameter for listen only mode? Sorry for posting raw code:

 // setup device
        {
            unsigned cmd_count = 0;
            PUCHAR cmd_tx_ptr = g_cmd_ctx[chNum].tx_buffer;

            // clear features
            struct sc_msg_features* feat = (struct sc_msg_features*)cmd_tx_ptr;
            memset(feat, 0, sizeof(*feat));
            feat->id = SC_MSG_FEATURES;
            feat->len = sizeof(*feat);
            feat->op = SC_FEAT_OP_CLEAR;
            cmd_tx_ptr += feat->len;
            ++cmd_count;

            feat = (struct sc_msg_features*)cmd_tx_ptr;
            memset(feat, 0, sizeof(*feat));
            feat->id = SC_MSG_FEATURES;
            feat->len = sizeof(*feat);
            feat->op = SC_FEAT_OP_OR;
            // try to enable CAN-FD and TXR
            feat->arg = (dev_info.feat_perm | dev_info.feat_conf) &
                ((fdf ? SC_FEATURE_FLAG_FDF : 0) | SC_FEATURE_FLAG_TXR);
            cmd_tx_ptr += feat->len;
            ++cmd_count;


            // set nominal bittiming
            struct sc_msg_bittiming* bt = (struct sc_msg_bittiming*)cmd_tx_ptr;
            memset(bt, 0, sizeof(*bt));
            bt->id = SC_MSG_NM_BITTIMING;
            bt->len = sizeof(*bt);
            bt->brp = device[chNum]->dev_to_host16(nominal_settings.brp);
            bt->sjw = nominal_settings.sjw;
            bt->tseg1 = device[chNum]->dev_to_host16(nominal_settings.tseg1);
            bt->tseg2 = nominal_settings.tseg2;
            cmd_tx_ptr += bt->len;
            ++cmd_count;

            if (fdf && ((dev_info.feat_perm | dev_info.feat_conf) & SC_FEATURE_FLAG_FDF)) {
                // CAN-FD capable & configured -> set data bitrate

                bt = (struct sc_msg_bittiming*)cmd_tx_ptr;
                memset(bt, 0, sizeof(*bt));
                bt->id = SC_MSG_DT_BITTIMING;
                bt->len = sizeof(*bt);
                bt->brp = device[chNum]->dev_to_host16(data_settings.brp);
                bt->sjw = data_settings.sjw;
                bt->tseg1 = device[chNum]->dev_to_host16(data_settings.tseg1);
                bt->tseg2 = data_settings.tseg2;
                cmd_tx_ptr += bt->len;
                ++cmd_count;
            }

            struct sc_msg_config* bus_on = (struct sc_msg_config*)cmd_tx_ptr;
            memset(bus_on, 0, sizeof(*bus_on));
            bus_on->id = SC_MSG_BUS;
            bus_on->len = sizeof(*bus_on);
            bus_on->arg = device[chNum]->dev_to_host16(1);
            cmd_tx_ptr += bus_on->len;
            ++cmd_count;

            uint16_t rep_len;
            error = sc_cmd_ctx_run(&g_cmd_ctx[chNum], (uint16_t)(cmd_tx_ptr - g_cmd_ctx[chNum].tx_buffer), &rep_len, CMD_TIMEOUT_MS);
            if (error) {
                goto Exit;
            }


            if (rep_len < cmd_count * sizeof(struct sc_msg_error)) {
                //fprintf(stderr, "failed to setup device\n");
                error = -1;
                goto Exit;
            }

            struct sc_msg_error* error_msgs = (struct sc_msg_error*)g_cmd_ctx[chNum].rx_buffer;
            for (unsigned i = 0; i < cmd_count; ++i) {
                struct sc_msg_error* error_msg = &error_msgs[i];
                if (SC_ERROR_NONE != error_msg->error) {
                    //fprintf(stderr, "cmd index %u failed: %d\n", i, error_msg->error);
                    error = -1;
                    goto Exit;
                }
            }
        }

        error = sc_can_stream_init(device[chNum], can_info.msg_buffer_size, &(can_state[chNum]), process_can, -1, &(sc_can_stream[chNum]));
        if (error) {
            goto Exit;
        }