Segmentation fault (core dump) after grabbing images using 59 gige cameras

[chentongwilliam]

Describe what you want to implement and what the issue & the steps to reproduce it are:

Hello,
I am developing an application for large-scale image acquisition with Basler GigE cameras (model: a2A3840-13gcBAS). The goal is to grab images from all cameras (typically each camera grabs 1–6 images per run, using .GrabOne()), with all cameras connected via a network switch to a single physical Ubuntu machine.

Everything works as expected during image acquisition:

• All images can be grabbed from each camera successfully and saved.

However, after the acquisition is complete and the program exits (after attempting to release/close all resources), I very frequently encounter:
Segmentation fault (core dumped)
There is no other Python exception or error message. This happens right after the script finishes, never during image grabbing.

---

Is your camera operational in Basler pylon viewer on your platform?

• No
  I cannot see or open the cameras in pylon viewer, but all cameras are visible in the pylon IP configurator tool.

---

Steps to reproduce

1. Connect 59 Basler a2A3840-13gcBAS cameras to the same physical PC via a network switch.

2. For each camera, open it, and grab 1–6 images using .GrabOne(), save each image.

3. After all images are captured and all cameras are (supposedly) released/closed using .Close() and deleted, the script exits.

4. Observe:

   • All images are correctly captured and saved
   • At the end of the script (program exit), a segmentation fault (Segmentation fault (core dumped)) frequently occurs.

5. This happens regardless of how many times .Close() or del is called for camera objects; no other Python exception is raised.

---

Code sample

import cv2
from pypylon import pylon
import os
import traceback
from datetime import datetime

def find_basler_cameras():
    devices = pylon.TlFactory.GetInstance().EnumerateDevices()
    return devices

def main():
    export_dir = "/home/test"
    converter = pylon.ImageFormatConverter()
    converter.OutputPixelFormat = pylon.PixelType_BGR8packed
    converter.OutputBitAlignment = pylon.OutputBitAlignment_MsbAligned
    
    basler_devices = find_basler_cameras()
    if len(basler_devices) == 0:
        print("no camera detected!")
    else:
        print(f"{len(basler_devices)} cameras detected")
    # Create an array of instant cameras for the found devices and avoid exceeding a maximum number of devices.
    basler_cameras = pylon.InstantCameraArray(min(len(basler_devices), 100))

    cam_dict = {}
    grab_record_dict = dict()

    for i, camera in enumerate(basler_cameras):
        camera.Attach(pylon.TlFactory.GetInstance().CreateDevice(basler_devices[i]))
        serial_num = camera.GetDeviceInfo().GetSerialNumber()
        cam_model = camera.GetDeviceInfo().GetModelName()

        print(f"{i}: {serial_num}: {cam_model}")
        camera.Open()
        camera.PixelFormat.Value = "BayerRG8"
        cam_dict[serial_num] = {"cam": camera}
        grab_record_dict[serial_num] = 0
    
    now = datetime.now()
    nowstring = now.strftime("%Y%m%d_%H%M%S")
    export_dir_cams = os.path.join(export_dir, f"{nowstring}")
    os.makedirs(export_dir_cams, exist_ok=True)

    for num, cam_info in cam_dict.items():
        cam = cam_info["cam"]
        et = 50000
        for et in [30000, 50000, 80000]:
            cam.ExposureTime.Value = et
            result = cam.GrabOne(5000)
            if result.GrabSucceeded():
                image = converter.Convert(result)
                img = image.GetArray()
                img_name = f"{num}_et{et}.jpg"
                cv2.imwrite(os.path.join(export_dir_cams, img_name), img)
                grab_record_dict[num] += 1

        if cam.IsOpen():
            cam.Close()
    
    # clean up (with and without are the same)
    cam_dict.clear()
    del cam_dict
    del basler_cameras
    import gc; 
        gc.collect(); 
    time.sleep(0.1)
  
main()
# (Segmentation fault occurs here, after script ends)

---

What I have tried

• Increased ulimit -n to 4096.
• Explicitly called .Close() and del for all camera objects and the InstantCameraArray.
• Used gc.collect() and added time.sleep() to allow resource cleanup.
• No Python-level exception or error is raised; only segmentation fault after script exit.
• All image acquisition operations work fine and images are saved correctly.

---

Additional notes

• Each run is single-threaded (not multi-threaded or multi-process).
• Each camera only grabs a few images per session.
• Cameras are visible in pylon IP Configurator but not visible in pylon Viewer.
• No other user-space process is using the cameras.

---

Questions

• Is this a known resource management issue when using large numbers of cameras?
• Are there recommended practices / code for robust image capture using large numbers of cameras with pypylon?
• Could the network topology (all cameras via one switch) or pylon viewer detection issue be related to the segmentation fault?
• Is there a workaround or patch for this problem, or is there an upper limit for cameras per process?

---

Thank you for your support and advice!

---

Is your camera operational in Basler pylon viewer on your platform

No

Hardware setup used

• Platform: Physical machine (not a VM, not docker)
• CPU: Intel Core i5-14600KF ×20
• RAM: 32GB
• OS: Ubuntu 22.04 LTS
• Python: 3.10 (miniconda)
• pylon: 8.0.1-16188
• pypylon: 4.1.0
• Cameras: 59x Basler a2A3840-13gcBAS (GigE)
• Cameras connection: All cameras are connected to a netgear switch (PoE), which is connected to the PC via ethernet.

Camera(s) used

Basler a2A3840-13gcBAS (40378431)
p=vg4_imx334c_bas/s=r/v=2.4.2/i=8208.11/h=02e36ab
Basler a2A3840-13gcBAS (40439340)
p=vg4_imx334c_bas/s=r/v=2.4.2/i=8208.11/h=02e36ab
Basler a2A3840-13gcBAS (40444654)
p=vg4_imx334c_bas/s=r/v=2.4.2/i=8208.11/h=02e36ab
Basler a2A3840-13gcBAS (40604424)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604425)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604427)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604428)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604429)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604430)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604431)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604432)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604434)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604435)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604437)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604438)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604441)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604442)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604443)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604444)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604445)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604446)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604447)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604449)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604450)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604451)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604454)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604456)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604457)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604459)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604460)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604462)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604464)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604468)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604470)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604471)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604781)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604785)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40604786)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605112)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605115)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605116)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605117)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605118)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605119)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605121)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605123)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605124)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605125)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605127)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605128)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605130)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605131)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605132)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605133)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605134)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605135)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605140)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605141)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35
Basler a2A3840-13gcBAS (40605149)
p=vg4b_imx334c_bas/s=r/v=2.5.1/i=9421.6/h=e7c7a35

Runtime information:

python: 3.10.16 (main, Dec 11 2024, 16:24:50) [GCC 11.2.0]
platform: linux/x86_64/6.8.0-59-generic
pypylon: 4.1.0 / 9.0.3.215

[thiesmoeller]

Hi @chentongwilliam,

you trigger an issue with the pypylon version that you use because
the way you capture is not very efficient.

Opening/Closing devices
GrabOne ( start image acquisition - get only one image - stop image acquisition )

are all computationally expensive operations.

See here for a slightly modified version, that

• uses the InstantCameraArray to handle all cameras from a central point
• configures all cameras to use SW Trigger
• starts all cameras
• sets the exposuretime and triggers one image and captures it

import cv2
from pypylon import pylon
import os
import time
import traceback
from datetime import datetime


def find_basler_cameras():
    devices = pylon.TlFactory.GetInstance().EnumerateDevices()
    return devices


def configure_camera_for_software_trigger(camera):
    """Configure camera for software triggering"""
    camera.TriggerSelector.Value = "FrameStart"
    camera.TriggerMode.Value = "On"
    camera.TriggerSource.Value = "Software"
    camera.AcquisitionMode.Value = "Continuous"


def main():
    export_dir = "/home/test"
    converter = pylon.ImageFormatConverter()
    converter.OutputPixelFormat = pylon.PixelType_BGR8packed
    converter.OutputBitAlignment = pylon.OutputBitAlignment_MsbAligned

    basler_devices = find_basler_cameras()
    if len(basler_devices) == 0:
        print("no camera detected!")
        return
    else:
        print(f"{len(basler_devices)} cameras detected")

    # Create an array of instant cameras for the found devices
    basler_cameras = pylon.InstantCameraArray(min(len(basler_devices), 100))

    grab_record_dict = dict()

    try:
        # Initialize and configure cameras
        for i, camera in enumerate(basler_cameras):
            camera.Attach(pylon.TlFactory.GetInstance().CreateDevice(basler_devices[i]))
            serial_num = camera.GetDeviceInfo().GetSerialNumber()
            cam_model = camera.GetDeviceInfo().GetModelName()

            print(f"{i}: {serial_num}: {cam_model}")
            camera.Open()

            # Configure camera
            camera.PixelFormat.Value = "BayerRG8"
            configure_camera_for_software_trigger(camera)

            grab_record_dict[serial_num] = 0

        # Create export directory
        now = datetime.now()
        nowstring = now.strftime("%Y%m%d_%H%M%S")
        export_dir_cams = os.path.join(export_dir, f"{nowstring}")
        os.makedirs(export_dir_cams, exist_ok=True)

        # Start grabbing on all cameras
        print("Starting grabbing on all cameras...")
        basler_cameras.StartGrabbing(pylon.GrabStrategy_OneByOne)

        exposure_times = [30000, 50000, 80000]

        # For each camera, capture images with different exposure times
        for i, cam in enumerate(basler_cameras):
            serial_num = cam.GetDeviceInfo().GetSerialNumber()
            print(f"Capturing images from camera {serial_num} (index {i})")

            for et in exposure_times:
                try:
                    # Set exposure time
                    cam.ExposureTime.Value = et
                    print(f"  Setting exposure time to {et}µs")

                    # Wait for camera to be ready for the next trigger
                    timeout_ms = 5000
                    start_time = time.time()
                    cam.AcquisitionStatusSelector.Value = "FrameTriggerWait"
                    # Get the acquisition status
                    isWaitingForFrameStart = cam.AcquisitionStatus.Value
                    while not isWaitingForFrameStart:
                            time.sleep(0.001)  # 1ms sleep
                            if (time.time() - start_time) * 1000 > timeout_ms:
                                raise TimeoutError(
                                    f"Timeout waiting for trigger ready on camera {serial_num}, status: {cam.TriggerStatus.Value}"
                                )

                    # Execute software trigger
                    cam.TriggerSoftware.Execute()

                    # Wait for image with timeout using context manager
                    with basler_cameras.RetrieveResult(
                        5000, pylon.TimeoutHandling_ThrowException
                    ) as grab_result:
                        if grab_result.GrabSucceeded():
                            # Check if this result is from the current camera
                            if grab_result.GetCameraContext() == i:
                                image = converter.Convert(grab_result)
                                img = image.GetArray()
                                img_name = f"{serial_num}_et{et}.jpg"
                                cv2.imwrite(
                                    os.path.join(export_dir_cams, img_name), img
                                )
                                grab_record_dict[serial_num] += 1
                                print(f"    Captured {img_name}")
                            else:
                                print(
                                    f"    Received image from different camera, retrying..."
                                )
                                # Continue to next iteration - context manager will handle cleanup
                                continue
                        else:
                            print(
                                f"    Failed to grab image with ET {et}: {grab_result.GetErrorCode()}"
                            )

                except Exception as e:
                    print(f"    Error capturing image with ET {et}: {e}")
                    continue

    except Exception as e:
        print(f"Error occurred: {e}")
        traceback.print_exc()

    finally:
        # Stop grabbing
        if basler_cameras.IsGrabbing():
            basler_cameras.StopGrabbing()
            print("Stopped grabbing")

        # Close cameras
        for i, cam in enumerate(basler_cameras):
            if cam.IsOpen():
                serial_num = cam.GetDeviceInfo().GetSerialNumber()
                cam.Close()
                print(f"Closed camera {serial_num}")

        # Clean up
        grab_record_dict.clear()
        del grab_record_dict
        del basler_cameras
        import gc

        gc.collect()
        time.sleep(0.1)

        print("Cleanup completed")


if __name__ == "__main__":
    main()

The upcoming version pypylon 4.2.0 is more robust even with not efficient programming

[chentongwilliam]

Hi @thiesmoeller ，

Thank you very much for your reply and for sharing the improved example code.

I have tested your suggested approach with my setup:

• With pypylon 4.1.0:
  The code is indeed more efficient than my previous approach. However, the same issue persists: after the script finishes (even with your improved code), a segmentation fault (core dumped) still occurs at the end of execution.

• With pypylon 4.2.0rc2:
  I also tried your code. Some cameras reported errors such as
  Error capturing image with ET 150000: Node not existing (file 'genicam_wrap.cpp', line 16822)
  but even with this version, the segmentation fault at the end of the script still occurs.

Do you have any effective solution for this segmentation fault issue, or any recommended cleanup/resource management strategies to prevent it?

Additionally, if there are more efficient or robust methods for large-scale multi-camera image acquisition, I would be very grateful for your advice. For example, is it recommended to group cameras and trigger a few at a time (e.g., batches of 3 cameras in parallel), or use multi-threading or multi-processing approaches?
I have experimented with threading in Python, but so far have not managed to make it stable. That’s why I initially settled for a sequential, one-by-one approach, which, although not efficient, is the most reliable method I have found for ensuring all cameras return images.

If you have any best-practice recommendations or sample code for high-channel-count, high-stability image capture (even if it involves more advanced resource management or architecture), I would greatly appreciate it!

Thanks again for your support.

Hi @chentongwilliam,

you trigger an issue with the pypylon version that you use because the way you capture is not very efficient.

Opening/Closing devices GrabOne ( start image acquisition - get only one image - stop image acquisition )

are all computationally expensive operations.

See here for a slightly modified version, that

* uses the InstantCameraArray to handle all cameras from a central point

* configures all cameras to use SW Trigger

* starts all cameras

* sets the exposuretime and triggers one image and captures it

import cv2
from pypylon import pylon
import os
import time
import traceback
from datetime import datetime

def find_basler_cameras():
devices = pylon.TlFactory.GetInstance().EnumerateDevices()
return devices

def configure_camera_for_software_trigger(camera):
"""Configure camera for software triggering"""
camera.TriggerSelector.Value = "FrameStart"
camera.TriggerMode.Value = "On"
camera.TriggerSource.Value = "Software"
camera.AcquisitionMode.Value = "Continuous"

def main():
export_dir = "/home/test"
converter = pylon.ImageFormatConverter()
converter.OutputPixelFormat = pylon.PixelType_BGR8packed
converter.OutputBitAlignment = pylon.OutputBitAlignment_MsbAligned

basler_devices = find_basler_cameras()
if len(basler_devices) == 0:
    print("no camera detected!")
    return
else:
    print(f"{len(basler_devices)} cameras detected")

# Create an array of instant cameras for the found devices
basler_cameras = pylon.InstantCameraArray(min(len(basler_devices), 100))

grab_record_dict = dict()

try:
    # Initialize and configure cameras
    for i, camera in enumerate(basler_cameras):
        camera.Attach(pylon.TlFactory.GetInstance().CreateDevice(basler_devices[i]))
        serial_num = camera.GetDeviceInfo().GetSerialNumber()
        cam_model = camera.GetDeviceInfo().GetModelName()

        print(f"{i}: {serial_num}: {cam_model}")
        camera.Open()

        # Configure camera
        camera.PixelFormat.Value = "BayerRG8"
        configure_camera_for_software_trigger(camera)

        grab_record_dict[serial_num] = 0

    # Create export directory
    now = datetime.now()
    nowstring = now.strftime("%Y%m%d_%H%M%S")
    export_dir_cams = os.path.join(export_dir, f"{nowstring}")
    os.makedirs(export_dir_cams, exist_ok=True)

    # Start grabbing on all cameras
    print("Starting grabbing on all cameras...")
    basler_cameras.StartGrabbing(pylon.GrabStrategy_OneByOne)

    exposure_times = [30000, 50000, 80000]

    # For each camera, capture images with different exposure times
    for i, cam in enumerate(basler_cameras):
        serial_num = cam.GetDeviceInfo().GetSerialNumber()
        print(f"Capturing images from camera {serial_num} (index {i})")

        for et in exposure_times:
            try:
                # Set exposure time
                cam.ExposureTime.Value = et
                print(f"  Setting exposure time to {et}µs")

                # Wait for camera to be ready for the next trigger
                timeout_ms = 5000
                start_time = time.time()
                cam.AcquisitionStatusSelector.Value = "FrameTriggerWait"
                # Get the acquisition status
                isWaitingForFrameStart = cam.AcquisitionStatus.Value
                while not isWaitingForFrameStart:
                        time.sleep(0.001)  # 1ms sleep
                        if (time.time() - start_time) * 1000 > timeout_ms:
                            raise TimeoutError(
                                f"Timeout waiting for trigger ready on camera {serial_num}, status: {cam.TriggerStatus.Value}"
                            )

                # Execute software trigger
                cam.TriggerSoftware.Execute()

                # Wait for image with timeout using context manager
                with basler_cameras.RetrieveResult(
                    5000, pylon.TimeoutHandling_ThrowException
                ) as grab_result:
                    if grab_result.GrabSucceeded():
                        # Check if this result is from the current camera
                        if grab_result.GetCameraContext() == i:
                            image = converter.Convert(grab_result)
                            img = image.GetArray()
                            img_name = f"{serial_num}_et{et}.jpg"
                            cv2.imwrite(
                                os.path.join(export_dir_cams, img_name), img
                            )
                            grab_record_dict[serial_num] += 1
                            print(f"    Captured {img_name}")
                        else:
                            print(
                                f"    Received image from different camera, retrying..."
                            )
                            # Continue to next iteration - context manager will handle cleanup
                            continue
                    else:
                        print(
                            f"    Failed to grab image with ET {et}: {grab_result.GetErrorCode()}"
                        )

            except Exception as e:
                print(f"    Error capturing image with ET {et}: {e}")
                continue

except Exception as e:
    print(f"Error occurred: {e}")
    traceback.print_exc()

finally:
    # Stop grabbing
    if basler_cameras.IsGrabbing():
        basler_cameras.StopGrabbing()
        print("Stopped grabbing")

    # Close cameras
    for i, cam in enumerate(basler_cameras):
        if cam.IsOpen():
            serial_num = cam.GetDeviceInfo().GetSerialNumber()
            cam.Close()
            print(f"Closed camera {serial_num}")

    # Clean up
    grab_record_dict.clear()
    del grab_record_dict
    del basler_cameras
    import gc

    gc.collect()
    time.sleep(0.1)

    print("Cleanup completed")

if name == "main":
main()

The upcoming version pypylon 4.2.0 is more robust even with not efficient programming