为什么canlib表现得这么慢？

Question

这可能是胡说八道，但这种行为把我难倒了。

我正在编写一个嵌入式电机控制器的控制图形用户界面，通过CAN与PC通信(使用kvaser LEAF2)。根据Kvaser Can King的说法，总线是1兆比特/秒，并利用了大约29%的总线。问题是，当我向嵌入式设备发送对特定数据片段的请求时，在它显示在我的gui上之前，会有大约10到15秒的长时间延迟。延迟开始很小，如果我在启动时请求数据，它只有1秒左右。如果我让它静置几分钟

我写的第一个gui是使用tkinter用python编写的。我发现性能是边缘的:这意味着在我开始处理延迟问题之前，我可以对CAN消息进行少量的处理。我想这是因为python是一种解释型语言，也许它太慢了，跟不上。所以我用C#写了一个新的图形用户界面，因为它是一种编译语言，应该运行得更快。但我也遇到了同样的问题。在不同的主机，不同的嵌入式开发板和不同的kvaser上尝试过，同样的问题。

有人知道可能会发生什么吗？

所以我的python线程方法看起来像这样：

def can_thread():  
    global finished  
    global can_log_name  
    global temp_log_name  
    global yoko_log_name  
    global time_last  
    global logging  
    global start_time  
    global TU1_active  
    global TU2_active  
    global TV1_active  
    global TV2_active  
    global TW1_active  
    global TW2_active  
    global Tcool_active  
    global state_dic  
    global printlog  
    global yoko_cmd  
    global can_timeout  
    global missed_messages  
    finished = None  
    start_time = time()  
    time_last_1Hz = time()  
    time_last_4Hz = time()  
    while not finished:  
        time_now = time()  
        elapsed_time_1Hz = time_now - time_last_1Hz  
        elapsed_time_4Hz = time_now - time_last_4Hz  
        finished = get_can_message()  
        if elapsed_time_1Hz > 1:  
            if logging == True:  
                if not temp_log_name == None:  
                    tempText = str(text_time)+ "," + \  
                               TU1_temp["text"] + "," + \  
                               TU2_temp["text"] + "," + \  
                               TV1_temp["text"] + "," + \  
                               TV2_temp["text"] + "," + \  
                               TW1_temp["text"] + "," + \  
                               TW2_temp["text"] + "," + \  
                               ULPF_current["text"] + "," + \  
                               VLPF_current["text"] + "," + \  
                               WLPF_current["text"] + "," + \  
                               Tcool_temp["text"]  
                    f = open(temp_log_name, "a")  
                    f.write(tempText + "\n")  
                    f.close  
                if not yoko_log_name == None:  
                    f = open(yoko_log_name, "a")  
                    f.write(str(text_time)+ "," + yoko_cmd)  
                    f.close  
            time_last_1Hz = time_now  
        if elapsed_time_4Hz > 0.25:  
            while incoming_message_queue.qsize() > 0:  
                frame = incoming_message_queue.get()  
                if frame.id == broadcast_frame_id + get_id():  
                    broadcast_frame(frame)  
                    None  
                elif frame.id == UTA2_frame_id + get_id():  
                    UTA2_frame(frame)  
                    None  
                elif frame.id == volt_cur_pow_frame_id + get_id():  
                    volt_curr_pwr_frame(frame)  
                    None  
                elif frame.id == state_faults_frame_id + get_id():  
                    state_faults_frame(frame)  
                    None  
                else:  
                    None  
            if missed_messages > 2:  
                can_inidicator_lbl["bg"] = "red"  
                can_inidicator_lbl["text"] = "CAN Timeout"  
            else:  
                can_inidicator_lbl["bg"] = "green"  
                can_inidicator_lbl["text"] = "CAN Traffic detected"  
            elapsed_time_4Hz = time_now  
        while outgoing_message_queue.qsize() > 0:  
            msg = outgoing_message_queue.get()  
            cn.ch.write(msg)  

我的C#线程方法如下所示：

private void CanThread()
        {
            while(m_OkToRunThread)
            {
                try
                {
                    var result = m_CanMessage.ReadCanBusWithWait(m_canHandle, CAN_TIMEOUT);
                    if(result == Canlib.canStatus.canOK)
                    {
                        m_canTimeoutCount = 0;
                        m_canTimedOut = false;
                        CanMessageEventArgs e = new CanMessageEventArgs();
                        e.Message = m_CanMessage;
                        e.CanTimeOut = m_canTimedOut;
                        OnMessageReceived(e);
                    }
                    else if(result == Canlib.canStatus.canERR_NOMSG)
                    {
                        m_canTimeoutCount++;
                        if(m_canTimeoutCount > ALLOWED_TIMED_OUT_MESSAGES)
                        {
                            m_canTimedOut = true;
                            CanMessageEventArgs e = new CanMessageEventArgs();
                            e.Message = m_CanMessage;
                            e.CanTimeOut = m_canTimedOut;
                            OnMessageReceived(e);
                        }
                    }
                    else
                    {
                        m_OkToRunThread = false;
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                    //m_OkToRunThread = false;
                }
            }
        }

Answer 1

因此，就像在软件行业中的许多次一样，我找到了导致我的代码出现所有问题的人，他就是我。

为了通知用户嵌入式处理器仍在工作/未冻结，我在每次收到原始CAN消息时都在GUI上打印它。

我切换到C#中的"CAN检测到/ CAN超时“指示，所有的滞后问题都消失了。CAN消息的ToString方法并不简单，每次消息以1Mb/s总线29%的负载传入时，调用该方法需要进行大量处理。它就在公交车后面，延迟是因为缓冲。

请注意，此解决方案在python中不起作用。python的解释特性跟不上这样的速度。我首先尝试了python中的解决方案，但没有成功，这就是为什么我花了这么长时间才在C#中找到它。