Skip to content

Sequencer (GigE Cameras)#

The Sequencer camera feature allows you to define up to 64 sets of parameter settings, called sequence sets, and apply them to a sequence of image acquisitions.

As the camera acquires images, it applies one sequence set after the other. This enables you to quickly change camera parameters without compromising the maximum frame rate.

For example, you can use the Sequencer feature to quickly change between preconfigured image ROIs or exposure times.

For a description of the Sequencer feature for USB 3.0 cameras, click here.

Using the Feature#

Enabling or Disabling the Sequencer#

When enabled, the sequencer controls image acquisitions. It can't be configured in this state.

When disabled, the sequencer can be configured but is not controlling image acquisitions.

To enable the sequencer:

  1. Set all auto functions (e.g., Gain Auto, Exposure Auto) to Off.
  2. Set the SequenceEnable parameter to true.

How to disable the sequencer depends on your camera model:

  • If the SequenceConfigurationMode parameter is available:
    1. Set the SequenceEnable parameter to false.
    2. Set the SequenceConfigurationMode parameter to On.
  • If the SequenceConfigurationMode parameter is not available, set the SequenceEnable parameter to false.

What's in a Sequence Set?#

Sequencer sets contain the following parameters, if available:

  • AcquisitionFrameRate
  • AcquisitionFrameRateEnable
  • BalanceRatio
  • BinningHorizontal
  • BinningVertical
  • BlackLevel
  • CenterX
  • CenterY
  • ChunkEnable
  • ChunkModeActive
  • ColorAdjustmentEnable
  • ColorAdjustmentHue
  • ColorAdjustmentSaturation
  • ColorTransformationMatrixFactor
  • ColorTransformationValue
  • DecimationVertical
  • DigitalShift
  • ExposureTime
  • Gain
  • GammaEnablea
  • Height
  • LUTEnableb
  • OffsetX
  • OffsetX
  • PixelFormatc
  • ProcessedRawEnable
  • ReverseX
  • ReverseYd
  • ScalingHorizontal
  • SequenceSetExecutionse
  • StackedZoneImagingEnable
  • StackedZoneImagingZoneEnable
  • StackedZoneImagingZoneHeight
  • StackedZoneImagingZoneOffsetY
  • SubsamplingHorizontal
  • SyncUserOutput
  • TestImageSelector
  • TimerDelayf
  • TimerDelayTimebasef
  • TimerDurationf
  • TimerDurationTimebasef
  • Width

  1. Only contained if the LUTEnable parameter is set to false.

  2. Only contained if the GammaEnable parameter is set to false.

  3. Only available for the following camera models: acA640-300gm/gc, acA800-200gm/gc, acA1300-75gm/gc, acA1920-48gm/gc, acA2500-20gm/gc.

  4. Not available for the following camera models: acA3088-16gm/gc, acA4024-8gm/gc, acA5472-5gm/gc.

  5. Only contained if the auto sequence advance mode is enabled.

  6. Available for Timer 1.

All other camera parameters can't be controlled using the Sequencer feature.

Info

Loading or saving a sequence set will always load or save all of the above parameters, even those you haven't changed. For example, if you only changed the exposure time and left all other parameters at their default values, the values of all other parameters will also be stored (and overwritten on load).

Configuring Sequence Sets#

Info

  • To configure sequence sets, the sequencer must be disabled.
  • All changes made to sequence sets are lost when the camera is disconnected from power. Also, sequencer settings can't be saved in a user set. In order to preserve your settings, Basler recommends that you write suitable program code using the pylon API to re-populate the sequence sets every time the camera is powered on.

Before you can use the Sequencer feature, you must populate the sequence sets with your desired settings. Each sequence set has a unique sequence set index number, ranging from 0 to 63.

To populate the sequence sets:

  1. Set the SequenceSetTotalNumber parameter to the total number of sequence sets you want to use.
  2. Configure the sequence set parameters that you want to store in sequence set 0.
  3. Save sequence set 0.
  4. Repeat steps 2 and 3 for all sequence sets you want to use. Make sure to always use a continuous series of index numbers starting with index number 0, e.g., use sequence sets 0, 1, 2, and 3.

Example: Assume you need two sequence sets and want to populate them with different image ROI settings. To do so:

  1. Set the SequenceSetTotalNumber parameter to 2.
  2. Create the first image ROI by adjusting the Width, Height, OffsetX, and OffsetY parameter values.
  3. Save sequence set 0.
  4. Create the second image ROI by choosing different values for the Width, Height, OffsetX, and OffsetY parameters.
  5. Save sequence set 1.

You can now configure the sequencer to quickly change between the two image ROIs.

Saving a Sequence Set#

To save a sequence set:

  1. Set the SequenceSetIndex parameter to the desired sequence set.
  2. Execute the SequenceSetStore command.

The values of all sequence set parameters are stored in the selected sequence set.

Loading a Sequence Set#

Sequence sets are loaded automatically during sequencer operation. However, loading a sequence set manually can be useful for testing purposes or when configuring the sequencer.

To manually load a sequence set:

  1. Set the SequenceSetIndex parameter to the desired sequence set.
  2. Execute the SequenceSetLoad command.

The values of all sequence set parameters are overwritten and replaced by the values stored in the selected sequence set.

Configuring the Sequencer#

After you have configured the sequence sets, you must configure the sequencer.

Info

  • To configure the sequencer, the sequencer must be disabled.
  • All changes made to the sequencer configuration are lost when the camera is disconnected from power. Also, sequencer settings can't be saved in a user set. Basler recommends that you write suitable program code using the pylon API to reconfigure the camera every time it is powered on.
  • You can use the SequenceSetIndex chunk to keep track of the sequence sets used. When enabled, each image contains chunk data including the index number of the sequence set used for image acquisition.

The sequencer can be operated in three modes, called "advance modes":

In all modes, sequence sets always advance in ascending order, starting from sequence set index number 0.

Auto Sequence Advance Mode#

This mode is useful if you want to configure a fixed sequence which is repeated continuously.

You can enable this mode by setting the SequenceAdvanceMode parameter to Auto.

In this mode, the advance from one sequence set to the next occurs automatically as Frame Start trigger signals are received.

The SequenceSetTotalNumber parameter specifies the total number of sequence sets to be used. After the sequence set with the highest index number has been used, the cycle starts again at 0.

Example: Assume you want to configure the following sequence cycle:

Sample Sequence Cycle: 0-1-2-3-4-0-1-...

To configure the above sequence cycle:

  1. Set the SequenceAdvanceMode parameter to Auto.
  2. Set the SequenceSetTotalNumber parameter to 5.

Using Sequence Sets Multiple Times

Optionally, each sequence set can be used several times in a row.

To specify how many times you want to use each sequence set:

  1. Load the desired sequence set.
  2. Configure the SequenceSetExecutions parameter for this sequence set. By default, the parameter is set to 1 for all sets which means that each sequence set is used once per cycle.
  3. Save the sequence set.

Example: Assume you want to configure the following sequence cycle:

Sample Sequence Cycle: 0-1-1-1-2-3-4-5-5-0-1-...

To configure the above sequence cycle:

  1. Set the SequenceAdvanceMode parameter to Auto.
  2. Set the SequenceSetTotalNumber parameter to 6.
  3. Configure the SequenceSetExecutions parameter for each sequence set:
    • Sequence sets 0, 2, 3, and 4 are to be used only once per cycle. Therefore, you can skip these sets and leave the SequenceSetExecutions parameter at the default value of 1.
    • Sequence set 1 is to be used three times in a row. Load sequence set 1, set the SequenceSetExecutions parameter to 3, and save sequence set 1.
    • Sequence set 5 is to be used two times in a row. Load sequence set 5, set the SequenceSetExecutions parameter to 2, and save sequence set 5.

Controlled Sequence Advance Mode#

This mode is useful if you want to configure a dynamic sequence which can be controlled via line 1 or software commands.

Info

  • For real-time applications, Basler strongly recommends not to control the sequencer via software commands. The delay between sending a software command and it becoming effective depends on the specific installation and the current load on the network. Therefore, it's impossible to predict how many image acquisitions may occur between sending the software command and it becoming effective.
  • When you're controlling the sequencer using line 1, you have to bear in mind that it takes one microsecond between setting the status of the line and the rise of the Frame Start trigger signal. You also have to maintain the status of the line for at least one microsecond after the Frame Start trigger signal has risen. Monitor the Frame Trigger Wait signal to optimize the timing.

You can enable this mode by setting the SequenceAdvanceMode parameter to Controlled.

As in the other modes, the advance always proceeds in ascending order, starting from sequence set index number 0.

You can, however, control the following:

  • Sequence set advance: When do you want the sequencer to advance to the next sequence set?
  • Sequence set restart: When do you want the sequence cycle to start again from sequence set 0?

The SequenceSetTotalNumber parameter specifies the total number of sequence sets you want to use. After the sequence set with the highest index number has been used, the cycle starts again at 0.

Configuring Sequence Set Advance

To configure sequence set advance:

  1. Set the SequenceControlSelector parameter to Advance.
  2. Set the SequenceControlSource parameter to one of the following options:
    • Line1: Sequence set advance will be controlled via line 1. If line 1 is low (0) while a frame start trigger signal is received, the sequencer does not advance and the current sequence set is used again for image acquisition. If line 1 is high (1) while a Frame Start trigger signal is received, the sequencer advances and the next sequence set in the cycle is used for image acquisition.
    • Disabled: Sequence set advance will be controlled using the SequenceAsyncAdvance software command. When this command is received, the sequencer advances without acquiring an image. When the next Frame Start trigger signal is received, the sequence set indicated by the SequenceCurrentSet parameter value is used for image acquisition.
    • AlwaysActive: The sequencer behaves as if Line1 was selected and line 1 was always high (1). as a result, the sequencer advances every time a frame start trigger signal is received. This way of operating the sequencer is similar to operating it in auto sequence advance mode when each sequence set is used only once per cycle. The only difference is that sequence set 1 is used as the first sequence set instead of sequence set 0.
Configuring Sequence Set Restart

To configure sequence set restart:

  1. Set the SequenceControlSelector parameter to Restart.
  2. Set the SequenceControlSource parameter to one of the following options:
    • Line1: Sequence set restart will be controlled via line 1. If line 1 is low (0) while a frame start trigger signal is received, the next sequence set is used. If line 1 is high (1) while a Frame Start trigger signal is received, the sequence cycle is restarted and sequence set 0 is used.
    • Disabled: Sequence set restart will be controlled using the SequenceAsyncRestart software command. When this command is received, the sequence cycle is restarted without acquiring an image. When the next Frame Start trigger signal is received, sequence set 0 is used.

Free Selection Advance Mode#

This mode is useful if you want to quickly change between freely selectable sequence sets without having to observe any particular order. You use the input lines of your camera to determine the sequence.

Info

Bear in mind that it takes one microsecond between setting the status of the line and the rise of the Frame Start trigger signal. You also have to maintain the status of the line for at least one microsecond after the Frame Start trigger signal has risen. Monitor the Frame Trigger Wait signal to optimize the timing.

How to configure free selection advance mode depends on how many input lines are available on your camera:

Cameras with One Input Line

Sequence sets are chosen according to the status of input line 1:

  • If line 1 is low (0) while a frame start trigger signal is received, sequence set 0 is used for image acquisition.
  • If line 1 is high (1) while a Frame Start trigger signal is received, sequence set 1 is used for image acquisition.

Only sequence sets 0 and 1 are available.

To enable free selection advance mode:

  1. Set the SequenceAdvanceMode parameter to FreeSelection.
  2. Set the SequenceSetTotalNumber parameter to 2.

The SequenceAddressBitSelector and SequenceAddressBitSource parameters also control the operation of the free selection advance mode. However, these parameters are preset and can't be changed.

Cameras with Two Input Lines

Sequence sets are chosen according to the status of line 1 (opto-coupled input line) and line 3 (GPIO line, must be configured as input), resulting in four possible combinations. This allows you to choose between four sequence sets. Consequently, only sequence sets 0, 1, 2, and 3 are available.

In order to configure the free selection advance mode, you must assign a "sequence set address bit" to each line. The combinations of these address bits determine the sequence set index number. The following table shows the possible combinations and their respective outcomes.

Address Bit 1 Address Bit 0 Sequence Set That Will Be Selected
0 0 Sequence set 0
0 1 Sequence set 1
1 0 Sequence set 2
1 1 Sequence set 3

For example, you can assign line 1 to bit 1 and line 3 to bit 0. This results in the following sample configuration:

  • If line 1 is low (0) and line 3 is low (0) while a frame start trigger signal is received, sequence set 0 is used for image acquisition.
  • If line 1 is low (0) and line 3 is high (1) while a frame start trigger signal is received, sequence set 1 is used for image acquisition.
  • If line 1 is high (1) and line 3 is low (0) while a frame start trigger signal is received, sequence set 2 is used for image acquisition.
  • If line 1 is high (1) and line 3 is high (1) while a frame start trigger signal is received, sequence set 3 is used for image acquisition.

To configure the bits and enable free selection advance mode:

  1. Set the SequenceAdvanceMode parameter to FreeSelection.
  2. Set the SequenceSetTotalNumber parameter to 4.
  3. Set the SequenceAddressBitSelector parameter to Bit0.
  4. Set the SequenceAddressBitSource parameter to the line that you want to assign to bit 0, e.g., Line3.
  5. Set the SequenceAddressBitSelector parameter to Bit1.
  6. Set the SequenceAddressBitSource parameter to the line that you want to assign to bit 1, e.g., Line1.

Info

You can also use only one input line in free selection advance mode. To do so, set the SequenceSetTotalNumber parameter to 2. Now, only bit 0 is used to choose a sequence set. The free selection advance mode will behave as described under "Cameras with One Input Line".

Timing Diagrams#

Example: Auto Sequence Advance Mode#

Auto Sequence Advance Mode Timing Diagram (Example)

Example: Controlled Sequence Advance Mode (Controlled via Line 1)#

Controlled Sequence Advance Mode Timing Diagram (Example)

Example: Free Selection Advance Mode#

Free Selection Advance Mode Timing Diagram (Example)

Specifics#

Show all camera models

Camera Model SequenceConfigurationMode Parameter Available
a2A1920-51gcBAS See Sequencer (USB 3.0 Cameras)
a2A1920-51gcPRO See Sequencer (USB 3.0 Cameras)
a2A1920-51gmBAS See Sequencer (USB 3.0 Cameras)
a2A1920-51gmPRO See Sequencer (USB 3.0 Cameras)
a2A1920-160ucBAS See Sequencer (USB 3.0 Cameras)
a2A1920-160ucPRO See Sequencer (USB 3.0 Cameras)
a2A1920-160umBAS See Sequencer (USB 3.0 Cameras)
a2A1920-160umPRO See Sequencer (USB 3.0 Cameras)
a2A2590-22gcBAS See Sequencer (USB 3.0 Cameras)
a2A2590-22gcPRO See Sequencer (USB 3.0 Cameras)
a2A2590-22gmBAS See Sequencer (USB 3.0 Cameras)
a2A2590-22gmPRO See Sequencer (USB 3.0 Cameras)
a2A2590-60ucBAS See Sequencer (USB 3.0 Cameras)
a2A2590-60ucPRO See Sequencer (USB 3.0 Cameras)
a2A2590-60umBAS See Sequencer (USB 3.0 Cameras)
a2A2590-60umPRO See Sequencer (USB 3.0 Cameras)
a2A3840-13gcBAS See Sequencer (USB 3.0 Cameras)
a2A3840-13gcPRO See Sequencer (USB 3.0 Cameras)
a2A3840-13gmBAS See Sequencer (USB 3.0 Cameras)
a2A3840-13gmPRO See Sequencer (USB 3.0 Cameras)
a2A3840-45ucBAS See Sequencer (USB 3.0 Cameras)
a2A3840-45ucPRO See Sequencer (USB 3.0 Cameras)
a2A3840-45umBAS See Sequencer (USB 3.0 Cameras)
a2A3840-45umPRO See Sequencer (USB 3.0 Cameras)
acA640-90gc No
acA640-90gm No
acA640-90uc See Sequencer (USB 3.0 Cameras)
acA640-90um See Sequencer (USB 3.0 Cameras)
acA640-120gc No
acA640-120gm No
acA640-120uc See Sequencer (USB 3.0 Cameras)
acA640-120um See Sequencer (USB 3.0 Cameras)
acA640-121gm Yes
acA640-300gc Yes
acA640-300gm Yes
acA640-750uc See Sequencer (USB 3.0 Cameras)
acA640-750um See Sequencer (USB 3.0 Cameras)
acA720-290gc Yes
acA720-290gm Yes
acA720-520uc See Sequencer (USB 3.0 Cameras)
acA720-520um See Sequencer (USB 3.0 Cameras)
acA780-75gc No
acA780-75gm No
acA800-200gc Yes
acA800-200gm Yes
acA800-510uc See Sequencer (USB 3.0 Cameras)
acA800-510um See Sequencer (USB 3.0 Cameras)
acA1280-60gc No
acA1280-60gm No
acA1300-22gc No
acA1300-22gm No
acA1300-30gc No
acA1300-30gm No
acA1300-30uc See Sequencer (USB 3.0 Cameras)
acA1300-30um See Sequencer (USB 3.0 Cameras)
acA1300-60gc No
acA1300-60gm No
acA1300-60gmNIR No
acA1300-75gc Yes
acA1300-75gm Yes
acA1300-200uc See Sequencer (USB 3.0 Cameras)
acA1300-200um See Sequencer (USB 3.0 Cameras)
acA1440-73gc Yes
acA1440-73gm Yes
acA1440-220uc See Sequencer (USB 3.0 Cameras)
acA1440-220um See Sequencer (USB 3.0 Cameras)
acA1600-20gc Yes
acA1600-20gm Yes
acA1600-20uc See Sequencer (USB 3.0 Cameras)
acA1600-20um See Sequencer (USB 3.0 Cameras)
acA1600-60gc Yes
acA1600-60gm Yes
acA1920-25gc Yes
acA1920-25gm Yes
acA1920-25uc See Sequencer (USB 3.0 Cameras)
acA1920-25um See Sequencer (USB 3.0 Cameras)
acA1920-40gc Yes
acA1920-40gm Yes
acA1920-40uc See Sequencer (USB 3.0 Cameras)
acA1920-40ucMED See Sequencer (USB 3.0 Cameras)
acA1920-40um See Sequencer (USB Cameras)
acA1920-40umMED See Sequencer (USB 3.0 Cameras)
acA1920-48gc Yes
acA1920-48gm Yes
acA1920-50gc Yes
acA1920-50gm Yes
acA1920-150uc See Sequencer (USB 3.0 Cameras)
acA1920-150um See Sequencer (USB 3.0 Cameras)
acA1920-155uc See Sequencer (USB 3.0 Cameras)
acA1920-155ucMED See Sequencer (USB 3.0 Cameras)
acA1920-155um See Sequencer (USB 3.0 Cameras)
acA1920-155umMED See Sequencer (USB 3.0 Cameras)
acA2000-50gc Yes
acA2000-50gm Yes
acA2000-50gmNIR Yes
acA2000-165uc See Sequencer (USB 3.0 Cameras)
acA2000-165um See Sequencer (USB 3.0 Cameras)
acA2000-165umNIR See Sequencer (USB 3.0 Cameras)
acA2040-25gc Yes
acA2040-25gm Yes
acA2040-25gmNIR Yes
acA2040-35gc Yes
acA2040-35gm Yes
acA2040-55uc See Sequencer (USB 3.0 Cameras)
acA2040-55um See Sequencer (USB 3.0 Cameras)
acA2040-90uc See Sequencer (USB 3.0 Cameras)
acA2040-90um See Sequencer (USB 3.0 Cameras)
acA2040-90umNIR See Sequencer (USB 3.0 Cameras)
acA2040-120uc See Sequencer (USB 3.0 Cameras)
acA2040-120um See Sequencer (USB 3.0 Cameras)
acA2440-20gc Yes
acA2440-20gm Yes
acA2440-35uc See Sequencer (USB 3.0 Cameras)
acA2440-35ucMED See Sequencer (USB 3.0 Cameras)
acA2440-35um See Sequencer (USB 3.0 Cameras)
acA2440-35umMED See Sequencer (USB 3.0 Cameras)
acA2440-75uc See Sequencer (USB 3.0 Cameras)
acA2440-75ucMED See Sequencer (USB 3.0 Cameras)
acA2440-75um See Sequencer (USB 3.0 Cameras)
acA2440-75umMED See Sequencer (USB 3.0 Cameras)
acA2500-14gc No.
Note: If you use the camera with overlapping image acquisition, enabling the sequencer may affect the frame rate. When acquiring multiple images using the same sequence set, overlapping image acquisition is possible and the Sequencer feature has no effect on the camera's frame rate. When acquiring multiple images using different sequence sets, overlapping image acquisition is not possible. The camera must complete the entire exposure/readout process before a new sequence set can be loaded. As a consequence, the frame rate may drop significantly.
acA2500-14gm No.
Note: If you use the camera with overlapping image acquisition, enabling the sequencer may affect the frame rate. When acquiring multiple images using the same sequence set, overlapping image acquisition is possible and the Sequencer feature has no effect on the camera's frame rate. When acquiring multiple images using different sequence sets, overlapping image acquisition is not possible. The camera must complete the entire exposure/readout process before a new sequence set can be loaded. As a consequence, the frame rate may drop significantly.
acA2500-14uc See Sequencer (USB 3.0 Cameras)
acA2500-14um See Sequencer (USB 3.0 Cameras)
acA2500-20gc Yes
acA2500-20gcMED Yes
acA2500-20gm Yes
acA2500-20gmMED Yes
acA2500-60uc See Sequencer (USB 3.0 Cameras)
acA2500-60um See Sequencer (USB 3.0 Cameras)
acA3088-16gc Yes
acA3088-16gm Yes
acA3088-57uc See Sequencer (USB 3.0 Cameras)
acA3088-57um See Sequencer (USB 3.0 Cameras)
acA3800-10gc No
acA3800-10gm No
acA3800-14uc See Sequencer (USB 3.0 Cameras)
acA3800-14um See Sequencer (USB 3.0 Cameras)
acA4024-8gc Yes
acA4024-8gm Yes
acA4024-29uc See Sequencer (USB 3.0 Cameras)
acA4024-29um See Sequencer (USB 3.0 Cameras)
acA4096-11gc Yes
acA4096-11gm Yes
acA4096-30uc See Sequencer (USB 3.0 Cameras)
acA4096-30ucMED See Sequencer (USB 3.0 Cameras)
acA4096-30um See Sequencer (USB 3.0 Cameras)
acA4096-30umMED See Sequencer (USB 3.0 Cameras)
acA4096-40uc See Sequencer (USB 3.0 Cameras)
acA4096-40ucMED See Sequencer (USB 3.0 Cameras)
acA4096-40um See Sequencer (USB 3.0 Cameras)
acA4096-40umMED See Sequencer (USB 3.0 Cameras)
acA4112-8gc Yes
acA4112-8gm Yes
acA4112-20uc See Sequencer (USB 3.0 Cameras)
acA4112-20ucMED See Sequencer (USB 3.0 Cameras)
acA4112-20um See Sequencer (USB 3.0 Cameras)
acA4112-20umMED See Sequencer (USB 3.0 Cameras)
acA4112-30uc See Sequencer (USB 3.0 Cameras)
acA4112-30ucMED See Sequencer (USB 3.0 Cameras)
acA4112-30um See Sequencer (USB 3.0 Cameras)
acA4112-30umMED See Sequencer (USB 3.0 Cameras)
acA4600-7gc No
acA4600-10uc See Sequencer (USB 3.0 Cameras)
acA5472-5gc Yes
acA5472-5gm Yes
acA5472-17uc See Sequencer (USB 3.0 Cameras)
acA5472-17um See Sequencer (USB 3.0 Cameras)
boA4096-93cc Sequencer feature not supported
boA4096-93cm Sequencer feature not supported
boA4112-68cc Sequencer feature not supported
boA4112-68cm Sequencer feature not supported
daA1280-54lc Sequencer feature not supported
daA1280-54lm Sequencer feature not supported
daA1280-54uc Sequencer feature not supported
daA1280-54um Sequencer feature not supported
daA1600-60lc Sequencer feature not supported
daA1600-60lm Sequencer feature not supported
daA1600-60uc Sequencer feature not supported
daA1600-60um Sequencer feature not supported
daA1920-15um Sequencer feature not supported
daA1920-30uc Sequencer feature not supported
daA1920-30um Sequencer feature not supported
daA2500-14lc Sequencer feature not supported
daA2500-14lm Sequencer feature not supported
daA2500-14uc Sequencer feature not supported
daA2500-14um Sequencer feature not supported
daA2500-60mc Sequencer feature not supported
daA2500-60mci Sequencer feature not supported
daA4200-30mci Sequencer feature not supported
puA1280-54uc Sequencer feature not supported
puA1280-54um Sequencer feature not supported
puA1600-60uc Sequencer feature not supported
puA1600-60um Sequencer feature not supported
puA1920-30uc Sequencer feature not supported
puA1920-30um Sequencer feature not supported
puA2500-14uc Sequencer feature not supported
puA2500-14um Sequencer feature not supported

Sample Code#

// ** Configuring sequence sets **
// Disable the sequencer during configuration
camera.SequenceEnable.SetValue(false);
// Enable configuration mode (available on selected cameras only)
camera.SequenceConfigurationMode.SetValue(SequenceConfigurationMode_On);
// Set the total number of sequence sets to 2
camera.SequenceSetTotalNumber.SetValue(2);
// Configure the parameters that you want to store in the first sequence set
camera.Width.SetValue(500);
camera.Height.SetValue(300);
// Select sequence set 0 and save the parameter values
camera.SequenceSetIndex.SetValue(0);
camera.SequenceSetStore.Execute();
// Configure the parameters that you want to store in the second sequence set
camera.Width.SetValue(800);
camera.Height.SetValue(600);
// Select sequence set 1 and save the parameter values
camera.SequenceSetIndex.SetValue(1);
camera.SequenceSetStore.Execute();
// ** Configuring the sequencer for auto sequence advance mode
// Assuming you want to configure the following sequence cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...) **
// Disable the sequencer during configuration
camera.SequenceEnable.SetValue(false);
camera.SequenceAdvanceMode.SetValue(SequenceAdvanceMode_Auto);
// Set the total number of sequence sets to 2
camera.SequenceSetTotalNumber.SetValue(2);
// Load sequence set 0 and specify that this set is to be used
// 2 times in a row
camera.SequenceSetIndex.SetValue(0);
camera.SequenceSetLoad.Execute();
camera.SequenceSetExecutions.SetValue(2);
camera.SequenceSetStore.Execute();
// Load sequence set 1 and specify that this set is to be used
// 3 times in a row
camera.SequenceSetIndex.SetValue(1);
camera.SequenceSetLoad.Execute();
camera.SequenceSetExecutions.SetValue(3);
camera.SequenceSetStore.Execute();
// Enable the sequencer
camera.SequenceEnable.SetValue(true);
// ** Configuring the sequencer for controlled sequence advance mode **
// Disable the sequencer during configuration
camera.SequenceEnable.SetValue(false);
camera.SequenceAdvanceMode.SetValue(SequenceAdvanceMode_Controlled);
// Set the total number of sequence sets to 2
camera.SequenceSetTotalNumber.SetValue(2);
// Specify that sequence set advance is controlled via line 1
camera.SequenceControlSelector.SetValue(SequenceControlSelector_Advance);
camera.SequenceControlSource.SetValue(SequenceControlSource_Line1);
// Specify that sequence set restart is controlled
// via software command
camera.SequenceControlSelector.SetValue(SequenceControlSelector_Restart);
camera.SequenceControlSource.SetValue(SequenceControlSource_Disabled);
// Enable the sequencer
camera.SequenceEnable.SetValue(true);
// Restart the sequencer via software command (for testing purposes)
camera.SequenceAsyncRestart.Execute();
// ** Configuring the sequencer for free selection advance mode
// on cameras with ONE input line **
// Disable the sequencer during configuration
camera.SequenceEnable.SetValue(false);
camera.SequenceAdvanceMode.SetValue(SequenceAdvanceMode_FreeSelection);
// Set the total number of sequence sets to 2
camera.SequenceSetTotalNumber.SetValue(2);
// Enable the sequencer
camera.SequenceEnable.SetValue(true);
// ** Configuring the sequencer for free selection advance mode
// on cameras with TWO input lines (1x opto-coupled, 1x GPIO set for input) **
// Disable the sequencer during configuration
camera.SequenceEnable.SetValue(false);
camera.SequenceAdvanceMode.SetValue(SequenceAdvanceMode_FreeSelection);
// Set the total number of sequence sets to 2
camera.SequenceSetTotalNumber.SetValue(4);
// Assign sequence address bit 0 to line 3
camera.SequenceAddressBitSelector.SetValue(SequenceAddressBitSelector_Bit0);
camera.SequenceAddressBitSource.SetValue(SequenceAddressBitSource_Line3);
// Assign sequence address bit 1 to line 1
camera.SequenceAddressBitSelector.SetValue(SequenceAddressBitSelector_Bit1);
camera.SequenceAddressBitSource.SetValue(SequenceAddressBitSource_Line1);
// Enable the sequencer
camera.SequenceEnable.SetValue(true);
INodeMap& nodemap = camera.GetNodeMap();
// ** Configuring sequence sets **
// Disable the sequencer during configuration
CBooleanPtr(nodemap.GetNode("SequenceEnable"))->SetValue(false);
// Enable configuration mode (available on selected cameras only)
CEnumerationPtr(nodemap.GetNode("SequenceConfigurationMode"))->FromString("On");
// Set the total number of sequence sets to 2
CIntegerPtr(nodemap.GetNode("SequenceSetTotalNumber"))->SetValue(2);
// Configure the parameters that you want to store in the first sequence set
CIntegerPtr(nodemap.GetNode("Width"))->SetValue(500);
CIntegerPtr(nodemap.GetNode("Height"))->SetValue(300);
// Select sequence set 0 and save the parameter values
CIntegerPtr(nodemap.GetNode("SequenceSetIndex"))->SetValue(0);
CCommandPtr(nodemap.GetNode("SequenceSetStore"))->Execute();
// Configure the parameters that you want to store in the second sequence set
CIntegerPtr(nodemap.GetNode("Width"))->SetValue(800);
CIntegerPtr(nodemap.GetNode("Height"))->SetValue(600);
// Select sequence set 1 and save the parameter values
CIntegerPtr(nodemap.GetNode("SequenceSetIndex"))->SetValue(1);
CCommandPtr(nodemap.GetNode("SequenceSetStore"))->Execute();
// ** Configuring the sequencer for auto sequence advance mode
// Assuming you want to configure the following sequence cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...) **
// Disable the sequencer during configuration
CBooleanPtr(nodemap.GetNode("SequenceEnable"))->SetValue(false);
CEnumerationPtr(nodemap.GetNode("SequenceAdvanceMode"))->FromString("Auto");
// Set the total number of sequence sets to 2
CIntegerPtr(nodemap.GetNode("SequenceSetTotalNumber"))->SetValue(2);
// Load sequence set 0 and specify that this set is to be used
// 2 times in a row
CIntegerPtr(nodemap.GetNode("SequenceSetIndex"))->SetValue(0);
CCommandPtr(nodemap.GetNode("SequenceSetLoad"))->Execute();
CIntegerPtr(nodemap.GetNode("SequenceSetExecutions"))->SetValue(2);
CCommandPtr(nodemap.GetNode("SequenceSetStore"))->Execute();
// Load sequence set 1 and specify that this set is to be used
// 3 times in a row
CIntegerPtr(nodemap.GetNode("SequenceSetIndex"))->SetValue(1);
CCommandPtr(nodemap.GetNode("SequenceSetLoad"))->Execute();
CIntegerPtr(nodemap.GetNode("SequenceSetExecutions"))->SetValue(3);
CCommandPtr(nodemap.GetNode("SequenceSetStore"))->Execute();
// Enable the sequencer
CBooleanPtr(nodemap.GetNode("SequenceEnable"))->SetValue(true);
// ** Configuring the sequencer for controlled sequence advance mode **
// Disable the sequencer during configuration
CBooleanPtr(nodemap.GetNode("SequenceEnable"))->SetValue(false);
CEnumerationPtr(nodemap.GetNode("SequenceAdvanceMode"))->FromString("Controlled");
// Set the total number of sequence sets to 2
CIntegerPtr(nodemap.GetNode("SequenceSetTotalNumber"))->SetValue(2);
// Specify that sequence set advance is controlled via line 1
CEnumerationPtr(nodemap.GetNode("SequenceControlSelector"))->FromString("Advance");
CEnumerationPtr(nodemap.GetNode("SequenceControlSource"))->FromString("Line1");
// Specify that sequence set restart is controlled
// via software command
CEnumerationPtr(nodemap.GetNode("SequenceControlSelector"))->FromString("Restart");
CEnumerationPtr(nodemap.GetNode("SequenceControlSource"))->FromString("Disabled");
// Enable the sequencer
CBooleanPtr(nodemap.GetNode("SequenceEnable"))->SetValue(true);
// Restart the sequencer via software command (for testing purposes)
CCommandPtr(nodemap.GetNode("SequenceAsyncRestart"))->Execute();
// ** Configuring the sequencer for free selection advance mode
// on cameras with ONE input line **
// Disable the sequencer during configuration
CBooleanPtr(nodemap.GetNode("SequenceEnable"))->SetValue(false);
CEnumerationPtr(nodemap.GetNode("SequenceAdvanceMode"))->FromString("FreeSelection");
// Set the total number of sequence sets to 2
CIntegerPtr(nodemap.GetNode("SequenceSetTotalNumber"))->SetValue(2);
// Enable the sequencer
CBooleanPtr(nodemap.GetNode("SequenceEnable"))->SetValue(true);
// ** Configuring the sequencer for free selection advance mode
// on cameras with TWO input lines (1x opto-coupled, 1x GPIO set for input) **
// Disable the sequencer during configuration
CBooleanPtr(nodemap.GetNode("SequenceEnable"))->SetValue(false);
CEnumerationPtr(nodemap.GetNode("SequenceAdvanceMode"))->FromString("FreeSelection");
// Set the total number of sequence sets to 2
CIntegerPtr(nodemap.GetNode("SequenceSetTotalNumber"))->SetValue(4);
// Assign sequence address bit 0 to line 3
CEnumerationPtr(nodemap.GetNode("SequenceAddressBitSelector"))->FromString("Bit0");
CEnumerationPtr(nodemap.GetNode("SequenceAddressBitSource"))->FromString("Line3");
// Assign sequence address bit 1 to line 1
CEnumerationPtr(nodemap.GetNode("SequenceAddressBitSelector"))->FromString("Bit1");
CEnumerationPtr(nodemap.GetNode("SequenceAddressBitSource"))->FromString("Line1");
// Enable the sequencer
CBooleanPtr(nodemap.GetNode("SequenceEnable"))->SetValue(true);
INodeMap& nodemap = camera.GetNodeMap();
// ** Configuring sequence sets **
// Disable the sequencer during configuration
CBooleanParameter(nodemap, "SequenceEnable").SetValue(false);
// Enable configuration mode (available on selected cameras only)
CEnumParameter(nodemap, "SequenceConfigurationMode").SetValue("On");
// Set the total number of sequence sets to 2
CIntegerParameter(nodemap, "SequenceSetTotalNumber").SetValue(2);
// Configure the parameters that you want to store in the first sequence set
CIntegerParameter(nodemap, "Width").SetValue(500);
CIntegerParameter(nodemap, "Height").SetValue(300);
// Select sequence set 0 and save the parameter values
CIntegerParameter(nodemap, "SequenceSetIndex").SetValue(0);
CCommandParameter(nodemap, "SequenceSetStore").Execute();
// Configure the parameters that you want to store in the second sequence set
CIntegerParameter(nodemap, "Width").SetValue(800);
CIntegerParameter(nodemap, "Height").SetValue(600);
// Select sequence set 1 and save the parameter values
CIntegerParameter(nodemap, "SequenceSetIndex").SetValue(1);
CCommandParameter(nodemap, "SequenceSetStore").Execute();
// ** Configuring the sequencer for auto sequence advance mode
// Assuming you want to configure the following sequence cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...) **
// Disable the sequencer during configuration
CBooleanParameter(nodemap, "SequenceEnable").SetValue(false);
CEnumParameter(nodemap, "SequenceAdvanceMode").SetValue("Auto");
// Set the total number of sequence sets to 2
CIntegerParameter(nodemap, "SequenceSetTotalNumber").SetValue(2);
// Load sequence set 0 and specify that this set is to be used
// 2 times in a row
CIntegerParameter(nodemap, "SequenceSetIndex").SetValue(0);
CCommandParameter(nodemap, "SequenceSetLoad").Execute();
CIntegerParameter(nodemap, "SequenceSetExecutions").SetValue(2);
CCommandParameter(nodemap, "SequenceSetStore").Execute();
// Load sequence set 1 and specify that this set is to be used
// 3 times in a row
CIntegerParameter(nodemap, "SequenceSetIndex").SetValue(1);
CCommandParameter(nodemap, "SequenceSetLoad").Execute();
CIntegerParameter(nodemap, "SequenceSetExecutions").SetValue(3);
CCommandParameter(nodemap, "SequenceSetStore").Execute();
// Enable the sequencer
CBooleanParameter(nodemap, "SequenceEnable").SetValue(true);
// ** Configuring the sequencer for controlled sequence advance mode **
// Disable the sequencer during configuration
CBooleanParameter(nodemap, "SequenceEnable").SetValue(false);
CEnumParameter(nodemap, "SequenceAdvanceMode").SetValue("Controlled");
// Set the total number of sequence sets to 2
CIntegerParameter(nodemap, "SequenceSetTotalNumber").SetValue(2);
// Specify that sequence set advance is controlled via line 1
CEnumParameter(nodemap, "SequenceControlSelector").SetValue("Advance");
CEnumParameter(nodemap, "SequenceControlSource").SetValue("Line1");
// Specify that sequence set restart is controlled
// via software command
CEnumParameter(nodemap, "SequenceControlSelector").SetValue("Restart");
CEnumParameter(nodemap, "SequenceControlSource").SetValue("Disabled");
// Enable the sequencer
CBooleanParameter(nodemap, "SequenceEnable").SetValue(true);
// Restart the sequencer via software command (for testing purposes)
CCommandParameter(nodemap, "SequenceAsyncRestart").Execute();
// ** Configuring the sequencer for free selection advance mode
// on cameras with ONE input line **
// Disable the sequencer during configuration
CBooleanParameter(nodemap, "SequenceEnable").SetValue(false);
CEnumParameter(nodemap, "SequenceAdvanceMode").SetValue("FreeSelection");
// Set the total number of sequence sets to 2
CIntegerParameter(nodemap, "SequenceSetTotalNumber").SetValue(2);
// Enable the sequencer
CBooleanParameter(nodemap, "SequenceEnable").SetValue(true);
// ** Configuring the sequencer for free selection advance mode
// on cameras with TWO input lines (1x opto-coupled, 1x GPIO set for input) **
// Disable the sequencer during configuration
CBooleanParameter(nodemap, "SequenceEnable").SetValue(false);
CEnumParameter(nodemap, "SequenceAdvanceMode").SetValue("FreeSelection");
// Set the total number of sequence sets to 2
CIntegerParameter(nodemap, "SequenceSetTotalNumber").SetValue(4);
// Assign sequence address bit 0 to line 3
CEnumParameter(nodemap, "SequenceAddressBitSelector").SetValue("Bit0");
CEnumParameter(nodemap, "SequenceAddressBitSource").SetValue("Line3");
// Assign sequence address bit 1 to line 1
CEnumParameter(nodemap, "SequenceAddressBitSelector").SetValue("Bit1");
CEnumParameter(nodemap, "SequenceAddressBitSource").SetValue("Line1");
// Enable the sequencer
CBooleanParameter(nodemap, "SequenceEnable").SetValue(true);
// ** Configuring sequence sets **
// Disable the sequencer during configuration
camera.Parameters[PLCamera.SequenceEnable].SetValue(false);
// Enable configuration mode (available on selected cameras only)
camera.Parameters[PLCamera.SequenceConfigurationMode].SetValue(PLCamera.SequenceConfigurationMode.On);
// Set the total number of sequence sets to 2
camera.Parameters[PLCamera.SequenceSetTotalNumber].SetValue(2);
// Configure the parameters that you want to store in the first sequence set
camera.Parameters[PLCamera.Width].SetValue(500);
camera.Parameters[PLCamera.Height].SetValue(300);
// Select sequence set 0 and save the parameter values
camera.Parameters[PLCamera.SequenceSetIndex].SetValue(0);
camera.Parameters[PLCamera.SequenceSetStore].Execute();
// Configure the parameters that you want to store in the second sequence set
camera.Parameters[PLCamera.Width].SetValue(800);
camera.Parameters[PLCamera.Height].SetValue(600);
// Select sequence set 1 and save the parameter values
camera.Parameters[PLCamera.SequenceSetIndex].SetValue(1);
camera.Parameters[PLCamera.SequenceSetStore].Execute();
// ** Configuring the sequencer for auto sequence advance mode
// Assuming you want to configure the following sequence cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...) **
// Disable the sequencer during configuration
camera.Parameters[PLCamera.SequenceEnable].SetValue(false);
camera.Parameters[PLCamera.SequenceAdvanceMode].SetValue(PLCamera.SequenceAdvanceMode.Auto);
// Set the total number of sequence sets to 2
camera.Parameters[PLCamera.SequenceSetTotalNumber].SetValue(2);
// Load sequence set 0 and specify that this set is to be used
// 2 times in a row
camera.Parameters[PLCamera.SequenceSetIndex].SetValue(0);
camera.Parameters[PLCamera.SequenceSetLoad].Execute();
camera.Parameters[PLCamera.SequenceSetExecutions].SetValue(2);
camera.Parameters[PLCamera.SequenceSetStore].Execute();
// Load sequence set 1 and specify that this set is to be used
// 3 times in a row
camera.Parameters[PLCamera.SequenceSetIndex].SetValue(1);
camera.Parameters[PLCamera.SequenceSetLoad].Execute();
camera.Parameters[PLCamera.SequenceSetExecutions].SetValue(3);
camera.Parameters[PLCamera.SequenceSetStore].Execute();
// Enable the sequencer
camera.Parameters[PLCamera.SequenceEnable].SetValue(true);
// ** Configuring the sequencer for controlled sequence advance mode **
// Disable the sequencer during configuration
camera.Parameters[PLCamera.SequenceEnable].SetValue(false);
camera.Parameters[PLCamera.SequenceAdvanceMode].SetValue(PLCamera.SequenceAdvanceMode.Controlled);
// Set the total number of sequence sets to 2
camera.Parameters[PLCamera.SequenceSetTotalNumber].SetValue(2);
// Specify that sequence set advance is controlled via line 1
camera.Parameters[PLCamera.SequenceControlSelector].SetValue(PLCamera.SequenceControlSelector.Advance);
camera.Parameters[PLCamera.SequenceControlSource].SetValue(PLCamera.SequenceControlSource.Line1);
// Specify that sequence set restart is controlled
// via software command
camera.Parameters[PLCamera.SequenceControlSelector].SetValue(PLCamera.SequenceControlSelector.Restart);
camera.Parameters[PLCamera.SequenceControlSource].SetValue(PLCamera.SequenceControlSource.Disabled);
// Enable the sequencer
camera.Parameters[PLCamera.SequenceEnable].SetValue(true);
// Restart the sequencer via software command (for testing purposes)
camera.Parameters[PLCamera.SequenceAsyncRestart].Execute();
// ** Configuring the sequencer for free selection advance mode
// on cameras with ONE input line **
// Disable the sequencer during configuration
camera.Parameters[PLCamera.SequenceEnable].SetValue(false);
camera.Parameters[PLCamera.SequenceAdvanceMode].SetValue(PLCamera.SequenceAdvanceMode.FreeSelection);
// Set the total number of sequence sets to 2
camera.Parameters[PLCamera.SequenceSetTotalNumber].SetValue(2);
// Enable the sequencer
camera.Parameters[PLCamera.SequenceEnable].SetValue(true);
// ** Configuring the sequencer for free selection advance mode
// on cameras with TWO input lines (1x opto-coupled, 1x GPIO set for input) **
// Disable the sequencer during configuration
camera.Parameters[PLCamera.SequenceEnable].SetValue(false);
camera.Parameters[PLCamera.SequenceAdvanceMode].SetValue(PLCamera.SequenceAdvanceMode.FreeSelection);
// Set the total number of sequence sets to 2
camera.Parameters[PLCamera.SequenceSetTotalNumber].SetValue(4);
// Assign sequence address bit 0 to line 3
camera.Parameters[PLCamera.SequenceAddressBitSelector].SetValue(PLCamera.SequenceAddressBitSelector.Bit0);
camera.Parameters[PLCamera.SequenceAddressBitSource].SetValue(PLCamera.SequenceAddressBitSource.Line3);
// Assign sequence address bit 1 to line 1
camera.Parameters[PLCamera.SequenceAddressBitSelector].SetValue(PLCamera.SequenceAddressBitSelector.Bit1);
camera.Parameters[PLCamera.SequenceAddressBitSource].SetValue(PLCamera.SequenceAddressBitSource.Line1);
// Enable the sequencer
camera.Parameters[PLCamera.SequenceEnable].SetValue(true);
// ** Configuring sequence sets **
// Disable the sequencer during configuration
Pylon.DeviceSetBooleanFeature(hdev, "SequenceEnable", false);
// Enable configuration mode (available on selected cameras only)
Pylon.DeviceFeatureFromString(hdev, "SequenceConfigurationMode", "On");
// Set the total number of sequence sets to 2
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 2);
// Configure the parameters that you want to store in the first sequence set
Pylon.DeviceSetIntegerFeature(hdev, "Width", 500);
Pylon.DeviceSetIntegerFeature(hdev, "Height", 300);
// Select sequence set 0 and save the parameter values
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetIndex", 0);
Pylon.DeviceExecuteCommandFeature(hdev, "SequenceSetStore");
// Configure the parameters that you want to store in the second sequence set
Pylon.DeviceSetIntegerFeature(hdev, "Width", 800);
Pylon.DeviceSetIntegerFeature(hdev, "Height", 600);
// Select sequence set 1 and save the parameter values
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetIndex", 1);
Pylon.DeviceExecuteCommandFeature(hdev, "SequenceSetStore");
// ** Configuring the sequencer for auto sequence advance mode
// Assuming you want to configure the following sequence cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...) **
// Disable the sequencer during configuration
Pylon.DeviceSetBooleanFeature(hdev, "SequenceEnable", false);
Pylon.DeviceFeatureFromString(hdev, "SequenceAdvanceMode", "Auto");
// Set the total number of sequence sets to 2
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 2);
// Load sequence set 0 and specify that this set is to be used
// 2 times in a row
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetIndex", 0);
Pylon.DeviceExecuteCommandFeature(hdev, "SequenceSetLoad");
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetExecutions", 2);
Pylon.DeviceExecuteCommandFeature(hdev, "SequenceSetStore");
// Load sequence set 1 and specify that this set is to be used
// 3 times in a row
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetIndex", 1);
Pylon.DeviceExecuteCommandFeature(hdev, "SequenceSetLoad");
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetExecutions", 3);
Pylon.DeviceExecuteCommandFeature(hdev, "SequenceSetStore");
// Enable the sequencer
Pylon.DeviceSetBooleanFeature(hdev, "SequenceEnable", true);
// ** Configuring the sequencer for controlled sequence advance mode **
// Disable the sequencer during configuration
Pylon.DeviceSetBooleanFeature(hdev, "SequenceEnable", false);
Pylon.DeviceFeatureFromString(hdev, "SequenceAdvanceMode", "Controlled");
// Set the total number of sequence sets to 2
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 2);
// Specify that sequence set advance is controlled via line 1
Pylon.DeviceFeatureFromString(hdev, "SequenceControlSelector", "Advance");
Pylon.DeviceFeatureFromString(hdev, "SequenceControlSource", "Line1");
// Specify that sequence set restart is controlled
// via software command
Pylon.DeviceFeatureFromString(hdev, "SequenceControlSelector", "Restart");
Pylon.DeviceFeatureFromString(hdev, "SequenceControlSource", "Disabled");
// Enable the sequencer
Pylon.DeviceSetBooleanFeature(hdev, "SequenceEnable", true);
// Restart the sequencer via software command (for testing purposes)
Pylon.DeviceExecuteCommandFeature(hdev, "SequenceAsyncRestart");
// ** Configuring the sequencer for free selection advance mode
// on cameras with ONE input line **
// Disable the sequencer during configuration
Pylon.DeviceSetBooleanFeature(hdev, "SequenceEnable", false);
Pylon.DeviceFeatureFromString(hdev, "SequenceAdvanceMode", "FreeSelection");
// Set the total number of sequence sets to 2
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 2);
// Enable the sequencer
Pylon.DeviceSetBooleanFeature(hdev, "SequenceEnable", true);
// ** Configuring the sequencer for free selection advance mode
// on cameras with TWO input lines (1x opto-coupled, 1x GPIO set for input) **
// Disable the sequencer during configuration
Pylon.DeviceSetBooleanFeature(hdev, "SequenceEnable", false);
Pylon.DeviceFeatureFromString(hdev, "SequenceAdvanceMode", "FreeSelection");
// Set the total number of sequence sets to 2
Pylon.DeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 4);
// Assign sequence address bit 0 to line 3
Pylon.DeviceFeatureFromString(hdev, "SequenceAddressBitSelector", "Bit0");
Pylon.DeviceFeatureFromString(hdev, "SequenceAddressBitSource", "Line3");
// Assign sequence address bit 1 to line 1
Pylon.DeviceFeatureFromString(hdev, "SequenceAddressBitSelector", "Bit1");
Pylon.DeviceFeatureFromString(hdev, "SequenceAddressBitSource", "Line1");
// Enable the sequencer
Pylon.DeviceSetBooleanFeature(hdev, "SequenceEnable", true);
/* Macro to check for errors */
#define CHECK(errc) if (GENAPI_E_OK != errc) printErrorAndExit(errc)
GENAPIC_RESULT errRes = GENAPI_E_OK;  /* Return value of pylon methods */
/* ** Configuring sequence sets ** */
/* Disable the sequencer during configuration */
errRes = PylonDeviceSetBooleanFeature(hdev, "SequenceEnable", 0);
CHECK(errRes);
/* Enable configuration mode (available on selected cameras only) */
errRes = PylonDeviceFeatureFromString(hdev, "SequenceConfigurationMode", "On");
CHECK(errRes);
/* Set the total number of sequence sets to 2 */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 2);
CHECK(errRes);
/* Configure the parameters that you want to store in the first sequence set */
errRes = PylonDeviceSetIntegerFeature(hdev, "Width", 500);
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "Height", 300);
CHECK(errRes);
/* Select sequence set 0 and save the parameter values */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetIndex", 0);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequenceSetStore");
CHECK(errRes);
/* Configure the parameters that you want to store in the second sequence set */
errRes = PylonDeviceSetIntegerFeature(hdev, "Width", 800);
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "Height", 600);
CHECK(errRes);
/* Select sequence set 1 and save the parameter values */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetIndex", 1);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequenceSetStore");
CHECK(errRes);
/* ** Configuring the sequencer for auto sequence advance mode */
/* Assuming you want to configure the following sequence cycle: */
/* 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...) ** */
/* Disable the sequencer during configuration */
errRes = PylonDeviceSetBooleanFeature(hdev, "SequenceEnable", 0);
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequenceAdvanceMode", "Auto");
CHECK(errRes);
/* Set the total number of sequence sets to 2 */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 2);
CHECK(errRes);
/* Load sequence set 0 and specify that this set is to be used */
/* 2 times in a row */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetIndex", 0);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequenceSetLoad");
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetExecutions", 2);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequenceSetStore");
CHECK(errRes);
/* Load sequence set 1 and specify that this set is to be used */
/* 3 times in a row */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetIndex", 1);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequenceSetLoad");
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetExecutions", 3);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequenceSetStore");
CHECK(errRes);
/* Enable the sequencer */
errRes = PylonDeviceSetBooleanFeature(hdev, "SequenceEnable", 1);
CHECK(errRes);
/* ** Configuring the sequencer for controlled sequence advance mode ** */
/* Disable the sequencer during configuration */
errRes = PylonDeviceSetBooleanFeature(hdev, "SequenceEnable", 0);
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequenceAdvanceMode", "Controlled");
CHECK(errRes);
/* Set the total number of sequence sets to 2 */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 2);
CHECK(errRes);
/* Specify that sequence set advance is controlled via line 1 */
errRes = PylonDeviceFeatureFromString(hdev, "SequenceControlSelector", "Advance");
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequenceControlSource", "Line1");
CHECK(errRes);
/* Specify that sequence set restart is controlled */
/* via software command */
errRes = PylonDeviceFeatureFromString(hdev, "SequenceControlSelector", "Restart");
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequenceControlSource", "Disabled");
CHECK(errRes);
/* Enable the sequencer */
errRes = PylonDeviceSetBooleanFeature(hdev, "SequenceEnable", 1);
CHECK(errRes);
/* Restart the sequencer via software command (for testing purposes) */
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequenceAsyncRestart");
CHECK(errRes);
/* ** Configuring the sequencer for free selection advance mode */
/* on cameras with ONE input line ** */
/* Disable the sequencer during configuration */
errRes = PylonDeviceSetBooleanFeature(hdev, "SequenceEnable", 0);
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequenceAdvanceMode", "FreeSelection");
CHECK(errRes);
/* Set the total number of sequence sets to 2 */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 2);
CHECK(errRes);
/* Enable the sequencer */
errRes = PylonDeviceSetBooleanFeature(hdev, "SequenceEnable", 1);
CHECK(errRes);
/* ** Configuring the sequencer for free selection advance mode */
/* on cameras with TWO input lines (1x opto-coupled, 1x GPIO set for input) ** */
/* Disable the sequencer during configuration */
errRes = PylonDeviceSetBooleanFeature(hdev, "SequenceEnable", 0);
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequenceAdvanceMode", "FreeSelection");
CHECK(errRes);
/* Set the total number of sequence sets to 2 */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequenceSetTotalNumber", 4);
CHECK(errRes);
/* Assign sequence address bit 0 to line 3 */
errRes = PylonDeviceFeatureFromString(hdev, "SequenceAddressBitSelector", "Bit0");
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequenceAddressBitSource", "Line3");
CHECK(errRes);
/* Assign sequence address bit 1 to line 1 */
errRes = PylonDeviceFeatureFromString(hdev, "SequenceAddressBitSelector", "Bit1");
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequenceAddressBitSource", "Line1");
CHECK(errRes);
/* Enable the sequencer */
errRes = PylonDeviceSetBooleanFeature(hdev, "SequenceEnable", 1);
CHECK(errRes);

You can also use the pylon Viewer to easily set the parameters.