タグ: pylon

How to Manually Control Exposure Time Using the Basler pylon SDK (C# / .NET 8)

Have you ever felt that your industrial camera images look too dark, too bright, or fluctuate unexpectedly?
Automatic exposure (auto-exposure) can be useful, but in many machine-vision or inspection systems, consistent lighting is essential, and automatic adjustments can cause instability.

With the Basler pylon SDK, you can switch exposure control to manual mode and specify an exact exposure time (in microseconds), enabling stable and predictable imaging.

This article explains how to set, read, and validate exposure time manually using C# and the pylon SDK.

✔ Environment

Item	Details
Camera	Basler acA2500-14gm
SDK	Basler pylon Camera Software Suite
Lang	C# / .NET 8.0 (Windows)

💡 Background: GenICam and Camera Parameters

Parameters such as ExposureTimeAbs used in this article follow GenICam (Generic Interface for Cameras) — an industry standard used by Basler, FLIR, IDS, JAI, and many other industrial camera manufacturers.

With GenICam SFNC (Standard Features Naming Convention), you can access:

Exposure
Gain
ROI / image size
Trigger settings
Acquisition modes

all using a common parameter model.

👉 GenICam SFNC specification:
https://www.emva.org/standards-technology/genicam/

This article focuses on practical usage, but knowing that pylon follows GenICam helps when switching between camera brands.

🔧 Setting Exposure Time Manually

Below is an extension to the BaslerCameraSample class from the previous article.

Method: Set Exposure Time (manual mode)

// Set exposure time manually (unit: microseconds)
public bool SetExposure(double exposureTimeUs)
{
    // Disable auto exposure (switch to manual)
    if (!SetExposureMode(PLCamera.ExposureAuto.Off))
        return false;

    // Set exposure time (e.g., 5000 µs = 5 ms)
    if (!SetPLCameraParamter(PLCamera.ExposureTimeAbs, exposureTimeUs))
        return false;

    Console.WriteLine($”Exposure time set to {exposureTimeUs} μs.”);
    return true;
}

// Set exposure time manually (unit: microseconds)

public bool SetExposure(double exposureTimeUs)

{

// Disable auto exposure (switch to manual)

if (!SetExposureMode(PLCamera.ExposureAuto.Off))

return false;

// Set exposure time (e.g., 5000 µs = 5 ms)

if (!SetPLCameraParamter(PLCamera.ExposureTimeAbs, exposureTimeUs))

return false;

Console.WriteLine($“Exposure time set to {exposureTimeUs} μs.”);

return true;

}

Helper Functions

Set auto-exposure mode (Off / Once / Continuous)

public bool SetExposureMode(string mode)
    => SetPLCameraParamter(PLCamera.ExposureAuto, mode);

1 2	public bool SetExposureMode(string mode) => SetPLCameraParamter(PLCamera.ExposureAuto, mode);

Set an enum parameter

public bool SetPLCameraParamter(ParameterListEnum parameter, string value)
{
    if (Camera == null || !IsConnected)
        return false;

    if (Camera.Parameters[parameter].IsWritable)
    {
        Camera.Parameters[parameter].SetValue(value);
        Console.WriteLine($”{parameter} set to {value}.”);
        return true;
    }
    Console.WriteLine($”{parameter} is not writable.”);
    return false;
}

public bool SetPLCameraParamter(ParameterListEnum parameter, string value)

{

if (Camera == null || !IsConnected)

return false;

if (Camera.Parameters[parameter].IsWritable)

{

Camera.Parameters[parameter].SetValue(value);

Console.WriteLine($“{parameter} set to {value}.”);

return true;

}

Console.WriteLine($“{parameter} is not writable.”);

return false;

}

Set a floating-point parameter (e.g., ExposureTimeAbs)

public bool SetPLCameraParamter(FloatName parameter, double value)
{
    if (Camera == null || !IsConnected)
        return false;

    if (Camera.Parameters[parameter].IsWritable)
    {
        Camera.Parameters[parameter].SetValue(value);
        Console.WriteLine($”{parameter} set to {value}.”);
        return true;
    }
    Console.WriteLine($”{parameter} is not writable.”);
    return false;
}

public bool SetPLCameraParamter(FloatName parameter, double value)

{

if (Camera == null || !IsConnected)

return false;

if (Camera.Parameters[parameter].IsWritable)

{

Camera.Parameters[parameter].SetValue(value);

Console.WriteLine($“{parameter} set to {value}.”);

return true;

}

Console.WriteLine($“{parameter} is not writable.”);

return false;

}

🔍 Reading the Current Exposure Time

Use GetValue() to read exposure parameters from the camera.

// Read exposure time in microseconds
public double GetExposureTime()
    => GetPLCameraParamter(PLCamera.ExposureTimeAbs);

public double GetPLCameraParamter(FloatName parameter)
{
    if (Camera == null || !IsConnected)
        throw new InvalidOperationException(“Camera is not connected.”);

    if (Camera.Parameters[parameter].IsReadable)
    {
        double value = Camera.Parameters[parameter].GetValue();
        Console.WriteLine($”{parameter} value: {value}”);
        return value;
    }
    throw new InvalidOperationException($”{parameter} is not readable.”);
}

// Read exposure time in microseconds

public double GetExposureTime()

=> GetPLCameraParamter(PLCamera.ExposureTimeAbs);

public double GetPLCameraParamter(FloatName parameter)

{

if (Camera == null || !IsConnected)

throw new InvalidOperationException(“Camera is not connected.”);

if (Camera.Parameters[parameter].IsReadable)

{

double value = Camera.Parameters[parameter].GetValue();

Console.WriteLine($“{parameter} value: {value}”);

return value;

}

throw new InvalidOperationException($“{parameter} is not readable.”);

}

💡 About ExposureAuto Modes

Value	Behavior
Off	Manual exposure (used in this article)
Once	Adjusts exposure once, then fixes it
Continuous	Continuously adjusts to maintain brightness

📷 Example: Change Exposure and Capture Images

The test below captures images at 5 ms, 20 ms, and 50 ms.

[TestMethod()]
public void SetExposureTest()
{
    _baslerCameraSample.Connect();

    // 5 ms
    _baslerCameraSample.SetExposure(5000);
    var img1 = _baslerCameraSample.SnapToBitmapSource();
    BaslerCameraSample.SaveBitmap(img1, “Exposure_5ms.bmp”);
    Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 5000) < 100);

    // 20 ms
    _baslerCameraSample.SetExposure(20000);
    var img2 = _baslerCameraSample.SnapToBitmapSource();
    BaslerCameraSample.SaveBitmap(img2, “Exposure_20ms.bmp”);
    Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 20000) < 100);

    // 50 ms
    _baslerCameraSample.SetExposure(50000);
    var img3 = _baslerCameraSample.SnapToBitmapSource();
    BaslerCameraSample.SaveBitmap(img3, “Exposure_50ms.bmp”);
    Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 50000) < 100);
}

[TestMethod()]

public void SetExposureTest()

{

_baslerCameraSample.Connect();

// 5 ms

_baslerCameraSample.SetExposure(5000);

var img1 = _baslerCameraSample.SnapToBitmapSource();

BaslerCameraSample.SaveBitmap(img1, “Exposure_5ms.bmp”);

Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 5000) < 100);

// 20 ms

_baslerCameraSample.SetExposure(20000);

var img2 = _baslerCameraSample.SnapToBitmapSource();

BaslerCameraSample.SaveBitmap(img2, “Exposure_20ms.bmp”);

Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 20000) < 100);

// 50 ms

_baslerCameraSample.SetExposure(50000);

var img3 = _baslerCameraSample.SnapToBitmapSource();

BaslerCameraSample.SaveBitmap(img3, “Exposure_50ms.bmp”);

Assert.IsTrue(Math.Abs(_baslerCameraSample.GetExposureTime() – 50000) < 100);

}

📊 Exposure Comparison

5 ms (darker)	20 ms (balanced)	50 ms (brighter)

🧭 Common Issues & Troubleshooting

Issue	Cause / Solution
Exposure does not change	`ExposureAuto` is still On
Value outside valid range	Exposure too long or too short for the camera model
Image too dark/bright	Lighting or gain settings are insufficient
Exposure fluctuates	External lighting or auto exposure still enabled

📝 Summary

Set ExposureAuto = Off to enable manual exposure control
Exposure time is specified in microseconds (μs)
pylon SDK accesses all parameters through Camera.Parameters[...], following GenICam SFNC

🔜 Coming Up Next

Exposure alone may not give enough brightness range depending on your lighting environment.
The next article will cover manual gain control using the pylon SDK.

2025-12-04

How to Capture a Single Image from Basler ace Camera using pylon SDK in C#

Basler industrial cameras can be controlled easily using the pylon Camera Software Suite.
In this article, I’ll show you how to connect to a camera, grab a single frame, convert it to a BitmapSource, and save it as a .bmp file—all using C# and .NET 8.

When I first started working with Basler cameras in a .NET environment, I found very few practical code examples.
This guide is based on tested code from my own applications.

This article covers:

Connecting to a camera
Capturing one frame (Snap)
Converting to BitmapSource (WPF-friendly)
Saving the image as .bmp

⚠️ Important Notice

This article demonstrates how to develop custom applications using the Basler pylon Camera Software Suite SDK.

The content here is based on my own testing and implementation
It is not endorsed by Basler AG
The SDK itself is not redistributed here (no DLLs, headers, etc.)

To use the SDK, download it directly from Basler’s official website:

🔗 pylon SDK download
https://www.baslerweb.com/en/products/software/basler-pylon-camera-software-suite/

Make sure to review the EULA, especially if using the SDK in commercial or high-risk environments:
https://www.baslerweb.com/en/service/eula/

The sample code in this article is provided strictly for learning and reference. Use it at your own responsibility.

✔ Environment

Item	Details
SDK	Basler pylon Camera Software Suite
Language	C# (.NET 8.0 — Windows)
Camera	Basler acA2500-14gm
OS	Windows 10 / 11

1. Connecting to the Camera

First, create a simple wrapper class for managing the connection.
You can connect to the first available camera or use a specified camera name (as shown in Basler pylon Viewer).

using System;
using Basler.Pylon;

namespace BaslerSamples
{
    public class BaslerCameraSample
    {
        public Camera? Camera { get; private set; }
        public bool IsConnected => Camera?.IsConnected ?? false;

        public bool Connect()
        {
            var camera = new Camera();
            return ConnectInternal(camera);
        }

        public bool Connect(string cameraName)
        {
            try
            {
                var camera = new Camera(cameraName);
                return ConnectInternal(camera);
            }
            catch (InvalidOperationException e)
            {
                Console.WriteLine($”Failed to create camera. Message: {e.Message}”);
                return false;
            }
        }

        private bool ConnectInternal(Camera camera)
        {
            try
            {
                camera.Open();
                if (camera.IsOpen)
                {
                    Console.WriteLine(“Camera connected successfully.”);
                    Camera = camera;
                    return true;
                }
                else
                {
                    Console.WriteLine(“Failed to open camera.”);
                    return false;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($”Error connecting to camera: {ex.Message}”);
                return false;
            }
        }
    }
}

using System;

using Basler.Pylon;

namespace BaslerSamples

{

public class BaslerCameraSample

{

public Camera? Camera { get; private set; }

public bool IsConnected => Camera?.IsConnected ?? false;

public bool Connect()

{

var camera = new Camera();

return ConnectInternal(camera);

}

public bool Connect(string cameraName)

{

try

{

var camera = new Camera(cameraName);

return ConnectInternal(camera);

}

catch (InvalidOperationException e)

{

Console.WriteLine($“Failed to create camera. Message: {e.Message}”);

return false;

}

private bool ConnectInternal(Camera camera)

{

try

{

camera.Open();

if (camera.IsOpen)

{

Console.WriteLine(“Camera connected successfully.”);

Camera = camera;

return true;

}

else

{

Console.WriteLine(“Failed to open camera.”);

return false;

}

catch (Exception ex)

{

Console.WriteLine($“Error connecting to camera: {ex.Message}”);

return false;

}

2. Capturing a Single Image

The simplest way to grab one frame is by calling GrabOne() through the Stream Grabber.

public IGrabResult Snap(int timeoutMs = 5000)
{
    if (Camera == null)
        throw new InvalidOperationException(“Camera is not connected.”);

    var streamGrabber = Camera.StreamGrabber 
        ?? throw new InvalidOperationException(“StreamGrabber is not available.”);
    var grabResult = streamGrabber.GrabOne(timeoutMs);

    if (grabResult != null && grabResult.GrabSucceeded)
        return grabResult;
    else
        throw new Exception(“Failed to grab image: ” + (grabResult?.ErrorDescription ?? “Unknown error”));
}

public IGrabResult Snap(int timeoutMs = 5000)

{

if (Camera == null)

throw new InvalidOperationException(“Camera is not connected.”);

var streamGrabber = Camera.StreamGrabber

?? throw new InvalidOperationException(“StreamGrabber is not available.”);

var grabResult = streamGrabber.GrabOne(timeoutMs);

if (grabResult != null && grabResult.GrabSucceeded)

return grabResult;

else

throw new Exception(“Failed to grab image: “ + (grabResult?.ErrorDescription ?? “Unknown error”));

}

3. Converting to `BitmapSource` (for WPF)

IGrabResult cannot be displayed directly in WPF.
We convert it to a BitmapSource using PixelDataConverter.

using System.Windows.Media;
using System.Windows.Media.Imaging;

public BitmapSource SnapToBitmapSource(int timeoutMs = 5000)
{
    using IGrabResult grabResult = Snap(timeoutMs);
    PixelDataConverter converter = new();

    var (outputType, pixelFormat, bytesPerPixel) = grabResult.PixelTypeValue switch
    {
        PixelType.RGB8packed => (PixelType.RGB8packed, PixelFormats.Rgb24, 3),
        PixelType.BGR8packed => (PixelType.BGR8packed, PixelFormats.Bgr24, 3),
        _ => (PixelType.Mono8, PixelFormats.Gray8, 1),
    };

    converter.OutputPixelFormat = outputType;

    int width = grabResult.Width;
    int height = grabResult.Height;
    int stride = width * bytesPerPixel;

    byte[] buffer = new byte[stride * height];
    converter.Convert(buffer, grabResult);

    return BitmapSource.Create(width, height, 96, 96, pixelFormat, null, buffer, stride);
}

using System.Windows.Media;

using System.Windows.Media.Imaging;

public BitmapSource SnapToBitmapSource(int timeoutMs = 5000)

{

using IGrabResult grabResult = Snap(timeoutMs);

PixelDataConverter converter = new();

var (outputType, pixelFormat, bytesPerPixel) = grabResult.PixelTypeValue switch

{

PixelType.RGB8packed => (PixelType.RGB8packed, PixelFormats.Rgb24, 3),

PixelType.BGR8packed => (PixelType.BGR8packed, PixelFormats.Bgr24, 3),

_ => (PixelType.Mono8, PixelFormats.Gray8, 1),

};

converter.OutputPixelFormat = outputType;

int width = grabResult.Width;

int height = grabResult.Height;

int stride = width * bytesPerPixel;

byte[] buffer = new byte[stride * height];

converter.Convert(buffer, grabResult);

return BitmapSource.Create(width, height, 96, 96, pixelFormat, null, buffer, stride);

}

Supports:

RGB8packed
BGR8packed
Mono8 (default fallback)

4. Saving the Image as `.bmp`

A simple helper method using BmpBitmapEncoder:

public static void SaveBitmap(BitmapSource bitmap, string filePath)
{
    using FileStream fileStream = new(filePath, FileMode.Create);
    var encoder = new BmpBitmapEncoder();
    encoder.Frames.Add(BitmapFrame.Create(bitmap));
    encoder.Save(fileStream);
}

public static void SaveBitmap(BitmapSource bitmap, string filePath)

{

using FileStream fileStream = new(filePath, FileMode.Create);

var encoder = new BmpBitmapEncoder();

encoder.Frames.Add(BitmapFrame.Create(bitmap));

encoder.Save(fileStream);

}

5. Example Test Code

You can easily test the entire pipeline (grab → convert → save) using the following:

static BaslerCameraSample _baslerCameraSample = new BaslerCameraSample();

[TestMethod()]
public void SnapToBitmapSourceTest()
{
    if (!_baslerCameraSample.IsConnected)
        _baslerCameraSample.Connect();

    var result = _baslerCameraSample.SnapToBitmapSource(1234);
    Assert.IsNotNull(result);

    BaslerCameraSample.SaveBitmap(result, “SaveBitmapTest.bmp”);
    Assert.IsTrue(File.Exists(“SaveBitmapTest.bmp”));
}

static BaslerCameraSample _baslerCameraSample = new BaslerCameraSample();

[TestMethod()]

public void SnapToBitmapSourceTest()

{

if (!_baslerCameraSample.IsConnected)

_baslerCameraSample.Connect();

var result = _baslerCameraSample.SnapToBitmapSource(1234);

Assert.IsNotNull(result);

BaslerCameraSample.SaveBitmap(result, “SaveBitmapTest.bmp”);

Assert.IsTrue(File.Exists(“SaveBitmapTest.bmp”));

}

✔ Output Example

The captured image will be saved as:SaveBitmapTest.bmp

Example output:

(Image from the original article)

✨ Conclusion

Although official documentation covers the basics, hands-on .NET examples for pylon are still relatively rare.
Fortunately, pylon’s .NET API is clean and integrates smoothly with Windows desktop applications such as WPF.

2025-12-03

タグ: pylon

How to Manually Control Exposure Time Using the Basler pylon SDK (C# / .NET 8)

How to Manually Control Exposure Time Using the Basler pylon SDK (C# / .NET 8)

✔ Environment

💡 Background: GenICam and Camera Parameters

🔧 Setting Exposure Time Manually

Method: Set Exposure Time (manual mode)

Helper Functions

Set auto-exposure mode (Off / Once / Continuous)

Set an enum parameter

Set a floating-point parameter (e.g., ExposureTimeAbs)

🔍 Reading the Current Exposure Time

💡 About ExposureAuto Modes

📷 Example: Change Exposure and Capture Images

📊 Exposure Comparison

🧭 Common Issues & Troubleshooting

📝 Summary

🔜 Coming Up Next

How to Capture a Single Image from Basler ace Camera using pylon SDK in C#

How to Capture a Single Image from Basler ace Camera using pylon SDK in C#

⚠️ Important Notice

✔ Environment

1. Connecting to the Camera

2. Capturing a Single Image

3. Converting to BitmapSource (for WPF)

4. Saving the Image as .bmp

5. Example Test Code

✔ Output Example

✨ Conclusion

3. Converting to `BitmapSource` (for WPF)

4. Saving the Image as `.bmp`