# Do not edit this file; it was automatically generated.
import ctypes
import numpy
from nidaqmx._lib import (
lib_importer, wrapped_ndpointer, ctypes_byte_str, c_bool32)
from nidaqmx.system.physical_channel import PhysicalChannel
from nidaqmx.errors import (
check_for_error, is_string_buffer_too_small, is_array_buffer_too_small)
from nidaqmx.constants import (
Coupling, DigitalPatternCondition, Edge, Slope, Timescale, TriggerType,
WindowTriggerCondition1)
[docs]class ReferenceTrigger(object):
"""
Represents the reference trigger configurations for a DAQmx task.
"""
def __init__(self, task_handle):
self._handle = task_handle
@property
def anlg_edge_coupling(self):
"""
:class:`nidaqmx.constants.Coupling`: Specifies the coupling for
the source signal of the trigger if the source is a terminal
rather than a virtual channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAnlgEdgeRefTrigCoupling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return Coupling(val.value)
@anlg_edge_coupling.setter
def anlg_edge_coupling(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAnlgEdgeRefTrigCoupling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_int]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_coupling.deleter
def anlg_edge_coupling(self):
cfunc = lib_importer.windll.DAQmxResetAnlgEdgeRefTrigCoupling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_edge_dig_fltr_enable(self):
"""
bool: Specifies whether to apply a digital filter to the digital
output of the analog triggering circuitry (the Analog
Comparison Event). When enabled, the analog signal must stay
above or below the trigger level for the minimum pulse width
before being recognized. Use filtering for noisy trigger
signals that transition in and out of the hysteresis window
rapidly.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAnlgEdgeRefTrigDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_edge_dig_fltr_enable.setter
def anlg_edge_dig_fltr_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgEdgeRefTrigDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, c_bool32]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_dig_fltr_enable.deleter
def anlg_edge_dig_fltr_enable(self):
cfunc = lib_importer.windll.DAQmxResetAnlgEdgeRefTrigDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_edge_dig_fltr_min_pulse_width(self):
"""
float: Specifies in seconds the minimum pulse width thefilter
recognizes.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAnlgEdgeRefTrigDigFltrMinPulseWidth)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_edge_dig_fltr_min_pulse_width.setter
def anlg_edge_dig_fltr_min_pulse_width(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAnlgEdgeRefTrigDigFltrMinPulseWidth)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_dig_fltr_min_pulse_width.deleter
def anlg_edge_dig_fltr_min_pulse_width(self):
cfunc = (lib_importer.windll.
DAQmxResetAnlgEdgeRefTrigDigFltrMinPulseWidth)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_edge_dig_fltr_timebase_rate(self):
"""
float: Specifies in hertz the rate of the digital filter
timebase. NI-DAQmx uses this value to compute settings for
the filter.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAnlgEdgeRefTrigDigFltrTimebaseRate)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_edge_dig_fltr_timebase_rate.setter
def anlg_edge_dig_fltr_timebase_rate(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAnlgEdgeRefTrigDigFltrTimebaseRate)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_dig_fltr_timebase_rate.deleter
def anlg_edge_dig_fltr_timebase_rate(self):
cfunc = (lib_importer.windll.
DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseRate)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_edge_dig_fltr_timebase_src(self):
"""
str: Specifies the terminal of the signal to use as the timebase
of the digital filter.
"""
cfunc = (lib_importer.windll.
DAQmxGetAnlgEdgeRefTrigDigFltrTimebaseSrc)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@anlg_edge_dig_fltr_timebase_src.setter
def anlg_edge_dig_fltr_timebase_src(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAnlgEdgeRefTrigDigFltrTimebaseSrc)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_dig_fltr_timebase_src.deleter
def anlg_edge_dig_fltr_timebase_src(self):
cfunc = (lib_importer.windll.
DAQmxResetAnlgEdgeRefTrigDigFltrTimebaseSrc)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_edge_dig_sync_enable(self):
"""
bool: Specifies whether to synchronize recognition of
transitions in the signal to the internal timebase of the
device.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAnlgEdgeRefTrigDigSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_edge_dig_sync_enable.setter
def anlg_edge_dig_sync_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgEdgeRefTrigDigSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, c_bool32]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_dig_sync_enable.deleter
def anlg_edge_dig_sync_enable(self):
cfunc = lib_importer.windll.DAQmxResetAnlgEdgeRefTrigDigSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_edge_hyst(self):
"""
float: Specifies a hysteresis level in the units of the
measurement. If **anlg_edge_slope** is **Slope1.RISING**,
the trigger does not deassert until the source signal passes
below **anlg_edge_lvl** minus the hysteresis. If
**anlg_edge_slope** is **Slope1.FALLING**, the trigger does
not deassert until the source signal passes above
**anlg_edge_lvl** plus the hysteresis. Hysteresis is always
enabled. Set this property to a non-zero value to use
hysteresis.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAnlgEdgeRefTrigHyst
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_edge_hyst.setter
def anlg_edge_hyst(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgEdgeRefTrigHyst
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_hyst.deleter
def anlg_edge_hyst(self):
cfunc = lib_importer.windll.DAQmxResetAnlgEdgeRefTrigHyst
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_edge_lvl(self):
"""
float: Specifies in the units of the measurement the threshold
at which the Reference Trigger occurs. Use
**anlg_edge_slope** to specify on which slope to trigger at
this threshold.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAnlgEdgeRefTrigLvl
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_edge_lvl.setter
def anlg_edge_lvl(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgEdgeRefTrigLvl
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_lvl.deleter
def anlg_edge_lvl(self):
cfunc = lib_importer.windll.DAQmxResetAnlgEdgeRefTrigLvl
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_edge_slope(self):
"""
:class:`nidaqmx.constants.Slope`: Specifies on which slope of
the source signal the Reference Trigger occurs.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAnlgEdgeRefTrigSlope
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return Slope(val.value)
@anlg_edge_slope.setter
def anlg_edge_slope(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAnlgEdgeRefTrigSlope
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_int]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_slope.deleter
def anlg_edge_slope(self):
cfunc = lib_importer.windll.DAQmxResetAnlgEdgeRefTrigSlope
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_edge_src(self):
"""
str: Specifies the name of a virtual channel or terminal where
there is an analog signal to use as the source of the
Reference Trigger.
"""
cfunc = lib_importer.windll.DAQmxGetAnlgEdgeRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@anlg_edge_src.setter
def anlg_edge_src(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgEdgeRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_edge_src.deleter
def anlg_edge_src(self):
cfunc = lib_importer.windll.DAQmxResetAnlgEdgeRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_multi_edge_couplings(self):
"""
List[:class:`nidaqmx.constants.Coupling`]: Specifies an list
that describes the couplings for the corresponding source
signal of the trigger if the source is a terminal rather
than a virtual channel. Each element of the list corresponds
to a source in Ref.AnlgMultiEdge.Srcs and an element in each
of the other Analog Multi Edge property lists, if they are
not empty.
"""
cfunc = lib_importer.windll.DAQmxGetAnlgMultiEdgeRefTrigCouplings
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
wrapped_ndpointer(dtype=numpy.int32, flags=('C','W')),
ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [Coupling(e) for e in val]
@anlg_multi_edge_couplings.setter
def anlg_multi_edge_couplings(self, val):
val = numpy.int32([e.value for e in val])
cfunc = lib_importer.windll.DAQmxSetAnlgMultiEdgeRefTrigCouplings
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
wrapped_ndpointer(dtype=numpy.int32, flags=('C','W')),
ctypes.c_uint]
error_code = cfunc(
self._handle, val, len(val))
check_for_error(error_code)
@anlg_multi_edge_couplings.deleter
def anlg_multi_edge_couplings(self):
cfunc = lib_importer.windll.DAQmxResetAnlgMultiEdgeRefTrigCouplings
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_multi_edge_hysts(self):
"""
List[float]: Specifies an list of hysteresis levels in the units
of the measurement or generation. If the corresponding
element of Ref.AnlgMultiEdge.Slopes is Rising, the trigger
does not deassert until the source signal passes below the
corresponding element of Ref.AnlgMultiEdge.Lvls minus the
hysteresis. If Ref.AnlgEdge.Slope is Falling, the trigger
does not deassert until the source signal passes above
Ref.AnlgEdge.Lvl plus the hysteresis. Hysteresis is always
enabled. Set this property to a non-zero value to use
hysteresis. Each element of the list corresponds to a source
in Ref.AnlgMultiEdge.Srcs and an element in each of the
other Analog Multi Edge property lists, if they are not
empty.
"""
cfunc = lib_importer.windll.DAQmxGetAnlgMultiEdgeRefTrigHysts
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@anlg_multi_edge_hysts.setter
def anlg_multi_edge_hysts(self, val):
val = numpy.float64(val)
cfunc = lib_importer.windll.DAQmxSetAnlgMultiEdgeRefTrigHysts
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
error_code = cfunc(
self._handle, val, len(val))
check_for_error(error_code)
@anlg_multi_edge_hysts.deleter
def anlg_multi_edge_hysts(self):
cfunc = lib_importer.windll.DAQmxResetAnlgMultiEdgeRefTrigHysts
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_multi_edge_lvls(self):
"""
List[float]: Specifies an list of thresholds in the units of the
measurement or generation to start acquiring or generating
samples. Each element of the list corresponds to a source in
Ref.AnlgMultiEdge.Srcs and an element in each of the other
Analog Multi Edge property lists, if they are not empty.
"""
cfunc = lib_importer.windll.DAQmxGetAnlgMultiEdgeRefTrigLvls
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@anlg_multi_edge_lvls.setter
def anlg_multi_edge_lvls(self, val):
val = numpy.float64(val)
cfunc = lib_importer.windll.DAQmxSetAnlgMultiEdgeRefTrigLvls
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
error_code = cfunc(
self._handle, val, len(val))
check_for_error(error_code)
@anlg_multi_edge_lvls.deleter
def anlg_multi_edge_lvls(self):
cfunc = lib_importer.windll.DAQmxResetAnlgMultiEdgeRefTrigLvls
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_multi_edge_slopes(self):
"""
List[:class:`nidaqmx.constants.Slope`]: Specifies an list of
slopes on which to trigger task to start generating or
acquiring samples. Each element of the list corresponds to a
source in Ref.AnlgMultiEdge.Srcs and an element in each of
the other Analog Multi Edge property lists, if they are not
empty.
"""
cfunc = lib_importer.windll.DAQmxGetAnlgMultiEdgeRefTrigSlopes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
wrapped_ndpointer(dtype=numpy.int32, flags=('C','W')),
ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [Slope(e) for e in val]
@anlg_multi_edge_slopes.setter
def anlg_multi_edge_slopes(self, val):
val = numpy.int32([e.value for e in val])
cfunc = lib_importer.windll.DAQmxSetAnlgMultiEdgeRefTrigSlopes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
wrapped_ndpointer(dtype=numpy.int32, flags=('C','W')),
ctypes.c_uint]
error_code = cfunc(
self._handle, val, len(val))
check_for_error(error_code)
@anlg_multi_edge_slopes.deleter
def anlg_multi_edge_slopes(self):
cfunc = lib_importer.windll.DAQmxResetAnlgMultiEdgeRefTrigSlopes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_multi_edge_srcs(self):
"""
str: Specifies a List and/or range of analog sources that are
going to be used for Analog triggering. Each source
corresponds to an element in each of the Analog Multi Edge
property lists, if they are not empty.
"""
cfunc = lib_importer.windll.DAQmxGetAnlgMultiEdgeRefTrigSrcs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@anlg_multi_edge_srcs.setter
def anlg_multi_edge_srcs(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgMultiEdgeRefTrigSrcs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_multi_edge_srcs.deleter
def anlg_multi_edge_srcs(self):
cfunc = lib_importer.windll.DAQmxResetAnlgMultiEdgeRefTrigSrcs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_btm(self):
"""
float: Specifies the lower limit of the window. Specify this
value in the units of the measurement.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAnlgWinRefTrigBtm
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_win_btm.setter
def anlg_win_btm(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgWinRefTrigBtm
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_btm.deleter
def anlg_win_btm(self):
cfunc = lib_importer.windll.DAQmxResetAnlgWinRefTrigBtm
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_coupling(self):
"""
:class:`nidaqmx.constants.Coupling`: Specifies the coupling for
the source signal of the trigger if the source is a terminal
rather than a virtual channel.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAnlgWinRefTrigCoupling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return Coupling(val.value)
@anlg_win_coupling.setter
def anlg_win_coupling(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAnlgWinRefTrigCoupling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_int]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_coupling.deleter
def anlg_win_coupling(self):
cfunc = lib_importer.windll.DAQmxResetAnlgWinRefTrigCoupling
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_dig_fltr_enable(self):
"""
bool: Specifies whether to apply a digital filter to the digital
output of the analog triggering circuitry (the Analog
Comparison Event). When enabled, the analog signal must stay
within the trigger window for the minimum pulse width before
being recognized. Use filtering for noisy trigger signals
that transition in and out of the window rapidly.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAnlgWinRefTrigDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_win_dig_fltr_enable.setter
def anlg_win_dig_fltr_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgWinRefTrigDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, c_bool32]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_dig_fltr_enable.deleter
def anlg_win_dig_fltr_enable(self):
cfunc = lib_importer.windll.DAQmxResetAnlgWinRefTrigDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_dig_fltr_min_pulse_width(self):
"""
float: Specifies in seconds the minimum pulse width the filter
recognizes.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAnlgWinRefTrigDigFltrMinPulseWidth)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_win_dig_fltr_min_pulse_width.setter
def anlg_win_dig_fltr_min_pulse_width(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAnlgWinRefTrigDigFltrMinPulseWidth)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_dig_fltr_min_pulse_width.deleter
def anlg_win_dig_fltr_min_pulse_width(self):
cfunc = (lib_importer.windll.
DAQmxResetAnlgWinRefTrigDigFltrMinPulseWidth)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_dig_fltr_timebase_rate(self):
"""
float: Specifies in hertz the rate of the digital filter
timebase. NI-DAQmx uses this value to compute settings for
the filter.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetAnlgWinRefTrigDigFltrTimebaseRate)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_win_dig_fltr_timebase_rate.setter
def anlg_win_dig_fltr_timebase_rate(self, val):
cfunc = (lib_importer.windll.
DAQmxSetAnlgWinRefTrigDigFltrTimebaseRate)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_dig_fltr_timebase_rate.deleter
def anlg_win_dig_fltr_timebase_rate(self):
cfunc = (lib_importer.windll.
DAQmxResetAnlgWinRefTrigDigFltrTimebaseRate)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_dig_fltr_timebase_src(self):
"""
str: Specifies the terminal of the signal to use as the timebase
of the digital filter.
"""
cfunc = lib_importer.windll.DAQmxGetAnlgWinRefTrigDigFltrTimebaseSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@anlg_win_dig_fltr_timebase_src.setter
def anlg_win_dig_fltr_timebase_src(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgWinRefTrigDigFltrTimebaseSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_dig_fltr_timebase_src.deleter
def anlg_win_dig_fltr_timebase_src(self):
cfunc = lib_importer.windll.DAQmxResetAnlgWinRefTrigDigFltrTimebaseSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_dig_sync_enable(self):
"""
bool: Specifies whether to synchronize recognition of
transitions in the signal to the internal timebase of the
device.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetAnlgWinRefTrigDigSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_win_dig_sync_enable.setter
def anlg_win_dig_sync_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgWinRefTrigDigSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, c_bool32]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_dig_sync_enable.deleter
def anlg_win_dig_sync_enable(self):
cfunc = lib_importer.windll.DAQmxResetAnlgWinRefTrigDigSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_src(self):
"""
str: Specifies the name of a virtual channel or terminal where
there is an analog signal to use as the source of the
Reference Trigger.
"""
cfunc = lib_importer.windll.DAQmxGetAnlgWinRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@anlg_win_src.setter
def anlg_win_src(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgWinRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_src.deleter
def anlg_win_src(self):
cfunc = lib_importer.windll.DAQmxResetAnlgWinRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_top(self):
"""
float: Specifies the upper limit of the window. Specify this
value in the units of the measurement.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetAnlgWinRefTrigTop
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@anlg_win_top.setter
def anlg_win_top(self, val):
cfunc = lib_importer.windll.DAQmxSetAnlgWinRefTrigTop
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_top.deleter
def anlg_win_top(self):
cfunc = lib_importer.windll.DAQmxResetAnlgWinRefTrigTop
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def anlg_win_trig_when(self):
"""
:class:`nidaqmx.constants.WindowTriggerCondition1`: Specifies
whether the Reference Trigger occurs when the source signal
enters the window or when it leaves the window. Use
**anlg_win_btm** and **anlg_win_top** to specify the window.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetAnlgWinRefTrigWhen
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return WindowTriggerCondition1(val.value)
@anlg_win_trig_when.setter
def anlg_win_trig_when(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetAnlgWinRefTrigWhen
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_int]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@anlg_win_trig_when.deleter
def anlg_win_trig_when(self):
cfunc = lib_importer.windll.DAQmxResetAnlgWinRefTrigWhen
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def auto_trig_enable(self):
"""
bool: Specifies whether to send a software trigger to the device
when a hardware trigger is no longer active in order to
prevent a timeout.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetRefTrigAutoTrigEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@auto_trig_enable.setter
def auto_trig_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetRefTrigAutoTrigEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, c_bool32]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@auto_trig_enable.deleter
def auto_trig_enable(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigAutoTrigEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def auto_triggered(self):
"""
bool: Indicates whether a completed acquisition was triggered by
the auto trigger. If an acquisition has not completed after
the task starts, this property returns False. This property
is only applicable when **auto_trig_enable** is True.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetRefTrigAutoTriggered
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def delay(self):
"""
float: Specifies in seconds the time to wait after the device
receives the Reference Trigger before switching from
pretrigger to posttrigger samples.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetRefTrigDelay
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@delay.setter
def delay(self, val):
cfunc = lib_importer.windll.DAQmxSetRefTrigDelay
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@delay.deleter
def delay(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigDelay
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_edge_dig_fltr_enable(self):
"""
bool: Specifies whether to apply a digital filter to the trigger
signal.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDigEdgeRefTrigDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@dig_edge_dig_fltr_enable.setter
def dig_edge_dig_fltr_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetDigEdgeRefTrigDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, c_bool32]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_edge_dig_fltr_enable.deleter
def dig_edge_dig_fltr_enable(self):
cfunc = lib_importer.windll.DAQmxResetDigEdgeRefTrigDigFltrEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_edge_dig_fltr_min_pulse_width(self):
"""
float: Specifies in seconds the minimum pulse width the filter
recognizes.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetDigEdgeRefTrigDigFltrMinPulseWidth)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@dig_edge_dig_fltr_min_pulse_width.setter
def dig_edge_dig_fltr_min_pulse_width(self, val):
cfunc = (lib_importer.windll.
DAQmxSetDigEdgeRefTrigDigFltrMinPulseWidth)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_edge_dig_fltr_min_pulse_width.deleter
def dig_edge_dig_fltr_min_pulse_width(self):
cfunc = (lib_importer.windll.
DAQmxResetDigEdgeRefTrigDigFltrMinPulseWidth)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_edge_dig_fltr_timebase_rate(self):
"""
float: Specifies in hertz the rate of the digital filter
timebase. NI-DAQmx uses this value to compute settings for
the filter.
"""
val = ctypes.c_double()
cfunc = (lib_importer.windll.
DAQmxGetDigEdgeRefTrigDigFltrTimebaseRate)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@dig_edge_dig_fltr_timebase_rate.setter
def dig_edge_dig_fltr_timebase_rate(self, val):
cfunc = (lib_importer.windll.
DAQmxSetDigEdgeRefTrigDigFltrTimebaseRate)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_edge_dig_fltr_timebase_rate.deleter
def dig_edge_dig_fltr_timebase_rate(self):
cfunc = (lib_importer.windll.
DAQmxResetDigEdgeRefTrigDigFltrTimebaseRate)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_edge_dig_fltr_timebase_src(self):
"""
str: Specifies the terminal of the signal to use as the timebase
of the digital filter.
"""
cfunc = lib_importer.windll.DAQmxGetDigEdgeRefTrigDigFltrTimebaseSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@dig_edge_dig_fltr_timebase_src.setter
def dig_edge_dig_fltr_timebase_src(self, val):
cfunc = lib_importer.windll.DAQmxSetDigEdgeRefTrigDigFltrTimebaseSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_edge_dig_fltr_timebase_src.deleter
def dig_edge_dig_fltr_timebase_src(self):
cfunc = lib_importer.windll.DAQmxResetDigEdgeRefTrigDigFltrTimebaseSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_edge_dig_sync_enable(self):
"""
bool: Specifies whether to synchronize recognition of
transitions in the signal to the internal timebase of the
device.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDigEdgeRefTrigDigSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@dig_edge_dig_sync_enable.setter
def dig_edge_dig_sync_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetDigEdgeRefTrigDigSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, c_bool32]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_edge_dig_sync_enable.deleter
def dig_edge_dig_sync_enable(self):
cfunc = lib_importer.windll.DAQmxResetDigEdgeRefTrigDigSyncEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_edge_edge(self):
"""
:class:`nidaqmx.constants.Edge`: Specifies on what edge of a
digital pulse the Reference Trigger occurs.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDigEdgeRefTrigEdge
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return Edge(val.value)
@dig_edge_edge.setter
def dig_edge_edge(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetDigEdgeRefTrigEdge
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_int]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_edge_edge.deleter
def dig_edge_edge(self):
cfunc = lib_importer.windll.DAQmxResetDigEdgeRefTrigEdge
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_edge_src(self):
"""
str: Specifies the name of a terminal where there is a digital
signal to use as the source of the Reference Trigger.
"""
cfunc = lib_importer.windll.DAQmxGetDigEdgeRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@dig_edge_src.setter
def dig_edge_src(self, val):
cfunc = lib_importer.windll.DAQmxSetDigEdgeRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_edge_src.deleter
def dig_edge_src(self):
cfunc = lib_importer.windll.DAQmxResetDigEdgeRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_pattern_pattern(self):
"""
str: Specifies the digital pattern that must be met for the
Reference Trigger to occur.
"""
cfunc = lib_importer.windll.DAQmxGetDigPatternRefTrigPattern
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@dig_pattern_pattern.setter
def dig_pattern_pattern(self, val):
cfunc = lib_importer.windll.DAQmxSetDigPatternRefTrigPattern
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_pattern_pattern.deleter
def dig_pattern_pattern(self):
cfunc = lib_importer.windll.DAQmxResetDigPatternRefTrigPattern
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_pattern_src(self):
"""
:class:`nidaqmx.system.physical_channel.PhysicalChannel`:
Specifies the physical channels to use for pattern matching.
The order of the physical channels determines the order of
the pattern. If a port is included, the order of the
physical channels within the port is in ascending order.
"""
cfunc = lib_importer.windll.DAQmxGetDigPatternRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return PhysicalChannel(val.value.decode('ascii'))
@dig_pattern_src.setter
def dig_pattern_src(self, val):
val = val.name
cfunc = lib_importer.windll.DAQmxSetDigPatternRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_pattern_src.deleter
def dig_pattern_src(self):
cfunc = lib_importer.windll.DAQmxResetDigPatternRefTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def dig_pattern_trig_when(self):
"""
:class:`nidaqmx.constants.DigitalPatternCondition`: Specifies
whether the Reference Trigger occurs when the physical
channels specified with **dig_pattern_src** match or differ
from the digital pattern specified with
**dig_pattern_pattern**.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDigPatternRefTrigWhen
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return DigitalPatternCondition(val.value)
@dig_pattern_trig_when.setter
def dig_pattern_trig_when(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetDigPatternRefTrigWhen
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_int]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@dig_pattern_trig_when.deleter
def dig_pattern_trig_when(self):
cfunc = lib_importer.windll.DAQmxResetDigPatternRefTrigWhen
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def max_num_trigs_to_detect(self):
"""
int: Specifies the maximum number of times the task will detect
a reference trigger during the task. The number of times a
trigger is detected and acted upon by the module may be less
than the specified amount if the task stops early because of
trigger/retrigger window expiration. Specifying the Maximum
Number of Triggers to Detect to be 0 causes the driver to
automatically set this value to the maximum possible number
of triggers detectable by the device and configuration
combination. Note: The number of detected triggers may be
less than number of trigger events occurring, because the
devices were unable to respond to the trigger.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetRefTrigMaxNumTrigsToDetect
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@max_num_trigs_to_detect.setter
def max_num_trigs_to_detect(self, val):
cfunc = lib_importer.windll.DAQmxSetRefTrigMaxNumTrigsToDetect
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_uint]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@max_num_trigs_to_detect.deleter
def max_num_trigs_to_detect(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigMaxNumTrigsToDetect
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def pretrig_samples(self):
"""
int: Specifies the minimum number of pretrigger samples to
acquire from each channel before recognizing the reference
trigger. Post-trigger samples per channel are equal to
**samp_quant_samp_per_chan** minus the number of pretrigger
samples per channel.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetRefTrigPretrigSamples
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@pretrig_samples.setter
def pretrig_samples(self, val):
cfunc = lib_importer.windll.DAQmxSetRefTrigPretrigSamples
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_uint]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@pretrig_samples.deleter
def pretrig_samples(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigPretrigSamples
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def retrigger_win(self):
"""
float: Specifies the duration in seconds after each trigger
during which the device may trigger. Once the window has
passed, the device stops detecting triggers, and the task
will stop after the device finishes acquiring post-trigger
samples that it already started. Specifying a Retrigger
Window of -1 causes the window to be infinite.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetRefTrigRetriggerWin
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@retrigger_win.setter
def retrigger_win(self, val):
cfunc = lib_importer.windll.DAQmxSetRefTrigRetriggerWin
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@retrigger_win.deleter
def retrigger_win(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigRetriggerWin
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def retriggerable(self):
"""
bool: Specifies whether a finite task resets, acquires
pretrigger samples, and waits for another Reference Trigger
after the task completes. When you set this property to
True, the device will acquire post-trigger samples, reset,
and acquire pretrigger samples each time the Reference
Trigger occurs until the task stops. The device ignores a
trigger if it is in the process of acquiring signals.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetRefTrigRetriggerable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@retriggerable.setter
def retriggerable(self, val):
cfunc = lib_importer.windll.DAQmxSetRefTrigRetriggerable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, c_bool32]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@retriggerable.deleter
def retriggerable(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigRetriggerable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def term(self):
"""
str: Indicates the name of the internal Reference Trigger
terminal for the task. This property does not return the
name of the trigger source terminal.
"""
cfunc = lib_importer.windll.DAQmxGetRefTrigTerm
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
@property
def timestamp_enable(self):
"""
bool: Specifies whether the reference trigger timestamp is
enabled. If the timestamp is enabled but no resources are
available, an error will be returned at run time.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetRefTrigTimestampEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@timestamp_enable.setter
def timestamp_enable(self, val):
cfunc = lib_importer.windll.DAQmxSetRefTrigTimestampEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, c_bool32]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@timestamp_enable.deleter
def timestamp_enable(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigTimestampEnable
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def timestamp_timescale(self):
"""
:class:`nidaqmx.constants.Timescale`: Specifies the reference
trigger timestamp timescale.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetRefTrigTimestampTimescale
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return Timescale(val.value)
@timestamp_timescale.setter
def timestamp_timescale(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetRefTrigTimestampTimescale
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_int]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@timestamp_timescale.deleter
def timestamp_timescale(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigTimestampTimescale
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def trig_type(self):
"""
:class:`nidaqmx.constants.TriggerType`: Specifies the type of
trigger to use to mark a reference point for the
measurement.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetRefTrigType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return TriggerType(val.value)
@trig_type.setter
def trig_type(self, val):
val = val.value
cfunc = lib_importer.windll.DAQmxSetRefTrigType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_int]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@trig_type.deleter
def trig_type(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
@property
def trig_win(self):
"""
float: Specifies the duration in seconds after the task starts
during which the device may trigger. Once the window has
passed, the device stops detecting triggers, and the task
will stop after the device finishes acquiring post-trigger
samples that it already started. If no triggers are detected
during the entire period, then no data will be returned.
Specifying a Trigger Window of -1 causes the window to be
infinite.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetRefTrigTrigWin
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle,
ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._handle, ctypes.byref(val))
check_for_error(error_code)
return val.value
@trig_win.setter
def trig_win(self, val):
cfunc = lib_importer.windll.DAQmxSetRefTrigTrigWin
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_double]
error_code = cfunc(
self._handle, val)
check_for_error(error_code)
@trig_win.deleter
def trig_win(self):
cfunc = lib_importer.windll.DAQmxResetRefTrigTrigWin
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)
[docs] def cfg_anlg_edge_ref_trig(
self, trigger_source, pretrigger_samples,
trigger_slope=Slope.RISING, trigger_level=0.0):
"""
Configures the task to stop the acquisition when the device
acquires all pretrigger samples; an analog signal reaches the
level you specify; and the device acquires all post-trigger
samples. When you use a Reference Trigger, the default for the
read RelativeTo property is **first_pretrigger_sample** with a
read Offset of 0.
Args:
trigger_source (str): Is the name of a virtual channel or
terminal where there is an analog signal to use as the
source of the trigger.
pretrigger_samples (int): Specifies the minimum number of
samples to acquire per channel before recognizing the
Reference Trigger. The number of post-trigger samples
per channel is equal to **number of samples per
channel** in the DAQmx Timing function minus
**pretrigger_samples**.
trigger_slope (Optional[nidaqmx.constants.Slope]): Specifies
on which slope of the signal the Reference Trigger
occurs.
trigger_level (Optional[float]): Specifies at what threshold
to trigger. Specify this value in the units of the
measurement or generation. Use **trigger_slope** to
specify on which slope to trigger at this threshold.
"""
cfunc = lib_importer.windll.DAQmxCfgAnlgEdgeRefTrig
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int, ctypes.c_double, ctypes.c_uint]
error_code = cfunc(
self._handle, trigger_source, trigger_slope.value, trigger_level,
pretrigger_samples)
check_for_error(error_code)
[docs] def cfg_anlg_window_ref_trig(
self, trigger_source, window_top, window_bottom,
pretrigger_samples,
trigger_when=WindowTriggerCondition1.ENTERING_WINDOW):
"""
Configures the task to stop the acquisition when the device
acquires all pretrigger samples; an analog signal enters or
leaves a range you specify; and the device acquires all post-
trigger samples. When you use a Reference Trigger, the default
for the read RelativeTo property is **first_pretrigger_sample**
with a read Offset of 0.
Args:
trigger_source (str): Is the name of a virtual channel or
terminal where there is an analog signal to use as the
source of the trigger.
window_top (float): Is the upper limit of the window.
Specify this value in the units of the measurement or
generation.
window_bottom (float): Is the lower limit of the window.
Specify this value in the units of the measurement or
generation.
pretrigger_samples (int): Specifies the minimum number of
samples to acquire per channel before recognizing the
Reference Trigger. The number of post-trigger samples
per channel is equal to **number of samples per
channel** in the DAQmx Timing function minus
**pretrigger_samples**.
trigger_when (Optional[nidaqmx.constants.WindowTriggerCondition1]):
Specifies whether the Reference Trigger occurs when the
signal enters the window or when it leaves the window.
Use **window_bottom** and **window_top** to specify the
limits of the window.
"""
cfunc = lib_importer.windll.DAQmxCfgAnlgWindowRefTrig
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int, ctypes.c_double, ctypes.c_double,
ctypes.c_uint]
error_code = cfunc(
self._handle, trigger_source, trigger_when.value, window_top,
window_bottom, pretrigger_samples)
check_for_error(error_code)
[docs] def cfg_dig_edge_ref_trig(
self, trigger_source, pretrigger_samples,
trigger_edge=Edge.RISING):
"""
Configures the task to stop the acquisition when the device
acquires all pretrigger samples, detects a rising or falling
edge of a digital signal, and acquires all posttrigger samples.
When you use a Reference Trigger, the default for the read
RelativeTo property is **first_pretrigger_sample** with a read
Offset of 0.
Args:
trigger_source (str): Specifies the name of a terminal where
there is a digital signal to use as the source of the
trigger.
pretrigger_samples (int): Specifies the minimum number of
samples to acquire per channel before recognizing the
Reference Trigger. The number of post-trigger samples
per channel is equal to **number of samples per
channel** in the DAQmx Timing function minus
**pretrigger_samples**.
trigger_edge (Optional[nidaqmx.constants.Edge]): Specifies
on which edge of the digital signal the Reference
Trigger occurs.
"""
cfunc = lib_importer.windll.DAQmxCfgDigEdgeRefTrig
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes.c_int, ctypes.c_uint]
error_code = cfunc(
self._handle, trigger_source, trigger_edge.value,
pretrigger_samples)
check_for_error(error_code)
[docs] def cfg_dig_pattern_ref_trig(
self, trigger_source, trigger_pattern, pretrigger_samples,
trigger_when=DigitalPatternCondition.PATTERN_MATCHES):
"""
Configures the task to stop the acquisition when the device
acquires all pretrigger samples, matches a digital pattern, and
acquires all posttrigger samples. When you use a Reference
Trigger, the default for the read RelativeTo property is First
PretriggerSample with a read Offset of zero.
Args:
trigger_source (str): Specifies the physical channels to use
for pattern matching. The order of the physical channels
determines the order of the pattern. If a port is
included, the order of the physical channels within the
port is in ascending order.
trigger_pattern (str): Specifies the digital pattern that
must be met for the trigger to occur.
pretrigger_samples (int): Specifies the minimum number of
samples to acquire per channel before recognizing the
Reference Trigger. The number of post-trigger samples
per channel is equal to **number of samples per
channel** in the DAQmx Timing function minus
**pretrigger_samples**.
trigger_when (Optional[nidaqmx.constants.DigitalPatternCondition]):
Specifies the condition under which the trigger occurs.
"""
cfunc = lib_importer.windll.DAQmxCfgDigPatternRefTrig
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes_byte_str,
ctypes_byte_str, ctypes.c_int, ctypes.c_uint]
error_code = cfunc(
self._handle, trigger_source, trigger_pattern, trigger_when.value,
pretrigger_samples)
check_for_error(error_code)
[docs] def disable_ref_trig(self):
"""
Disables reference triggering for the measurement.
"""
cfunc = lib_importer.windll.DAQmxDisableRefTrig
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle]
error_code = cfunc(
self._handle)
check_for_error(error_code)