Basler acA720-290gm相机修改曝光时间后RetrieveResult超时问题

核心问题排查 #

结合代码和现象来看，超时及相机无响应的问题，主要和参数修改时机冲突、全局变量竞态、异常后未重置采集状态这几个点有关，以下是具体问题和修复方案：

问题点1：曝光参数修改未同步采集状态 #

相机在StartGrabbing状态下直接修改曝光时间，部分Basler型号会出现内部帧同步异常，尤其是使用GrabStrategy_LatestImageOnly策略时，参数变更会打断当前采集流程，导致后续RetrieveResult超时。

问题点2：全局变量操作无锁保护 #

代码中直接读写exposure_auto_req、exposure_time_raw_req等全局变量，多线程场景下会出现竞态，导致相机收到混乱的配置指令，进而进入无响应状态。

问题点3：超时/采集失败后未重置采集流程 #

出现TimeoutException或采集失败时，仅打印错误却未停止并重启采集，相机可能陷入半挂起状态，后续参数修改和采集均无法正常执行。

问题点4：GrabResult资源管理不当 #

当image_mutex.try_lock()失败时，ptrGrabResult的缓冲区未被正确处理，长期运行会导致相机内存耗尽，引发各类异常。

修复后的核心代码 #

void process_pylon(Pylon::String_t serial_number, int64_t width, int64_t height, int64_t packet_size, int64_t inter_packet_delay) {
    try {
        Pylon::CBaslerUniversalInstantCamera camera;
        Pylon::CTlFactory& tlFactory = Pylon::CTlFactory::GetInstance();
        Pylon::CDeviceInfo info;
        Pylon::DeviceInfoList_t filter;
        info.SetSerialNumber(serial_number);
        filter.push_back(info);
        Pylon::DeviceInfoList_t devices;

        // 全局参数操作锁
        std::mutex param_mutex;

        while (1) {
            try {
                while (1) {
                    if (tlFactory.EnumerateDevices(devices, filter) > 0) {
                        g_print("相机已连接。\n");
                        break;
                    }
                    else {
                        g_printerr("相机未连接。\n");
                        Pylon::WaitObject::Sleep(5000);
                    }
                }

                g_print("挂载相机。\n");
                camera.Attach(tlFactory.CreateFirstDevice(info));

                g_print("打开相机。\n");
                camera.Open();

                g_print("设置宽度: %li\n", width);
                camera.Width.TrySetValue(width);

                g_print("设置高度: %li\n", height);
                camera.Height.TrySetValue(height);

                g_print("设置GevSCPSPacketSize(数据包大小): %li\n", packet_size);
                camera.GevSCPSPacketSize.TrySetValue(packet_size);

                g_print("设置GevSCPD(包间延迟): %li\n", inter_packet_delay);
                camera.GevSCPD.TrySetValue(inter_packet_delay);

                // 初始化参数更新标志
                bool exposure_auto_set = true;
                bool exposure_time_raw_set = true;
                bool gain_auto_set = true;
                bool gain_raw_set = true;

                Pylon::CGrabResultPtr ptrGrabResult;

                while (1) {
                    bool need_restart_grab = false;

                    // 加锁读取全局参数，避免竞态
                    std::lock_guard<std::mutex> lock(param_mutex);
                    int32_t epics_exposure_auto_req = exposure_auto_req;
                    int32_t epics_exposure_time_raw_req = exposure_time_raw_req;
                    int32_t epics_gain_auto_req = gain_auto_req;
                    int32_t epics_gain_raw_req = gain_raw_req;

                    // 处理自动曝光设置
                    if (exposure_auto_set) {
                        g_print("设置自动曝光: %i\n", epics_exposure_auto_req);
                        camera.ExposureAuto.SetIntValue((int64_t)epics_exposure_auto_req);
                        exposure_auto_set = false;
                        need_restart_grab = true;
                    }
                    exposure_auto = camera.ExposureAuto.GetIntValue();

                    // 处理曝光时间设置
                    if (exposure_time_raw_set) {
                        g_print("设置曝光时间: %i\n", epics_exposure_time_raw_req);
                        camera.ExposureTimeRaw.TrySetValue((int64_t)epics_exposure_time_raw_req, Pylon::IntegerValueCorrection_Nearest);
                        exposure_time_raw_set = false;
                        need_restart_grab = true;
                    }
                    exposure_time_raw = camera.ExposureTimeRaw.GetValue();

                    // 处理自动增益设置
                    if (gain_auto_set) {
                        g_print("设置自动增益: %i\n", epics_gain_auto_req);
                        camera.GainAuto.SetIntValue((int64_t)epics_gain_auto_req);
                        gain_auto_set = false;
                        need_restart_grab = true;
                    }
                    gain_auto = camera.GainAuto.GetIntValue();

                    // 处理增益设置
                    if (gain_raw_set) {
                        g_print("设置增益: %i\n", epics_gain_raw_req);
                        camera.GainRaw.TrySetValue((int64_t)epics_gain_raw_req, Pylon::IntegerValueCorrection_Nearest);
                        gain_raw_set = false;
                        need_restart_grab = true;
                    }
                    gain_raw = camera.GainRaw.GetValue();

                    // 修改关键参数后重启采集，确保参数生效
                    if (need_restart_grab) {
                        if (camera.IsGrabbing()) {
                            camera.StopGrabbing();
                        }
                        camera.StartGrabbing(Pylon::GrabStrategy_LatestImageOnly);
                    }

                    try {
                        camera.RetrieveResult((unsigned int)timeout_ms, ptrGrabResult, Pylon::TimeoutHandling_ThrowException);
                        if (ptrGrabResult->GrabSucceeded()) {
                            std::lock_guard<std::mutex> img_lock(image_mutex);
                            image.AttachGrabResultBuffer(ptrGrabResult);
                        }
                        else {
                            g_printerr("采集失败。\n");
                            g_printerr("%s\n", ptrGrabResult->GetErrorDescription().c_str());
                            // 采集失败时重置采集流程
                            camera.StopGrabbing();
                            camera.StartGrabbing(Pylon::GrabStrategy_LatestImageOnly);
                        }
                    }
                    catch (const Pylon::TimeoutException& e) {
                        g_printerr("%s\n", e.GetDescription());
                        // 超时后强制重启采集，重置相机状态
                        camera.StopGrabbing();
                        camera.StartGrabbing(Pylon::GrabStrategy_LatestImageOnly);
                        // 重置参数标志，确保参数重新同步
                        exposure_auto_set = true;
                        exposure_time_raw_set = true;
                        gain_auto_set = true;
                        gain_raw_set = true;
                    }
                }
            }
            catch (const Pylon::GenericException& e) {
                Pylon::WaitObject::Sleep(1000);

                if (camera.IsCameraDeviceRemoved()) {
                    g_printerr("相机连接已丢失。\n");
                    camera.DestroyDevice();
                }
                else {
                    g_printerr("%s\n", e.GetDescription());
                    // 异常时停止采集，避免无效状态
                    if (camera.IsGrabbing()) {
                        camera.StopGrabbing();
                    }
                }
            }
        }
    }
    catch (const Pylon::GenericException& e) {
        g_printerr("发生异常。\n");
        g_printerr("%s\n", e.GetDescription());
        exit(-1);
    }
}

额外优化建议 #

• 参数合法性校验：设置曝光时间前，通过camera.ExposureTimeRaw.GetMin()和GetMax()验证输入值，避免非法参数导致相机异常。
• 调整超时时间：将timeout_ms设为曝光时间 + 100ms，给相机足够的帧处理缓冲时间。
• 启用心跳机制：通过camera.GevHeartbeatTimeout设置合理的心跳超时，及时检测相机连接状态。
• 减少参数修改频率：非实时场景下降低参数调整频率，减少相机内部状态切换压力。

内容的提问来源于stack exchange，提问作者Patrick