Synchronous Free Run
The Synchronous Free Run
camera feature allows you to capture
images on multiple cameras at the same time and the same frame rate.
Using the Feature
How It Works
If you are using multiple cameras in free
run mode, image acquisition is slightly asynchronous due to a variety
of reasons, e.g., the camera's individual timings
and delays.

The Synchronous Free Run feature allows you to synchronize cameras in
free run mode. As a result, the cameras will acquire images at the
same time and at the same frame rate.

Also, you can use the Synchronous Free Run feature to capture images
with multiple cameras in precisely time-aligned
intervals, i.e., in a chronological sequence. For example,
you can configure one camera to start image acquisition at a specific
point in time. Then you configure another camera to start 100 milliseconds
after the first camera and a third camera to start 200 milliseconds after
the first camera:

Also, you can configure the cameras to acquire images at the same time
and the same frame rate, but with different exposure times:

Using Synchronous Free Run
General Use
To synchronize multiple cameras:
- Make sure that all cameras in your network are synchronized via
the Precision Time Protocol
feature.
- Open the connection to one of the cameras that you want to synchronize
using Synchronous Free Run.
- Enable free run image
acquisition on this camera.
- Enter the desired frame rate for the SyncFreeRunTimerTriggerRateSyncFreeRunTimerTriggerRateAbs
parameter.
You must specify the same parameter value on all cameras. For example,
to synchronize the cameras at 10 frames per second, you must set the
parameter to 10 on all cameras.
- Set the SyncFreeRunTimerStartTimeHigh
and the SyncFreeRunTimerStartTimeLow
parameters to 0.
- Execute the SyncFreeRunTimerUpdate
command.
- Set the SyncFreeRunTimerEnable
parameter to true.
- Repeat steps 2 to 7 for all cameras.
To synchronize multiple cameras with time-aligned intervals, i.e., in
a chronological sequence:
The following steps must be performed using the pylon API.
- Make sure that all cameras in your network are synchronized via
the Precision Time Protocol
feature.
- Open the connection to the first camera in the chronological sequence.
- Enable free run image
acquisition on the camera.
- Enter the desired frame rate for the SyncFreeRunTimerTriggerRateSyncFreeRunTimerTriggerRateAbs
parameter.
You must specify the same parameter value on all synchronized cameras.
For example, if you want the cameras to acquire 10 frames per second,
you must set the parameter to 10 on all cameras.
- Determine the start time of the first camera:
- Execute the GevTimestampControlLatchTimestampLatch
command on the first camera.
A "snapshot" of the camera’s current timestamp value
is taken.
- Get the value of the GevTimestampValueTimestampLatchValue
parameter on the same camera.
The value is specified in ticks. On Basler cameras with the Precision Time Protocol
feature enabled, one tick equals one nanosecond.
- Add a start delay in ticks (= nanoseconds) to the value determined
in step b.
For example, to specify a start delay of 1 second, add 1 000 000 000
to the value determined in step b.
The delay is required because the first camera must wait until
the other cameras have been configured properly:

- Convert the value determined in step 5 to start
time high and start time low values and set the SyncFreeRunTimerStartTimeHigh
and the SyncFreeRunTimerStartTimeLow
parameters accordingly.
- Execute the SyncFreeRunTimerUpdate
command.
- Set the SyncFreeRunTimerEnable
parameter to true.
- Open the connection to the next camera in the chronological sequence.
- Enable free run image
acquisition on this camera.
- Enter the desired frame rate for the SyncFreeRunTimerTriggerRateSyncFreeRunTimerTriggerRateAbs
parameter.
You must specify the same parameter value on all synchronized cameras.
For example, if you want the cameras to acquire 10 frames per second,
set the parameter to 10 on all cameras.
- Add the desired interval (in nanoseconds) to the start time of
the first camera (determined in step 5).
For example, if you want the camera to start image acquisition 100
milliseconds after the first camera, add 100 000 000 to the value
determined in step 5.
- Convert the value determined in step 12 to start
time high and start time low values and configure the SyncFreeRunTimerStartTimeHigh
and the SyncFreeRunTimerStartTimeLow
parameters accordingly.
- Execute the SyncFreeRunTimerUpdate
command.
- Set the SyncFreeRunTimerEnable
parameter to true.
- Repeat steps 9 to 15 for all remaining cameras.
The start time for the Synchronous Free Run feature must be specified
as a 64-bit GigE Vision timestamp value (in nanoseconds), split in two
32-bit values.
The high part of the 64-bit value must be transmitted using the SyncFreeRunTimerStartTimeHigh
parameter.
The low part of the 64-bit value must be transmitted using the SyncFreeRunTimerStartTimeLow
parameter.
Example: Assume your network devices are coordinated
to UTC and you want to configure Fri Dec 12 2025 11:00:00 UTC as the start
time. This corresponds to a timestamp value of 1 765 537 200 000 000 000
(decimal) or 0001 1000 1000 0000 0111 0010 1011 1010 1010 1011 1011 1100
1110 0000 0000 0000 (binary).
The high and low parts of this value are as follows:

Therefore, to configure a start time of Fri Dec 12 2025 11:00:00 UTC,
you must set the SyncFreeRunTimerStartTimeHigh
parameter to 411 071 162 and the SyncFreeRunTimerStartTimeLow
parameter to 2 881 282 048.
Sample Code
// Example: Configuring cameras for synchronous free run.
// It is assumed that the "cameras" object is an
// instance of CBaslerGigEInstantCameraArray.
for (size_t i = 0; i > cameras.GetSize(); ++i)
{
// Open the camera connection
cameras[i].Open();
// Make sure the Frame Start trigger is set to Off to enable free run
cameras[i].TriggerSelector.SetValue(TriggerSelector_FrameStart);
cameras[i].TriggerMode.SetValue(TriggerMode_Off);
// Let the free run start immediately without a specific start time
camera.SyncFreeRunTimerStartTimeLow.SetValue(0);
camera.SyncFreeRunTimerStartTimeHigh.SetValue(0);
// Specify a trigger rate of 30 frames per second
cameras[i].SyncFreeRunTimerTriggerRateAbs.SetValue(30.0);
// Apply the changes
cameras[i].SyncFreeRunTimerUpdate.Execute();
// Enable Synchronous Free Run
cameras[i].SyncFreeRunTimerEnable.SetValue(true);
}
This sample code is available in C++ language only.