跳转到内容

Sequencer(USB 相机)#

相机的 Sequencer 功能允许您定义多达 32 组参数设置(称为定序器集),并将其应用于图像采集序列。

相机采集图像时,会逐个应用定序器集。这使您可以快速更改相机参数,而不会影响最大帧速率。

例如,您可以使用 Sequencer 功能,在预配置的图像 ROI曝光时间之间快速切换。

有关 GigE 相机的 Sequencer 功能说明,请单击此处

该功能的使用#

定序器模式#

  • 定序器模式下,定序器控制图像采集。无法在此状态下配置定序器。
  • 定序器配置模式下,可以配置定序器,但定序器不控制图像采集。

要启用定序器模式:

  1. 将所有自动功能(例如,Gain AutoExposure Auto)设置为 Off
  2. SequencerMode 参数设置为 On

要启用定序器配置模式:

  1. SequencerMode 参数设置为 Off
  2. SequencerConfigurationMode 参数设置为 On

定序器集中包含什么?#

定序器集包含以下参数(如果可用):

  • AcquisitionFrameRate
  • AcquisitionFrameRateEnable
  • BalanceRatio
  • BinningHorizontal
  • BinningVertical
  • BlackLevel
  • CenterX
  • CenterY
  • ChunkEnable
  • ChunkModeActive
  • ColorAdjustmentHue
  • ColorAdjustmentSaturation
  • ColorTransformationValue
  • CounterDuration(用于 Counter 2)
  • CounterEventSource
  • CounterResetSource
  • DigitalShift
  • ExposureTime
  • Gain
  • Height
  • LUTEnablea
  • OffsetX
  • OffsetY
  • PixelFormatb
  • ReverseX
  • ReverseYc
  • ScalingHorizontal
  • SequencerSetNext
  • SequencerSetPath
  • SequencerSetSelector
  • SequencerSetStart
  • SequencerTriggerActivation
  • SequencerTriggerSource
  • TestImageSelector
  • TimerDelay(用于计时器 1)
  • TimerDuration(用于计时器 1)
  • Width

  1. 仅在 Gamma 参数设置为 1.0,并且 LightSourcePreset 参数设置为 Off 时包含。

  2. 仅适用于以下相机型号:acA640-750um/uc、acA800-510um/uc、acA1300-200um/uc、acA1920-150um/uc、acA2500-60um/uc。

  3. 不适用于以下相机型号:acA3088-57um/uc、acA4024-29um/uc、acA5472-17um/uc。

其他所有相机参数均无法使用 Sequencer 功能控制。

信息

加载保存定序器集将始终加载或保存以上所有参数,包括您未更改的参数在内。例如,如果仅更改曝光时间并保留所有其他参数的默认值,则所有其他参数的值也将被存储(并在加载时被覆盖)。

配置定序器集#

信息

  • 要配置定序器集,定序器必须处于配置模式
  • 断开相机电源后,对定序器集所做的所有更改都会丢失。另外,定序器集也无法保存在用户设置集中。为了保留您的设置,Basler 建议您使用 pylon API 编写适当的代码,在每次打开相机电源时重新填充序列集。

在使用 Sequencer 功能之前,必须使用所需的设置填充定序器集。每个定序器集都有一个唯一的定序器集索引编号,范围从 0 到 31。

要填充定序器集:

  1. 配置要存储在定序器集 0 中的定序器集参数
  2. 保存定序器集 0。
  3. 对要使用的所有定序器集重复步骤 1 和 2。确保始终使用从索引号 0 开始的连续索引号序列,例如,使用定序器集 0、1、2 和 3。

示例:假设您需要两个定序器集,并希望使用不同的图像 ROI 设置来填充。为此:

  1. 通过调整宽度高度OffsetXOffsetY参数值创建第一个图像 ROI。
  2. 保存定序器集 0。
  3. 通过选择不同的宽度高度OffsetXOffsetY参数值创建第二个图像 ROI。
  4. 保存定序器集 1。

现在,您可以将定序器配置为在两个图像 ROI 之间快速切换。

保存定序器集#

要保存定序器集:

  1. SequencerSetSelector 参数设置为所需的定序器集。
  2. 执行 SequencerSetSave 命令。

所有定序器集参数的值都存储在选定的定序器集中。

加载定序器集#

定序器集在定序器操作期间自动加载。但是,手动加载定序器集对于测试或定序器的配置可能很有用。

若要手动加载定序器集:

  1. SequencerSetSelector 参数设置为所需的定序器集。
  2. 执行 SequencerSetLoad 命令。

所有定序器集参数的值都将被覆盖,并由存储在所选定序器集中的值替换。

配置 Sequencer#

配置定序器集后,必须设置定序器。

信息

  • 要配置定序器,定序器必须处于配置模式
  • 断开相机电源后,对定序器配置所做的所有更改都将丢失。另外,定序器集也无法保存在用户设置集中。Basler 建议您使用 pylon API 编写适当的程序代码,在相机每次开启电源时重新配置相机。
  • 您可以使用 SequencerSetActive块 来跟踪所使用的定序器集。启用后,每个图像都包含块数据,该数据包括用于图像采集的定序器集的索引号。

路径 0 和路径 1#

要控制定序器,必须设置两个“路径”:

  • 路径 1 允许您循环遍历可用的定序器集(定序器集推进)。每当定序器接收到“路径 1”触发信号时,定序器就会推进到下一个设置。示例:

    路径 1 的示例序列循环:0-1-2-3-4-0-1-...

  • 路径 0 允许您重置循环(定序器集重置)。每当定序器收到“路径 0”触发信号时,定序器就会从定序器集 0 重新开始循环。示例:

    路径 0 的示例序列循环:0-1-2-0-1-2-...

设置路径 0#

要设置路径 0,您必须指定要用作“路径 0”触发信号(即用作定序器集重置信号)的源信号

您可以选择硬件信号或软件信号作为路径 0 的源信号。源设置必须存储在定序器集 0 中。

要指定路径 0 的源信号:

  1. 加载定序器集 0。
  2. SequencerPathSelector 参数设置为 0。
  3. 设置 SequencerTriggerSource 参数设置为以下值:
    • Line1Line3Line4:可以通过输入Line 1、GPIO Line 3 或 GPIO Line 4 控制定序器集重置。
    • SoftwareSignal1SoftwareSignal2SoftwareSignal3:可以使用 Software Signal Pulse 功能控制定序器集重置。
  4. 保存定序器集 0。

信息

  • 对于实时应用,Basler 强烈建议不要通过软件命令控制定序器集重置。由于信号处理和传输,在发出软件命令与定序器集重置之间的延迟不确定。因此,无法预测在发送软件命令到命令生效之间可能发生的图像采集次数。
  • 路径 0 和路径 1 不得使用相同的触发源。

设置路径 1#

指定触发源

首先,您必须指定要用作“路径 1”触发信号(即用作定序器集推进信号)的源信号

您可以选择帧开始触发信号、硬件信号、软件信号或计数器作为路径 1 的源信号。源设置必须存储在定序器集 0 中。

要指定路径 1 的源信号:

  1. 加载定序器集 0。
  2. SequencerPathSelector 参数设置为 1。
  3. 设置 SequencerTriggerSource 参数设置为以下值:
    • FrameStart:在接收到帧开始触发信号时,会自动发生定序器集推进。
    • Line1Line3Line4:可以通过输入Line 1、GPIO Line 3 或 GPIO Line 4 来控制定序器集推进。要使用 GPIO 线路,必须将该线路配置为输入。如果在接收到帧开始触发信号的同时,指定线路为低电平 (0),则定序器不会推进,并且当前设置将再次用于图像采集。如果在接收到帧开始触发信号的同时,相应线路为高电平 (1),则定序器将推进,并将循环中设置的下一个定序器用于图像采集。
    • SoftwareSignal1SoftwareSignal2SoftwareSignal3:可以使用 Software Signal Pulse 功能控制定序器集推进。
    • Counter2End:可以使用计数器控制定序器集推进。
  4. 保存定序器集 0。
指定使用的定序器集

其次,您必须指定在定序器操作期间要使用哪些定序器集

默认情况下,将使用全部 32 个定序器集。当接收到“路径 1”触发信号时,定序器会将定序器集的索引号从 0 一直推进至 31。在此之后,循环从 0 重新开始。

要使用编号较小的定序器集:

  1. 加载定序器集以及您要使用的最高索引号。
    示例:假设您已配置 5 个定序器集,并且想要设置以下循环:

    路径 1 的示例序列循环:0-1-2-3-4-0-1-...

    在此循环中,最高定序器集索引号为 4。因此,载入定序器集 4。2. 将 SequencerPathSelector 参数设置为 1。3. 将 SequencerSetNext 参数设置为 0。4. 保存定序器集。

在运行期间,定序器将在索引号最高的设置之后切换到定序器集 0。从而形成闭环循环。

信息

  • 对于实时应用,Basler 强烈建议不要通过软件命令控制定序器集推进。由于信号处理和传输,在发出软件命令与定序器集推进之间的延迟不确定。因此,无法预测在发送软件命令到命令生效之间可能发生的图像采集次数。
  • 路径 0 和路径 1 不得使用相同的触发源。

使用计数器控制定序器#

如果将路径 1 的源信号设置Counter2End,则可以使用计数器来控制定序器集推进。

如果要设置一个固定序列,该序列连续多次使用定序器集,则此功能很有用。

对于每个定序器集,您可以设置 CounterDuration 参数以指定要连续使用多少次该集。默认情况下,所有集的参数均设置为 1,每个序列集在每个循环中使用一次。

示例:假设您要设置以下定序器集循环:

示例定序器循环:0-1-1-1-2-3-4-5-5-0-1-...

要设置上述定序器集循环:

  1. 加载定序器集 0。
  2. SequencerPathSelector 参数设置为 1。
  3. SequencerTriggerSource 参数设置为 Counter2End
  4. 保存定序器集 0。
  5. CounterSelector 参数设置为 Counter2
  6. 设置 CounterDuration 参数(针对各定序器集):
    • 定序器集 0、2、3 和 4 在每个循环中只能使用一次。因此,您可以跳过这些设置,并将 CounterDuration 参数保留为默认值 1。
    • 定序器集 1 将连续使用 3 次。加载定序器集 1,将 CounterDuration 参数设置为 3,然后保存定序器集 1。
    • 定序器集 5 将连续使用两次。加载定序器集 5,将 CounterDuration 参数设置为 2,并保存定序器集 5。

附加参数#

SequencerSetStartSequencerTriggerActivation 参数还控制定序器的运行。但是,这些参数是预设的,无法更改。

详情#

显示所有相机型号

相机型号 提示
a2A1920-51gcBAS 不支持 Sequencer 功能
a2A1920-51gcPRO 不支持 Sequencer 功能
a2A1920-51gmBAS 不支持 Sequencer 功能
a2A1920-51gmPRO 不支持 Sequencer 功能
a2A1920-160ucBAS 不支持 Sequencer 功能
a2A1920-160ucPRO 不支持 Sequencer 功能
a2A1920-160umBAS 不支持 Sequencer 功能
a2A1920-160umPRO 不支持 Sequencer 功能
a2A2590-22gcBAS 不支持 Sequencer 功能
a2A2590-22gcPRO 不支持 Sequencer 功能
a2A2590-22gmBAS 不支持 Sequencer 功能
a2A2590-22gmPRO 不支持 Sequencer 功能
a2A2590-60ucBAS 不支持 Sequencer 功能
a2A2590-60ucPRO 不支持 Sequencer 功能
a2A2590-60umBAS 不支持 Sequencer 功能
a2A2590-60umPRO 不支持 Sequencer 功能
a2A3840-13gcBAS 不支持 Sequencer 功能
a2A3840-13gcPRO 不支持 Sequencer 功能
a2A3840-13gmBAS 不支持 Sequencer 功能
a2A3840-13gmPRO 不支持 Sequencer 功能
a2A3840-45ucBAS 不支持 Sequencer 功能
a2A3840-45ucPRO 不支持 Sequencer 功能
a2A3840-45umBAS 不支持 Sequencer 功能
a2A3840-45umPRO 不支持 Sequencer 功能
acA640-90gc 请参阅 Sequencer(GigE 相机)
acA640-90gm 请参阅 Sequencer(GigE 相机)
acA640-90uc 没有适用于您的相机型号的特定信息。
acA640-90um 没有适用于您的相机型号的特定信息。
acA640-120gc 请参阅 Sequencer(GigE 相机)
acA640-120gm 请参阅 Sequencer(GigE 相机)
acA640-120uc 没有适用于您的相机型号的特定信息。
acA640-120um 没有适用于您的相机型号的特定信息。
acA640-121gm 请参阅 Sequencer(GigE 相机)
acA640-300gc 请参阅 Sequencer(GigE 相机)
acA640-300gm 请参阅 Sequencer(GigE 相机)
acA640-750uc 没有适用于您的相机型号的特定信息。
acA640-750um 没有适用于您的相机型号的特定信息。
acA720-290gc 请参阅 Sequencer(GigE 相机)
acA720-290gm 请参阅 Sequencer(GigE 相机)
acA720-520uc 没有适用于您的相机型号的特定信息。
acA720-520um 没有适用于您的相机型号的特定信息。
acA780-75gc 请参阅 Sequencer(GigE 相机)
acA780-75gm 请参阅 Sequencer(GigE 相机)
acA800-200gc 请参阅 Sequencer(GigE 相机)
acA800-200gm 请参阅 Sequencer(GigE 相机)
acA800-510uc 没有适用于您的相机型号的特定信息。
acA800-510um 没有适用于您的相机型号的特定信息。
acA1280-60gc 请参阅 Sequencer(GigE 相机)
acA1280-60gm 请参阅 Sequencer(GigE 相机)
acA1300-22gc 请参阅 Sequencer(GigE 相机)
acA1300-22gm 请参阅 Sequencer(GigE 相机)
acA1300-30gc 请参阅 Sequencer(GigE 相机)
acA1300-30gm 请参阅 Sequencer(GigE 相机)
acA1300-30uc 没有适用于您的相机型号的特定信息。
acA1300-30um 没有适用于您的相机型号的特定信息。
acA1300-60gc 请参阅 Sequencer(GigE 相机)
acA1300-60gm 请参阅 Sequencer(GigE 相机)
acA1300-60gmNIR 请参阅 Sequencer(GigE 相机)
acA1300-75gc 请参阅 Sequencer(GigE 相机)
acA1300-75gm 请参阅 Sequencer(GigE 相机)
acA1300-200uc 没有适用于您的相机型号的特定信息。
acA1300-200um 没有适用于您的相机型号的特定信息。
acA1440-73gc 请参阅 Sequencer(GigE 相机)
acA1440-73gm 请参阅 Sequencer(GigE 相机)
acA1440-220uc 没有适用于您的相机型号的特定信息。
acA1440-220um 没有适用于您的相机型号的特定信息。
acA1600-20gc 请参阅 Sequencer(GigE 相机)
acA1600-20gm 请参阅 Sequencer(GigE 相机)
acA1600-20uc 没有适用于您的相机型号的特定信息。
acA1600-20um 没有适用于您的相机型号的特定信息。
acA1600-60gc 请参阅 Sequencer(GigE 相机)
acA1600-60gm 请参阅 Sequencer(GigE 相机)
acA1920-25gc 请参阅 Sequencer(GigE 相机)
acA1920-25gm 请参阅 Sequencer(GigE 相机)
acA1920-25uc 如果您为相机使用重叠图像采集,则启用定序器可能会影响帧速率。
使用相同的定序器集采集多个图像时,可以实现重叠图像采集,并且 Sequencer 功能对相机的帧速率没有影响。
使用不同的定序器集采集多幅图像时,无法进行重叠图像采集。相机必须完成整个曝光/读取过程,然后才能加载新的序列集。结果,帧速率可能会大大下降。
acA1920-25um 如果您为相机使用重叠图像采集,则启用定序器可能会影响帧速率。
使用相同的定序器集采集多个图像时,可以实现重叠图像采集,并且 Sequencer 功能对相机的帧速率没有影响。
使用不同的定序器集采集多幅图像时,无法进行重叠图像采集。相机必须完成整个曝光/读取过程,然后才能加载新的序列集。结果,帧速率可能会大大下降。
acA1920-40gc 请参阅 Sequencer(GigE 相机)
acA1920-40gm 请参阅 Sequencer(GigE 相机)
acA1920-40uc 没有适用于您的相机型号的特定信息。
acA1920-40ucMED 没有适用于您的相机型号的特定信息。
acA1920-40um 没有适用于您的相机型号的特定信息。
acA1920-40umMED 没有适用于您的相机型号的特定信息。
acA1920-48gc 请参阅 Sequencer(GigE 相机)
acA1920-48gm 请参阅 Sequencer(GigE 相机)
acA1920-50gc 请参阅 Sequencer(GigE 相机)
acA1920-50gm 请参阅 Sequencer(GigE 相机)
acA1920-150uc 没有适用于您的相机型号的特定信息。
acA1920-150um 没有适用于您的相机型号的特定信息。
acA1920-155uc 没有适用于您的相机型号的特定信息。
acA1920-155ucMED 没有适用于您的相机型号的特定信息。
acA1920-155um 没有适用于您的相机型号的特定信息。
acA1920-155umMED 没有适用于您的相机型号的特定信息。
acA2000-50gc 请参阅 Sequencer(GigE 相机)
acA2000-50gm 请参阅 Sequencer(GigE 相机)
acA2000-50gmNIR 请参阅 Sequencer(GigE 相机)
acA2000-165uc 没有适用于您的相机型号的特定信息。
acA2000-165um 没有适用于您的相机型号的特定信息。
acA2000-165umNIR 没有适用于您的相机型号的特定信息。
acA2040-25gc 请参阅 Sequencer(GigE 相机)
acA2040-25gm 请参阅 Sequencer(GigE 相机)
acA2040-25gmNIR 请参阅 Sequencer(GigE 相机)
acA2040-35gc 请参阅 Sequencer(GigE 相机)
acA2040-35gm 请参阅 Sequencer(GigE 相机)
acA2040-55uc 没有适用于您的相机型号的特定信息。
acA2040-55um 没有适用于您的相机型号的特定信息。
acA2040-90uc 没有适用于您的相机型号的特定信息。
acA2040-90um 没有适用于您的相机型号的特定信息。
acA2040-90umNIR 没有适用于您的相机型号的特定信息。
acA2040-120uc 没有适用于您的相机型号的特定信息。
acA2040-120um 没有适用于您的相机型号的特定信息。
acA2440-20gc 请参阅 Sequencer(GigE 相机)
acA2440-20gm 请参阅 Sequencer(GigE 相机)
acA2440-35uc 没有适用于您的相机型号的特定信息。
acA2440-35ucMED 没有适用于您的相机型号的特定信息。
acA2440-35um 没有适用于您的相机型号的特定信息。
acA2440-35umMED 没有适用于您的相机型号的特定信息。
acA2440-75uc 没有适用于您的相机型号的特定信息。
acA2440-75ucMED 没有适用于您的相机型号的特定信息。
acA2440-75um 没有适用于您的相机型号的特定信息。
acA2440-75umMED 没有适用于您的相机型号的特定信息。
acA2500-14gc 请参阅 Sequencer(GigE 相机)
acA2500-14gm 请参阅 Sequencer(GigE 相机)
acA2500-14uc 如果您为相机使用重叠图像采集,则启用定序器可能会影响帧速率。
使用相同的定序器集采集多个图像时,可以实现重叠图像采集,并且 Sequencer 功能对相机的帧速率没有影响。
使用不同的定序器集采集多幅图像时,无法进行重叠图像采集。相机必须完成整个曝光/读取过程,然后才能加载新的序列集。结果,帧速率可能会大大下降。
acA2500-14um 如果您为相机使用重叠图像采集,则启用定序器可能会影响帧速率。
使用相同的定序器集采集多个图像时,可以实现重叠图像采集,并且 Sequencer 功能对相机的帧速率没有影响。
使用不同的定序器集采集多幅图像时,无法进行重叠图像采集。相机必须完成整个曝光/读取过程,然后才能加载新的序列集。结果,帧速率可能会大大下降。
acA2500-20gc 请参阅 Sequencer(GigE 相机)
acA2500-20gcMED 请参阅 Sequencer(GigE 相机)
acA2500-20gm 请参阅 Sequencer(GigE 相机)
acA2500-20gmMED 请参阅 Sequencer(GigE 相机)
acA2500-60uc 没有适用于您的相机型号的特定信息。
acA2500-60um 没有适用于您的相机型号的特定信息。
acA3088-16gc 请参阅 Sequencer(GigE 相机)
acA3088-16gm 请参阅 Sequencer(GigE 相机)
acA3088-57uc 没有适用于您的相机型号的特定信息。
acA3088-57um 没有适用于您的相机型号的特定信息。
acA3800-10gc 请参阅 Sequencer(GigE 相机)
acA3800-10gm 请参阅 Sequencer(GigE 相机)
acA3800-14uc 没有适用于您的相机型号的特定信息。
acA3800-14um 没有适用于您的相机型号的特定信息。
acA4024-8gc 请参阅 Sequencer(GigE 相机)
acA4024-8gm 请参阅 Sequencer(GigE 相机)
acA4024-29uc 没有适用于您的相机型号的特定信息。
acA4024-29um 没有适用于您的相机型号的特定信息。
acA4096-11gc 请参阅 Sequencer(GigE 相机)
acA4096-11gm 请参阅 Sequencer(GigE 相机)
acA4096-30uc 没有适用于您的相机型号的特定信息。
acA4096-30ucMED 没有适用于您的相机型号的特定信息。
acA4096-30um 没有适用于您的相机型号的特定信息。
acA4096-30umMED 没有适用于您的相机型号的特定信息。
acA4096-40uc 没有适用于您的相机型号的特定信息。
acA4096-40ucMED 没有适用于您的相机型号的特定信息。
acA4096-40um 没有适用于您的相机型号的特定信息。
acA4096-40umMED 没有适用于您的相机型号的特定信息。
acA4112-8gc 请参阅 Sequencer(GigE 相机)
acA4112-8gm 请参阅 Sequencer(GigE 相机)
acA4112-20uc 没有适用于您的相机型号的特定信息。
acA4112-20ucMED 没有适用于您的相机型号的特定信息。
acA4112-20um 没有适用于您的相机型号的特定信息。
acA4112-20umMED 没有适用于您的相机型号的特定信息。
acA4112-30uc 没有适用于您的相机型号的特定信息。
acA4112-30ucMED 没有适用于您的相机型号的特定信息。
acA4112-30um 没有适用于您的相机型号的特定信息。
acA4112-30umMED 没有适用于您的相机型号的特定信息。
acA4600-7gc 请参阅 Sequencer(GigE 相机)
acA4600-10uc 没有适用于您的相机型号的特定信息。
acA5472-5gc 请参阅 Sequencer(GigE 相机)
acA5472-5gm 请参阅 Sequencer(GigE 相机)
acA5472-17uc 没有适用于您的相机型号的特定信息。
acA5472-17ucMED 没有适用于您的相机型号的特定信息。
acA5472-17um 没有适用于您的相机型号的特定信息。
boA4096-93cc 不支持 Sequencer 功能
boA4096-93cm 不支持 Sequencer 功能
boA4112-68cc 不支持 Sequencer 功能
boA4112-68cm 不支持 Sequencer 功能
daA1280-54lc 不支持 Sequencer 功能
daA1280-54lm 不支持 Sequencer 功能
daA1280-54uc 不支持 Sequencer 功能
daA1280-54um 不支持 Sequencer 功能
daA1600-60lc 不支持 Sequencer 功能
daA1600-60lm 不支持 Sequencer 功能
daA1600-60uc 不支持 Sequencer 功能
daA1600-60um 不支持 Sequencer 功能
daA1920-15um 不支持 Sequencer 功能
daA1920-30uc 不支持 Sequencer 功能
daA1920-30um 不支持 Sequencer 功能
daA2500-14lc 不支持 Sequencer 功能
daA2500-14lm 不支持 Sequencer 功能
daA2500-14uc 不支持 Sequencer 功能
daA2500-14um 不支持 Sequencer 功能
daA2500-60mc 不支持 Sequencer 功能
daA2500-60mci 不支持 Sequencer 功能
daA4200-30mci 不支持 Sequencer 功能
puA1280-54uc 不支持 Sequencer 功能
puA1280-54um 不支持 Sequencer 功能
puA1600-60uc 不支持 Sequencer 功能
puA1600-60um 不支持 Sequencer 功能
puA1920-30uc 不支持 Sequencer 功能
puA1920-30um 不支持 Sequencer 功能
puA2500-14uc 不支持 Sequencer 功能
puA2500-14um 不支持 Sequencer 功能

示例代码#

// ** Configuring the sequencer sets **
// Enable sequencer configuration mode
camera.SequencerMode.SetValue(SequencerMode_Off);
camera.SequencerConfigurationMode.SetValue(SequencerConfigurationMode_On);
// Configure parameters to be stored in the first sequencer set
camera.Width.SetValue(600);
camera.Height.SetValue(300);
// Select sequencer set 0 and save the parameter values
camera.SequencerSetSelector.SetValue(0);
camera.SequencerSetSave.Execute();
// Configure parameters to be stored in the second sequencer set
camera.Width.SetValue(800);
camera.Height.SetValue(600);
// Select sequencer set 1 and save the parameter values
camera.SequencerSetSelector.SetValue(1);
camera.SequencerSetSave.Execute();
// Enable sequencer mode to operate the sequencer
camera.SequencerMode.SetValue(SequencerMode_On);
// ** Setting up path 0 **
// Enable sequencer configuration mode
camera.SequencerMode.SetValue(SequencerMode_Off);
camera.SequencerConfigurationMode.SetValue(SequencerConfigurationMode_On);
// Load sequencer set 0 and select path 0
camera.SequencerSetSelector.SetValue(0);
camera.SequencerSetLoad.Execute();
camera.SequencerPathSelector.SetValue(0);
// Set software signal 1 as "path 0" trigger signal
camera.SequencerTriggerSource.SetValue(SequencerTriggerSource_SoftwareSignal1);
// Save the changes
camera.SequencerSetSave.Execute();
// Enable sequencer mode to operate the sequencer
camera.SequencerMode.SetValue(SequencerMode_On);
// * Setting up path 1 **
// Enable sequencer configuration mode
camera.SequencerMode.SetValue(SequencerMode_Off);
camera.SequencerConfigurationMode.SetValue(SequencerConfigurationMode_On);
// Load sequencer set 0 and select path 1
camera.SequencerSetSelector.SetValue(0);
camera.SequencerSetLoad.Execute();
camera.SequencerPathSelector.SetValue(1);
// Set software signal 2 as "path 1" trigger signal
camera.SequencerTriggerSource.SetValue(SequencerTriggerSource_SoftwareSignal2);
// Save the changes
camera.SequencerSetSave.Execute();
// Assume you want to set up the following sequencer set cycle:
// 0 - 1 - 2 - 3 (- 0 - 1 - ...)
// Load the sequencer set with the highest index number to be used (here: 3)
camera.SequencerSetSelector.SetValue(3);
camera.SequencerSetLoad.Execute();
// Set the next sequencer set to 0 to "close the circle"
camera.SequencerPathSelector.SetValue(1);
camera.SequencerSetNext.SetValue(0);
// Save the changes
camera.SequencerSetSave.Execute();
// Enable sequencer mode to operate the sequencer
camera.SequencerMode.SetValue(SequencerMode_On);
// ** Advanced: Using a counter to control the sequencer **
// Enable sequencer configuration mode
camera.SequencerMode.SetValue(SequencerMode_Off);
camera.SequencerConfigurationMode.SetValue(SequencerConfigurationMode_On);
// Load sequencer set 0 and select path 1
camera.SequencerSetSelector.SetValue(0);
camera.SequencerSetLoad.Execute();
camera.SequencerPathSelector.SetValue(1);
// Set the Counter2 end event as "path 1" trigger signal
camera.SequencerTriggerSource.SetValue(SequencerTriggerSource_Counter2End);
// Save the changes
camera.SequencerSetSave.Execute();
// Select counter 2 to configure this counter
camera.CounterSelector.SetValue(CounterSelector_Counter2);
// Assume you want to set up the following sequencer set cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...)
// Load sequencer set 0 and specify that this set is to be used
// two times in a row
camera.SequencerSetSelector.SetValue(0);
camera.SequencerSetLoad.Execute();
camera.CounterDuration.SetValue(2);
camera.SequencerSetSave.Execute();
// Load sequencer set 1 and specify that this set is to be used
// three times in a row
camera.SequencerSetSelector.SetValue(1);
camera.SequencerSetLoad.Execute();
camera.CounterDuration.SetValue(3);
camera.SequencerSetSave.Execute();
// Enable sequencer mode to operate the sequencer
camera.SequencerMode.SetValue(SequencerMode_On);
INodeMap& nodemap = camera.GetNodeMap();
// ** Configuring the sequencer sets **
// Enable sequencer configuration mode
CEnumerationPtr(nodemap.GetNode("SequencerMode"))->FromString("Off");
CEnumerationPtr(nodemap.GetNode("SequencerConfigurationMode"))->FromString("On");
// Configure parameters to be stored in the first sequencer set
CIntegerPtr(nodemap.GetNode("Width"))->SetValue(600);
CIntegerPtr(nodemap.GetNode("Height"))->SetValue(300);
// Select sequencer set 0 and save the parameter values
CIntegerPtr(nodemap.GetNode("SequencerSetSelector"))->SetValue(0);
CCommandPtr(nodemap.GetNode("SequencerSetSave"))->Execute();
// Configure parameters to be stored in the second sequencer set
CIntegerPtr(nodemap.GetNode("Width"))->SetValue(800);
CIntegerPtr(nodemap.GetNode("Height"))->SetValue(600);
// Select sequencer set 1 and save the parameter values
CIntegerPtr(nodemap.GetNode("SequencerSetSelector"))->SetValue(1);
CCommandPtr(nodemap.GetNode("SequencerSetSave"))->Execute();
// Enable sequencer mode to operate the sequencer
CEnumerationPtr(nodemap.GetNode("SequencerMode"))->FromString("On");
// ** Setting up path 0 **
// Enable sequencer configuration mode
CEnumerationPtr(nodemap.GetNode("SequencerMode"))->FromString("Off");
CEnumerationPtr(nodemap.GetNode("SequencerConfigurationMode"))->FromString("On");
// Load sequencer set 0 and select path 0
CIntegerPtr(nodemap.GetNode("SequencerSetSelector"))->SetValue(0);
CCommandPtr(nodemap.GetNode("SequencerSetLoad"))->Execute();
CIntegerPtr(nodemap.GetNode("SequencerPathSelector"))->SetValue(0);
// Set software signal 1 as "path 0" trigger signal
CEnumerationPtr(nodemap.GetNode("SequencerTriggerSource"))->FromString("SoftwareSignal1");
// Save the changes
CCommandPtr(nodemap.GetNode("SequencerSetSave"))->Execute();
// Enable sequencer mode to operate the sequencer
CEnumerationPtr(nodemap.GetNode("SequencerMode"))->FromString("On");
// * Setting up path 1 **
// Enable sequencer configuration mode
CEnumerationPtr(nodemap.GetNode("SequencerMode"))->FromString("Off");
CEnumerationPtr(nodemap.GetNode("SequencerConfigurationMode"))->FromString("On");
// Load sequencer set 0 and select path 1
CIntegerPtr(nodemap.GetNode("SequencerSetSelector"))->SetValue(0);
CCommandPtr(nodemap.GetNode("SequencerSetLoad"))->Execute();
CIntegerPtr(nodemap.GetNode("SequencerPathSelector"))->SetValue(1);
// Set software signal 2 as "path 1" trigger signal
CEnumerationPtr(nodemap.GetNode("SequencerTriggerSource"))->FromString("SoftwareSignal2");
// Save the changes
CCommandPtr(nodemap.GetNode("SequencerSetSave"))->Execute();
// Assume you want to set up the following sequencer set cycle:
// 0 - 1 - 2 - 3 (- 0 - 1 - ...)
// Load the sequencer set with the highest index number to be used (here: 3)
CIntegerPtr(nodemap.GetNode("SequencerSetSelector"))->SetValue(3);
CCommandPtr(nodemap.GetNode("SequencerSetLoad"))->Execute();
// Set the next sequencer set to 0 to "close the circle"
CIntegerPtr(nodemap.GetNode("SequencerPathSelector"))->SetValue(1);
CIntegerPtr(nodemap.GetNode("SequencerSetNext"))->SetValue(0);
// Save the changes
CCommandPtr(nodemap.GetNode("SequencerSetSave"))->Execute();
// Enable sequencer mode to operate the sequencer
CEnumerationPtr(nodemap.GetNode("SequencerMode"))->FromString("On");
// ** Advanced: Using a counter to control the sequencer **
// Enable sequencer configuration mode
CEnumerationPtr(nodemap.GetNode("SequencerMode"))->FromString("Off");
CEnumerationPtr(nodemap.GetNode("SequencerConfigurationMode"))->FromString("On");
// Load sequencer set 0 and select path 1
CIntegerPtr(nodemap.GetNode("SequencerSetSelector"))->SetValue(0);
CCommandPtr(nodemap.GetNode("SequencerSetLoad"))->Execute();
CIntegerPtr(nodemap.GetNode("SequencerPathSelector"))->SetValue(1);
// Set the Counter2 end event as "path 1" trigger signal
CEnumerationPtr(nodemap.GetNode("SequencerTriggerSource"))->FromString("Counter2End");
// Save the changes
CCommandPtr(nodemap.GetNode("SequencerSetSave"))->Execute();
// Select counter 2 to configure this counter
CEnumerationPtr(nodemap.GetNode("CounterSelector"))->FromString("Counter2");
// Assume you want to set up the following sequencer set cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...)
// Load sequencer set 0 and specify that this set is to be used
// two times in a row
CIntegerPtr(nodemap.GetNode("SequencerSetSelector"))->SetValue(0);
CCommandPtr(nodemap.GetNode("SequencerSetLoad"))->Execute();
CIntegerPtr(nodemap.GetNode("CounterDuration"))->SetValue(2);
CCommandPtr(nodemap.GetNode("SequencerSetSave"))->Execute();
// Load sequencer set 1 and specify that this set is to be used
// three times in a row
CIntegerPtr(nodemap.GetNode("SequencerSetSelector"))->SetValue(1);
CCommandPtr(nodemap.GetNode("SequencerSetLoad"))->Execute();
CIntegerPtr(nodemap.GetNode("CounterDuration"))->SetValue(3);
CCommandPtr(nodemap.GetNode("SequencerSetSave"))->Execute();
// Enable sequencer mode to operate the sequencer
CEnumerationPtr(nodemap.GetNode("SequencerMode"))->FromString("On");
INodeMap& nodemap = camera.GetNodeMap();
// ** Configuring the sequencer sets **
// Enable sequencer configuration mode
CEnumParameter(nodemap, "SequencerMode").SetValue("Off");
CEnumParameter(nodemap, "SequencerConfigurationMode").SetValue("On");
// Configure parameters to be stored in the first sequencer set
CIntegerParameter(nodemap, "Width").SetValue(600);
CIntegerParameter(nodemap, "Height").SetValue(300);
// Select sequencer set 0 and save the parameter values
CIntegerParameter(nodemap, "SequencerSetSelector").SetValue(0);
CCommandParameter(nodemap, "SequencerSetSave").Execute();
// Configure parameters to be stored in the second sequencer set
CIntegerParameter(nodemap, "Width").SetValue(800);
CIntegerParameter(nodemap, "Height").SetValue(600);
// Select sequencer set 1 and save the parameter values
CIntegerParameter(nodemap, "SequencerSetSelector").SetValue(1);
CCommandParameter(nodemap, "SequencerSetSave").Execute();
// Enable sequencer mode to operate the sequencer
CEnumParameter(nodemap, "SequencerMode").SetValue("On");
// ** Setting up path 0 **
// Enable sequencer configuration mode
CEnumParameter(nodemap, "SequencerMode").SetValue("Off");
CEnumParameter(nodemap, "SequencerConfigurationMode").SetValue("On");
// Load sequencer set 0 and select path 0
CIntegerParameter(nodemap, "SequencerSetSelector").SetValue(0);
CCommandParameter(nodemap, "SequencerSetLoad").Execute();
CIntegerParameter(nodemap, "SequencerPathSelector").SetValue(0);
// Set software signal 1 as "path 0" trigger signal
CEnumParameter(nodemap, "SequencerTriggerSource").SetValue("SoftwareSignal1");
// Save the changes
CCommandParameter(nodemap, "SequencerSetSave").Execute();
// Enable sequencer mode to operate the sequencer
CEnumParameter(nodemap, "SequencerMode").SetValue("On");
// * Setting up path 1 **
// Enable sequencer configuration mode
CEnumParameter(nodemap, "SequencerMode").SetValue("Off");
CEnumParameter(nodemap, "SequencerConfigurationMode").SetValue("On");
// Load sequencer set 0 and select path 1
CIntegerParameter(nodemap, "SequencerSetSelector").SetValue(0);
CCommandParameter(nodemap, "SequencerSetLoad").Execute();
CIntegerParameter(nodemap, "SequencerPathSelector").SetValue(1);
// Set software signal 2 as "path 1" trigger signal
CEnumParameter(nodemap, "SequencerTriggerSource").SetValue("SoftwareSignal2");
// Save the changes
CCommandParameter(nodemap, "SequencerSetSave").Execute();
// Assume you want to set up the following sequencer set cycle:
// 0 - 1 - 2 - 3 (- 0 - 1 - ...)
// Load the sequencer set with the highest index number to be used (here: 3)
CIntegerParameter(nodemap, "SequencerSetSelector").SetValue(3);
CCommandParameter(nodemap, "SequencerSetLoad").Execute();
// Set the next sequencer set to 0 to "close the circle"
CIntegerParameter(nodemap, "SequencerPathSelector").SetValue(1);
CIntegerParameter(nodemap, "SequencerSetNext").SetValue(0);
// Save the changes
CCommandParameter(nodemap, "SequencerSetSave").Execute();
// Enable sequencer mode to operate the sequencer
CEnumParameter(nodemap, "SequencerMode").SetValue("On");
// ** Advanced: Using a counter to control the sequencer **
// Enable sequencer configuration mode
CEnumParameter(nodemap, "SequencerMode").SetValue("Off");
CEnumParameter(nodemap, "SequencerConfigurationMode").SetValue("On");
// Load sequencer set 0 and select path 1
CIntegerParameter(nodemap, "SequencerSetSelector").SetValue(0);
CCommandParameter(nodemap, "SequencerSetLoad").Execute();
CIntegerParameter(nodemap, "SequencerPathSelector").SetValue(1);
// Set the Counter2 end event as "path 1" trigger signal
CEnumParameter(nodemap, "SequencerTriggerSource").SetValue("Counter2End");
// Save the changes
CCommandParameter(nodemap, "SequencerSetSave").Execute();
// Select counter 2 to configure this counter
CEnumParameter(nodemap, "CounterSelector").SetValue("Counter2");
// Assume you want to set up the following sequencer set cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...)
// Load sequencer set 0 and specify that this set is to be used
// two times in a row
CIntegerParameter(nodemap, "SequencerSetSelector").SetValue(0);
CCommandParameter(nodemap, "SequencerSetLoad").Execute();
CIntegerParameter(nodemap, "CounterDuration").SetValue(2);
CCommandParameter(nodemap, "SequencerSetSave").Execute();
// Load sequencer set 1 and specify that this set is to be used
// three times in a row
CIntegerParameter(nodemap, "SequencerSetSelector").SetValue(1);
CCommandParameter(nodemap, "SequencerSetLoad").Execute();
CIntegerParameter(nodemap, "CounterDuration").SetValue(3);
CCommandParameter(nodemap, "SequencerSetSave").Execute();
// Enable sequencer mode to operate the sequencer
CEnumParameter(nodemap, "SequencerMode").SetValue("On");
// ** Configuring the sequencer sets **
// Enable sequencer configuration mode
camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.Off);
camera.Parameters[PLCamera.SequencerConfigurationMode].SetValue(PLCamera.SequencerConfigurationMode.On);
// Configure parameters to be stored in the first sequencer set
camera.Parameters[PLCamera.Width].SetValue(600);
camera.Parameters[PLCamera.Height].SetValue(300);
// Select sequencer set 0 and save the parameter values
camera.Parameters[PLCamera.SequencerSetSelector].SetValue(0);
camera.Parameters[PLCamera.SequencerSetSave].Execute();
// Configure parameters to be stored in the second sequencer set
camera.Parameters[PLCamera.Width].SetValue(800);
camera.Parameters[PLCamera.Height].SetValue(600);
// Select sequencer set 1 and save the parameter values
camera.Parameters[PLCamera.SequencerSetSelector].SetValue(1);
camera.Parameters[PLCamera.SequencerSetSave].Execute();
// Enable sequencer mode to operate the sequencer
camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.On);
// ** Setting up path 0 **
// Enable sequencer configuration mode
camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.Off);
camera.Parameters[PLCamera.SequencerConfigurationMode].SetValue(PLCamera.SequencerConfigurationMode.On);
// Load sequencer set 0 and select path 0
camera.Parameters[PLCamera.SequencerSetSelector].SetValue(0);
camera.Parameters[PLCamera.SequencerSetLoad].Execute();
camera.Parameters[PLCamera.SequencerPathSelector].SetValue(0);
// Set software signal 1 as "path 0" trigger signal
camera.Parameters[PLCamera.SequencerTriggerSource].SetValue(PLCamera.SequencerTriggerSource.SoftwareSignal1);
// Save the changes
camera.Parameters[PLCamera.SequencerSetSave].Execute();
// Enable sequencer mode to operate the sequencer
camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.On);
// * Setting up path 1 **
// Enable sequencer configuration mode
camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.Off);
camera.Parameters[PLCamera.SequencerConfigurationMode].SetValue(PLCamera.SequencerConfigurationMode.On);
// Load sequencer set 0 and select path 1
camera.Parameters[PLCamera.SequencerSetSelector].SetValue(0);
camera.Parameters[PLCamera.SequencerSetLoad].Execute();
camera.Parameters[PLCamera.SequencerPathSelector].SetValue(1);
// Set software signal 2 as "path 1" trigger signal
camera.Parameters[PLCamera.SequencerTriggerSource].SetValue(PLCamera.SequencerTriggerSource.SoftwareSignal2);
// Save the changes
camera.Parameters[PLCamera.SequencerSetSave].Execute();
// Assume you want to set up the following sequencer set cycle:
// 0 - 1 - 2 - 3 (- 0 - 1 - ...)
// Load the sequencer set with the highest index number to be used (here: 3)
camera.Parameters[PLCamera.SequencerSetSelector].SetValue(3);
camera.Parameters[PLCamera.SequencerSetLoad].Execute();
// Set the next sequencer set to 0 to "close the circle"
camera.Parameters[PLCamera.SequencerPathSelector].SetValue(1);
camera.Parameters[PLCamera.SequencerSetNext].SetValue(0);
// Save the changes
camera.Parameters[PLCamera.SequencerSetSave].Execute();
// Enable sequencer mode to operate the sequencer
camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.On);
// ** Advanced: Using a counter to control the sequencer **
// Enable sequencer configuration mode
camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.Off);
camera.Parameters[PLCamera.SequencerConfigurationMode].SetValue(PLCamera.SequencerConfigurationMode.On);
// Load sequencer set 0 and select path 1
camera.Parameters[PLCamera.SequencerSetSelector].SetValue(0);
camera.Parameters[PLCamera.SequencerSetLoad].Execute();
camera.Parameters[PLCamera.SequencerPathSelector].SetValue(1);
// Set the Counter2 end event as "path 1" trigger signal
camera.Parameters[PLCamera.SequencerTriggerSource].SetValue(PLCamera.SequencerTriggerSource.Counter2End);
// Save the changes
camera.Parameters[PLCamera.SequencerSetSave].Execute();
// Select counter 2 to configure this counter
camera.Parameters[PLCamera.CounterSelector].SetValue(PLCamera.CounterSelector.Counter2);
// Assume you want to set up the following sequencer set cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...)
// Load sequencer set 0 and specify that this set is to be used
// two times in a row
camera.Parameters[PLCamera.SequencerSetSelector].SetValue(0);
camera.Parameters[PLCamera.SequencerSetLoad].Execute();
camera.Parameters[PLCamera.CounterDuration].SetValue(2);
camera.Parameters[PLCamera.SequencerSetSave].Execute();
// Load sequencer set 1 and specify that this set is to be used
// three times in a row
camera.Parameters[PLCamera.SequencerSetSelector].SetValue(1);
camera.Parameters[PLCamera.SequencerSetLoad].Execute();
camera.Parameters[PLCamera.CounterDuration].SetValue(3);
camera.Parameters[PLCamera.SequencerSetSave].Execute();
// Enable sequencer mode to operate the sequencer
camera.Parameters[PLCamera.SequencerMode].SetValue(PLCamera.SequencerMode.On);
// ** Configuring the sequencer sets **
// Enable sequencer configuration mode
Pylon.DeviceFeatureFromString(hdev, "SequencerMode", "Off");
Pylon.DeviceFeatureFromString(hdev, "SequencerConfigurationMode", "On");
// Configure parameters to be stored in the first sequencer set
Pylon.DeviceSetIntegerFeature(hdev, "Width", 600);
Pylon.DeviceSetIntegerFeature(hdev, "Height", 300);
// Select sequencer set 0 and save the parameter values
Pylon.DeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetSave");
// Configure parameters to be stored in the second sequencer set
Pylon.DeviceSetIntegerFeature(hdev, "Width", 800);
Pylon.DeviceSetIntegerFeature(hdev, "Height", 600);
// Select sequencer set 1 and save the parameter values
Pylon.DeviceSetIntegerFeature(hdev, "SequencerSetSelector", 1);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetSave");
// Enable sequencer mode to operate the sequencer
Pylon.DeviceFeatureFromString(hdev, "SequencerMode", "On");
// ** Setting up path 0 **
// Enable sequencer configuration mode
Pylon.DeviceFeatureFromString(hdev, "SequencerMode", "Off");
Pylon.DeviceFeatureFromString(hdev, "SequencerConfigurationMode", "On");
// Load sequencer set 0 and select path 0
Pylon.DeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
Pylon.DeviceSetIntegerFeature(hdev, "SequencerPathSelector", 0);
// Set software signal 1 as "path 0" trigger signal
Pylon.DeviceFeatureFromString(hdev, "SequencerTriggerSource", "SoftwareSignal1");
// Save the changes
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetSave");
// Enable sequencer mode to operate the sequencer
Pylon.DeviceFeatureFromString(hdev, "SequencerMode", "On");
// * Setting up path 1 **
// Enable sequencer configuration mode
Pylon.DeviceFeatureFromString(hdev, "SequencerMode", "Off");
Pylon.DeviceFeatureFromString(hdev, "SequencerConfigurationMode", "On");
// Load sequencer set 0 and select path 1
Pylon.DeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
Pylon.DeviceSetIntegerFeature(hdev, "SequencerPathSelector", 1);
// Set software signal 2 as "path 1" trigger signal
Pylon.DeviceFeatureFromString(hdev, "SequencerTriggerSource", "SoftwareSignal2");
// Save the changes
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetSave");
// Assume you want to set up the following sequencer set cycle:
// 0 - 1 - 2 - 3 (- 0 - 1 - ...)
// Load the sequencer set with the highest index number to be used (here: 3)
Pylon.DeviceSetIntegerFeature(hdev, "SequencerSetSelector", 3);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
// Set the next sequencer set to 0 to "close the circle"
Pylon.DeviceSetIntegerFeature(hdev, "SequencerPathSelector", 1);
Pylon.DeviceSetIntegerFeature(hdev, "SequencerSetNext", 0);
// Save the changes
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetSave");
// Enable sequencer mode to operate the sequencer
Pylon.DeviceFeatureFromString(hdev, "SequencerMode", "On");
// ** Advanced: Using a counter to control the sequencer **
// Enable sequencer configuration mode
Pylon.DeviceFeatureFromString(hdev, "SequencerMode", "Off");
Pylon.DeviceFeatureFromString(hdev, "SequencerConfigurationMode", "On");
// Load sequencer set 0 and select path 1
Pylon.DeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
Pylon.DeviceSetIntegerFeature(hdev, "SequencerPathSelector", 1);
// Set the Counter2 end event as "path 1" trigger signal
Pylon.DeviceFeatureFromString(hdev, "SequencerTriggerSource", "Counter2End");
// Save the changes
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetSave");
// Select counter 2 to configure this counter
Pylon.DeviceFeatureFromString(hdev, "CounterSelector", "Counter2");
// Assume you want to set up the following sequencer set cycle:
// 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...)
// Load sequencer set 0 and specify that this set is to be used
// two times in a row
Pylon.DeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
Pylon.DeviceSetIntegerFeature(hdev, "CounterDuration", 2);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetSave");
// Load sequencer set 1 and specify that this set is to be used
// three times in a row
Pylon.DeviceSetIntegerFeature(hdev, "SequencerSetSelector", 1);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
Pylon.DeviceSetIntegerFeature(hdev, "CounterDuration", 3);
Pylon.DeviceExecuteCommandFeature(hdev, "SequencerSetSave");
// Enable sequencer mode to operate the sequencer
Pylon.DeviceFeatureFromString(hdev, "SequencerMode", "On");
/* 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 the sequencer sets ** */
/* Enable sequencer configuration mode */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerMode", "Off");
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequencerConfigurationMode", "On");
CHECK(errRes);
/* Configure parameters to be stored in the first sequencer set */
errRes = PylonDeviceSetIntegerFeature(hdev, "Width", 600);
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "Height", 300);
CHECK(errRes);
/* Select sequencer set 0 and save the parameter values */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetSave");
CHECK(errRes);
/* Configure parameters to be stored in the second sequencer set */
errRes = PylonDeviceSetIntegerFeature(hdev, "Width", 800);
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "Height", 600);
CHECK(errRes);
/* Select sequencer set 1 and save the parameter values */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerSetSelector", 1);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetSave");
CHECK(errRes);
/* Enable sequencer mode to operate the sequencer */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerMode", "On");
CHECK(errRes);
/* ** Setting up path 0 ** */
/* Enable sequencer configuration mode */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerMode", "Off");
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequencerConfigurationMode", "On");
CHECK(errRes);
/* Load sequencer set 0 and select path 0 */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerPathSelector", 0);
CHECK(errRes);
/* Set software signal 1 as "path 0" trigger signal */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerTriggerSource", "SoftwareSignal1");
CHECK(errRes);
/* Save the changes */
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetSave");
CHECK(errRes);
/* Enable sequencer mode to operate the sequencer */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerMode", "On");
CHECK(errRes);
/* * Setting up path 1 ** */
/* Enable sequencer configuration mode */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerMode", "Off");
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequencerConfigurationMode", "On");
CHECK(errRes);
/* Load sequencer set 0 and select path 1 */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerPathSelector", 1);
CHECK(errRes);
/* Set software signal 2 as "path 1" trigger signal */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerTriggerSource", "SoftwareSignal2");
CHECK(errRes);
/* Save the changes */
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetSave");
CHECK(errRes);
/* Assume you want to set up the following sequencer set cycle: */
/* 0 - 1 - 2 - 3 (- 0 - 1 - ...) */
/* Load the sequencer set with the highest index number to be used (here: 3) */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerSetSelector", 3);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
CHECK(errRes);
/* Set the next sequencer set to 0 to "close the circle" */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerPathSelector", 1);
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerSetNext", 0);
CHECK(errRes);
/* Save the changes */
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetSave");
CHECK(errRes);
/* Enable sequencer mode to operate the sequencer */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerMode", "On");
CHECK(errRes);
/* ** Advanced: Using a counter to control the sequencer ** */
/* Enable sequencer configuration mode */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerMode", "Off");
CHECK(errRes);
errRes = PylonDeviceFeatureFromString(hdev, "SequencerConfigurationMode", "On");
CHECK(errRes);
/* Load sequencer set 0 and select path 1 */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerPathSelector", 1);
CHECK(errRes);
/* Set the Counter2 end event as "path 1" trigger signal */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerTriggerSource", "Counter2End");
CHECK(errRes);
/* Save the changes */
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetSave");
CHECK(errRes);
/* Select counter 2 to configure this counter */
errRes = PylonDeviceFeatureFromString(hdev, "CounterSelector", "Counter2");
CHECK(errRes);
/* Assume you want to set up the following sequencer set cycle: */
/* 0 - 0 - 1 - 1 - 1 (- 0 - 0 - ...) */
/* Load sequencer set 0 and specify that this set is to be used */
/* two times in a row */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerSetSelector", 0);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "CounterDuration", 2);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetSave");
CHECK(errRes);
/* Load sequencer set 1 and specify that this set is to be used */
/* three times in a row */
errRes = PylonDeviceSetIntegerFeature(hdev, "SequencerSetSelector", 1);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetLoad");
CHECK(errRes);
errRes = PylonDeviceSetIntegerFeature(hdev, "CounterDuration", 3);
CHECK(errRes);
errRes = PylonDeviceExecuteCommandFeature(hdev, "SequencerSetSave");
CHECK(errRes);
/* Enable sequencer mode to operate the sequencer */
errRes = PylonDeviceFeatureFromString(hdev, "SequencerMode", "On");
CHECK(errRes);

您也可以使用 pylon Viewer 轻松设置参数。