Source code for nidaqmx._task_modules.channels.ci_channel

# Do not edit this file; it was automatically generated.

import ctypes
import numpy

from nidaqmx._lib import lib_importer, ctypes_byte_str, c_bool32
from nidaqmx.scale import Scale
from nidaqmx.errors import (
    check_for_error, is_string_buffer_too_small, is_array_buffer_too_small)
from nidaqmx._task_modules.channels.channel import Channel
from nidaqmx.constants import (
    AngleUnits, AngularVelocityUnits, CountDirection, CounterFrequencyMethod,
    DataTransferActiveTransferMode, DigitalWidthUnits, Edge, EncoderType,
    EncoderZIndexPhase, FilterResponse, FrequencyUnits, GpsSignalType,
    InputDataTransferCondition, LengthUnits, Level, LogicLvlBehavior,
    SampClkOverrunBehavior, TerminalConfiguration, TimeUnits, UsageTypeCI,
    VelocityUnits)


[docs]class CIChannel(Channel): """ Represents one or more counter input virtual channels and their properties. """ __slots__ = [] def __repr__(self): return 'CIChannel(name={0})'.format(self._name) @property def ci_ang_encoder_initial_angle(self): """ float: Specifies the starting angle of the encoder. This value is in the units you specify with **ci_ang_encoder_units**. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIAngEncoderInitialAngle if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_ang_encoder_initial_angle.setter def ci_ang_encoder_initial_angle(self, val): cfunc = lib_importer.windll.DAQmxSetCIAngEncoderInitialAngle if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ang_encoder_initial_angle.deleter def ci_ang_encoder_initial_angle(self): cfunc = lib_importer.windll.DAQmxResetCIAngEncoderInitialAngle 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, self._name) check_for_error(error_code) @property def ci_ang_encoder_pulses_per_rev(self): """ int: Specifies the number of pulses the encoder generates per revolution. This value is the number of pulses on either signal A or signal B, not the total number of pulses on both signal A and signal B. """ val = ctypes.c_uint() cfunc = lib_importer.windll.DAQmxGetCIAngEncoderPulsesPerRev if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_ang_encoder_pulses_per_rev.setter def ci_ang_encoder_pulses_per_rev(self, val): cfunc = lib_importer.windll.DAQmxSetCIAngEncoderPulsesPerRev if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_uint] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ang_encoder_pulses_per_rev.deleter def ci_ang_encoder_pulses_per_rev(self): cfunc = lib_importer.windll.DAQmxResetCIAngEncoderPulsesPerRev 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, self._name) check_for_error(error_code) @property def ci_ang_encoder_units(self): """ :class:`nidaqmx.constants.AngleUnits`: Specifies the units to use to return angular position measurements from the channel. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIAngEncoderUnits if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return AngleUnits(val.value) @ci_ang_encoder_units.setter def ci_ang_encoder_units(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIAngEncoderUnits 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ang_encoder_units.deleter def ci_ang_encoder_units(self): cfunc = lib_importer.windll.DAQmxResetCIAngEncoderUnits 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, self._name) check_for_error(error_code) @property def ci_count(self): """ int: Indicates the current value of the count register. """ val = ctypes.c_uint() cfunc = lib_importer.windll.DAQmxGetCICount if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @property def ci_count_edges_active_edge(self): """ :class:`nidaqmx.constants.Edge`: Specifies on which edges to increment or decrement the counter. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesActiveEdge if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return Edge(val.value) @ci_count_edges_active_edge.setter def ci_count_edges_active_edge(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesActiveEdge 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_active_edge.deleter def ci_count_edges_active_edge(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesActiveEdge 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_dir_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountDirDigFltrEnable) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_dir_dig_fltr_enable.setter def ci_count_edges_count_dir_dig_fltr_enable(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountDirDigFltrEnable) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_dir_dig_fltr_enable.deleter def ci_count_edges_count_dir_dig_fltr_enable(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountDirDigFltrEnable) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_dir_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. DAQmxGetCICountEdgesCountDirDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_dir_dig_fltr_min_pulse_width.setter def ci_count_edges_count_dir_dig_fltr_min_pulse_width(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountDirDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_dir_dig_fltr_min_pulse_width.deleter def ci_count_edges_count_dir_dig_fltr_min_pulse_width(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountDirDigFltrMinPulseWidth) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_dir_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountDirDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_dir_dig_fltr_timebase_rate.setter def ci_count_edges_count_dir_dig_fltr_timebase_rate(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountDirDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_dir_dig_fltr_timebase_rate.deleter def ci_count_edges_count_dir_dig_fltr_timebase_rate(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountDirDigFltrTimebaseRate) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_dir_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountDirDigFltrTimebaseSrc) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_count_edges_count_dir_dig_fltr_timebase_src.setter def ci_count_edges_count_dir_dig_fltr_timebase_src(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountDirDigFltrTimebaseSrc) 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_dir_dig_fltr_timebase_src.deleter def ci_count_edges_count_dir_dig_fltr_timebase_src(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountDirDigFltrTimebaseSrc) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_dir_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. DAQmxGetCICountEdgesCountDirDigSyncEnable) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_dir_dig_sync_enable.setter def ci_count_edges_count_dir_dig_sync_enable(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountDirDigSyncEnable) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_dir_dig_sync_enable.deleter def ci_count_edges_count_dir_dig_sync_enable(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountDirDigSyncEnable) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_dir_hyst(self): """ float: Specifies a hysteresis level applied to the **ci_count_edges_count_dir_thresh_voltage**. The source signal must fall below **ci_count_edges_count_dir_thresh_voltage** minus the hysteresis before a change in count direction occurs. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCICountEdgesCountDirHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_dir_hyst.setter def ci_count_edges_count_dir_hyst(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesCountDirHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_dir_hyst.deleter def ci_count_edges_count_dir_hyst(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesCountDirHyst 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_dir_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the count reset line. """ val = ctypes.c_int() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountDirLogicLvlBehavior) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_count_edges_count_dir_logic_lvl_behavior.setter def ci_count_edges_count_dir_logic_lvl_behavior(self, val): val = val.value cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountDirLogicLvlBehavior) 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_dir_logic_lvl_behavior.deleter def ci_count_edges_count_dir_logic_lvl_behavior(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountDirLogicLvlBehavior) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_dir_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the input terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesCountDirTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_count_edges_count_dir_term_cfg.setter def ci_count_edges_count_dir_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesCountDirTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_dir_term_cfg.deleter def ci_count_edges_count_dir_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesCountDirTermCfg 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_dir_thresh_voltage(self): """ float: Specifies the voltage level applied to the Count Direction terminal. When the signal is above this threshold, the counter counts up. When the signal is below this threshold, the counter counts down. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountDirThreshVoltage) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_dir_thresh_voltage.setter def ci_count_edges_count_dir_thresh_voltage(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountDirThreshVoltage) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_dir_thresh_voltage.deleter def ci_count_edges_count_dir_thresh_voltage(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountDirThreshVoltage) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_active_edge(self): """ :class:`nidaqmx.constants.Edge`: Specifies on which edge of the signal to reset the count. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesCountResetActiveEdge if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return Edge(val.value) @ci_count_edges_count_reset_active_edge.setter def ci_count_edges_count_reset_active_edge(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesCountResetActiveEdge 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_active_edge.deleter def ci_count_edges_count_reset_active_edge(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesCountResetActiveEdge 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountResetDigFltrEnable) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_reset_dig_fltr_enable.setter def ci_count_edges_count_reset_dig_fltr_enable(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountResetDigFltrEnable) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_dig_fltr_enable.deleter def ci_count_edges_count_reset_dig_fltr_enable(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountResetDigFltrEnable) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_dig_fltr_min_pulse_width(self): """ float: Specifies the minimum pulse width the filter recognizes. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountResetDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_reset_dig_fltr_min_pulse_width.setter def ci_count_edges_count_reset_dig_fltr_min_pulse_width(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountResetDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_dig_fltr_min_pulse_width.deleter def ci_count_edges_count_reset_dig_fltr_min_pulse_width(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountResetDigFltrMinPulseWidth) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountResetDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_reset_dig_fltr_timebase_rate.setter def ci_count_edges_count_reset_dig_fltr_timebase_rate(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountResetDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_dig_fltr_timebase_rate.deleter def ci_count_edges_count_reset_dig_fltr_timebase_rate(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountResetDigFltrTimebaseRate) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_dig_fltr_timebase_src(self): """ str: Specifies the input of the signal to use as the timebase of the pulse width filter. """ cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountResetDigFltrTimebaseSrc) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_count_edges_count_reset_dig_fltr_timebase_src.setter def ci_count_edges_count_reset_dig_fltr_timebase_src(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountResetDigFltrTimebaseSrc) 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_dig_fltr_timebase_src.deleter def ci_count_edges_count_reset_dig_fltr_timebase_src(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountResetDigFltrTimebaseSrc) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_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. DAQmxGetCICountEdgesCountResetDigSyncEnable) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_reset_dig_sync_enable.setter def ci_count_edges_count_reset_dig_sync_enable(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountResetDigSyncEnable) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_dig_sync_enable.deleter def ci_count_edges_count_reset_dig_sync_enable(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountResetDigSyncEnable) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_enable(self): """ bool: Specifies whether to reset the count on the active edge specified with **ci_count_edges_count_reset_term**. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCICountEdgesCountResetEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_reset_enable.setter def ci_count_edges_count_reset_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesCountResetEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_enable.deleter def ci_count_edges_count_reset_enable(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesCountResetEnable 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_hyst(self): """ float: Specifies a hysteresis level applied to **ci_count_edges_count_reset_thresh_voltage**. When **ci_count_edges_count_reset_active_edge** is rising, the source signal must first fall below **ci_count_edges_count_reset_thresh_voltage** minus the hysteresis before a rising edge is detected at **ci_count_edges_count_reset_thresh_voltage**. When **ci_count_edges_count_reset_active_edge** is falling, the source signal must first rise above **ci_count_edges_count_reset_thresh_voltage** plus the hysteresis before a falling edge is detected at **ci_count_edges_count_reset_thresh_voltage**. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCICountEdgesCountResetHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_reset_hyst.setter def ci_count_edges_count_reset_hyst(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesCountResetHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_hyst.deleter def ci_count_edges_count_reset_hyst(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesCountResetHyst 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the count reset line. """ val = ctypes.c_int() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountResetLogicLvlBehavior) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_count_edges_count_reset_logic_lvl_behavior.setter def ci_count_edges_count_reset_logic_lvl_behavior(self, val): val = val.value cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountResetLogicLvlBehavior) 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_logic_lvl_behavior.deleter def ci_count_edges_count_reset_logic_lvl_behavior(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountResetLogicLvlBehavior) 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_reset_cnt(self): """ int: Specifies the value to reset the count to. """ val = ctypes.c_uint() cfunc = lib_importer.windll.DAQmxGetCICountEdgesCountResetResetCount if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_reset_reset_cnt.setter def ci_count_edges_count_reset_reset_cnt(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesCountResetResetCount if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_uint] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_reset_cnt.deleter def ci_count_edges_count_reset_reset_cnt(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesCountResetResetCount 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_term(self): """ str: Specifies the input terminal of the signal to reset the count. """ cfunc = lib_importer.windll.DAQmxGetCICountEdgesCountResetTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_count_edges_count_reset_term.setter def ci_count_edges_count_reset_term(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesCountResetTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_term.deleter def ci_count_edges_count_reset_term(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesCountResetTerm 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the input terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesCountResetTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_count_edges_count_reset_term_cfg.setter def ci_count_edges_count_reset_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesCountResetTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_term_cfg.deleter def ci_count_edges_count_reset_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesCountResetTermCfg 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, self._name) check_for_error(error_code) @property def ci_count_edges_count_reset_thresh_voltage(self): """ float: Specifies the voltage level at which to recognize the counter reset event. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesCountResetThreshVoltage) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_count_reset_thresh_voltage.setter def ci_count_edges_count_reset_thresh_voltage(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesCountResetThreshVoltage) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_count_reset_thresh_voltage.deleter def ci_count_edges_count_reset_thresh_voltage(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesCountResetThreshVoltage) 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, self._name) check_for_error(error_code) @property def ci_count_edges_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCICountEdgesDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_dig_fltr_enable.setter def ci_count_edges_dig_fltr_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_dig_fltr_enable.deleter def ci_count_edges_dig_fltr_enable(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesDigFltrEnable 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, self._name) check_for_error(error_code) @property def ci_count_edges_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.DAQmxGetCICountEdgesDigFltrMinPulseWidth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_dig_fltr_min_pulse_width.setter def ci_count_edges_dig_fltr_min_pulse_width(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesDigFltrMinPulseWidth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_dig_fltr_min_pulse_width.deleter def ci_count_edges_dig_fltr_min_pulse_width(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesDigFltrMinPulseWidth 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, self._name) check_for_error(error_code) @property def ci_count_edges_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCICountEdgesDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_dig_fltr_timebase_rate.setter def ci_count_edges_dig_fltr_timebase_rate(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_dig_fltr_timebase_rate.deleter def ci_count_edges_dig_fltr_timebase_rate(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesDigFltrTimebaseRate 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, self._name) check_for_error(error_code) @property def ci_count_edges_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = lib_importer.windll.DAQmxGetCICountEdgesDigFltrTimebaseSrc if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_count_edges_dig_fltr_timebase_src.setter def ci_count_edges_dig_fltr_timebase_src(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesDigFltrTimebaseSrc 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_dig_fltr_timebase_src.deleter def ci_count_edges_dig_fltr_timebase_src(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesDigFltrTimebaseSrc 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, self._name) check_for_error(error_code) @property def ci_count_edges_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.DAQmxGetCICountEdgesDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_dig_sync_enable.setter def ci_count_edges_dig_sync_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_dig_sync_enable.deleter def ci_count_edges_dig_sync_enable(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesDigSyncEnable 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, self._name) check_for_error(error_code) @property def ci_count_edges_dir(self): """ :class:`nidaqmx.constants.CountDirection`: Specifies whether to increment or decrement the counter on each edge. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesDir if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return CountDirection(val.value) @ci_count_edges_dir.setter def ci_count_edges_dir(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesDir 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_dir.deleter def ci_count_edges_dir(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesDir 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, self._name) check_for_error(error_code) @property def ci_count_edges_dir_term(self): """ str: Specifies the source terminal of the digital signal that controls the count direction if **ci_count_edges_dir** is **CountDirection1.EXTERNAL_SOURCE**. """ cfunc = lib_importer.windll.DAQmxGetCICountEdgesDirTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_count_edges_dir_term.setter def ci_count_edges_dir_term(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesDirTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_dir_term.deleter def ci_count_edges_dir_term(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesDirTerm 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the gate input signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCICountEdgesGateDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_gate_dig_fltr_enable.setter def ci_count_edges_gate_dig_fltr_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesGateDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_dig_fltr_enable.deleter def ci_count_edges_gate_dig_fltr_enable(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesGateDigFltrEnable 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_dig_fltr_min_pulse_width(self): """ float: Specifies in seconds the minimum pulse width the digital filter recognizes. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesGateDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_gate_dig_fltr_min_pulse_width.setter def ci_count_edges_gate_dig_fltr_min_pulse_width(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesGateDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_dig_fltr_min_pulse_width.deleter def ci_count_edges_gate_dig_fltr_min_pulse_width(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesGateDigFltrMinPulseWidth) 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCICountEdgesGateDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_gate_dig_fltr_timebase_rate.setter def ci_count_edges_gate_dig_fltr_timebase_rate(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesGateDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_dig_fltr_timebase_rate.deleter def ci_count_edges_gate_dig_fltr_timebase_rate(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesGateDigFltrTimebaseRate) 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = (lib_importer.windll. DAQmxGetCICountEdgesGateDigFltrTimebaseSrc) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_count_edges_gate_dig_fltr_timebase_src.setter def ci_count_edges_gate_dig_fltr_timebase_src(self, val): cfunc = (lib_importer.windll. DAQmxSetCICountEdgesGateDigFltrTimebaseSrc) 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_dig_fltr_timebase_src.deleter def ci_count_edges_gate_dig_fltr_timebase_src(self): cfunc = (lib_importer.windll. DAQmxResetCICountEdgesGateDigFltrTimebaseSrc) 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_enable(self): """ bool: Specifies whether to enable the functionality to gate the counter input signal for a count edges measurement. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCICountEdgesGateEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_gate_enable.setter def ci_count_edges_gate_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesGateEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_enable.deleter def ci_count_edges_gate_enable(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesGateEnable 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_hyst(self): """ float: Specifies a hysteresis level applied to the **ci_count_edges_gate_thresh_voltage**. When **ci_count_edges_gate_when** is High, the source signal must fall below **ci_count_edges_gate_thresh_voltage** minus the hysteresis before the counter resumes counting. When **ci_count_edges_gate_when** is Low, the source signal must rise above **ci_count_edges_gate_thresh_voltage** plus the hysteresis before the counter resumes counting. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCICountEdgesGateHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_gate_hyst.setter def ci_count_edges_gate_hyst(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesGateHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_hyst.deleter def ci_count_edges_gate_hyst(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesGateHyst 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the gate input line. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesGateLogicLvlBehavior if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_count_edges_gate_logic_lvl_behavior.setter def ci_count_edges_gate_logic_lvl_behavior(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesGateLogicLvlBehavior 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_logic_lvl_behavior.deleter def ci_count_edges_gate_logic_lvl_behavior(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesGateLogicLvlBehavior 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_term(self): """ str: Specifies the gate terminal. """ cfunc = lib_importer.windll.DAQmxGetCICountEdgesGateTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_count_edges_gate_term.setter def ci_count_edges_gate_term(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesGateTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_term.deleter def ci_count_edges_gate_term(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesGateTerm 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the gate terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesGateTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_count_edges_gate_term_cfg.setter def ci_count_edges_gate_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesGateTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_term_cfg.deleter def ci_count_edges_gate_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesGateTermCfg 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_thresh_voltage(self): """ float: Specifies the voltage level at which to recognize the counter gate signal. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCICountEdgesGateThreshVoltage if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_gate_thresh_voltage.setter def ci_count_edges_gate_thresh_voltage(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesGateThreshVoltage if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_thresh_voltage.deleter def ci_count_edges_gate_thresh_voltage(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesGateThreshVoltage 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, self._name) check_for_error(error_code) @property def ci_count_edges_gate_when(self): """ :class:`nidaqmx.constants.Level`: Specifies whether the counter gates input pulses while the signal is high or low. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesGateWhen if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return Level(val.value) @ci_count_edges_gate_when.setter def ci_count_edges_gate_when(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesGateWhen 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_gate_when.deleter def ci_count_edges_gate_when(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesGateWhen 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, self._name) check_for_error(error_code) @property def ci_count_edges_hyst(self): """ float: Specifies a hysteresis level to apply to **ci_count_edges_thresh_voltage**. When **ci_count_edges_active_edge** is rising, the source signal must first fall below **ci_count_edges_thresh_voltage** minus the hysteresis before a rising edge is detected at **ci_count_edges_thresh_voltage**. When **ci_count_edges_active_edge** is falling, the source signal must first rise above **ci_count_edges_thresh_voltage** plus the hysteresis before a falling edge is detected at **ci_count_edges_thresh_voltage**. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCICountEdgesHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_hyst.setter def ci_count_edges_hyst(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_hyst.deleter def ci_count_edges_hyst(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesHyst 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, self._name) check_for_error(error_code) @property def ci_count_edges_initial_cnt(self): """ int: Specifies the starting value from which to count. """ val = ctypes.c_uint() cfunc = lib_importer.windll.DAQmxGetCICountEdgesInitialCnt if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_initial_cnt.setter def ci_count_edges_initial_cnt(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesInitialCnt if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_uint] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_initial_cnt.deleter def ci_count_edges_initial_cnt(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesInitialCnt 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, self._name) check_for_error(error_code) @property def ci_count_edges_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the input line. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesLogicLvlBehavior if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_count_edges_logic_lvl_behavior.setter def ci_count_edges_logic_lvl_behavior(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesLogicLvlBehavior 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_logic_lvl_behavior.deleter def ci_count_edges_logic_lvl_behavior(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesLogicLvlBehavior 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, self._name) check_for_error(error_code) @property def ci_count_edges_term(self): """ str: Specifies the input terminal of the signal to measure. """ cfunc = lib_importer.windll.DAQmxGetCICountEdgesTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_count_edges_term.setter def ci_count_edges_term(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_term.deleter def ci_count_edges_term(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesTerm 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, self._name) check_for_error(error_code) @property def ci_count_edges_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the input terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICountEdgesTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_count_edges_term_cfg.setter def ci_count_edges_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICountEdgesTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_term_cfg.deleter def ci_count_edges_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesTermCfg 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, self._name) check_for_error(error_code) @property def ci_count_edges_thresh_voltage(self): """ float: Specifies the voltage level at which to recognize waveform repetitions. Select a voltage level that occurs only once within the entire period of a waveform. You also can select a voltage that occurs only once while the voltage rises or falls. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCICountEdgesThreshVoltage if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_count_edges_thresh_voltage.setter def ci_count_edges_thresh_voltage(self, val): cfunc = lib_importer.windll.DAQmxSetCICountEdgesThreshVoltage if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_count_edges_thresh_voltage.deleter def ci_count_edges_thresh_voltage(self): cfunc = lib_importer.windll.DAQmxResetCICountEdgesThreshVoltage 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, self._name) check_for_error(error_code) @property def ci_ctr_timebase_active_edge(self): """ :class:`nidaqmx.constants.Edge`: Specifies whether a timebase cycle is from rising edge to rising edge or from falling edge to falling edge. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCICtrTimebaseActiveEdge if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return Edge(val.value) @ci_ctr_timebase_active_edge.setter def ci_ctr_timebase_active_edge(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCICtrTimebaseActiveEdge 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ctr_timebase_active_edge.deleter def ci_ctr_timebase_active_edge(self): cfunc = lib_importer.windll.DAQmxResetCICtrTimebaseActiveEdge 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, self._name) check_for_error(error_code) @property def ci_ctr_timebase_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCICtrTimebaseDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_ctr_timebase_dig_fltr_enable.setter def ci_ctr_timebase_dig_fltr_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCICtrTimebaseDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ctr_timebase_dig_fltr_enable.deleter def ci_ctr_timebase_dig_fltr_enable(self): cfunc = lib_importer.windll.DAQmxResetCICtrTimebaseDigFltrEnable 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, self._name) check_for_error(error_code) @property def ci_ctr_timebase_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. DAQmxGetCICtrTimebaseDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_ctr_timebase_dig_fltr_min_pulse_width.setter def ci_ctr_timebase_dig_fltr_min_pulse_width(self, val): cfunc = (lib_importer.windll. DAQmxSetCICtrTimebaseDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ctr_timebase_dig_fltr_min_pulse_width.deleter def ci_ctr_timebase_dig_fltr_min_pulse_width(self): cfunc = (lib_importer.windll. DAQmxResetCICtrTimebaseDigFltrMinPulseWidth) 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, self._name) check_for_error(error_code) @property def ci_ctr_timebase_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCICtrTimebaseDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_ctr_timebase_dig_fltr_timebase_rate.setter def ci_ctr_timebase_dig_fltr_timebase_rate(self, val): cfunc = lib_importer.windll.DAQmxSetCICtrTimebaseDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ctr_timebase_dig_fltr_timebase_rate.deleter def ci_ctr_timebase_dig_fltr_timebase_rate(self): cfunc = lib_importer.windll.DAQmxResetCICtrTimebaseDigFltrTimebaseRate 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, self._name) check_for_error(error_code) @property def ci_ctr_timebase_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = lib_importer.windll.DAQmxGetCICtrTimebaseDigFltrTimebaseSrc if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_ctr_timebase_dig_fltr_timebase_src.setter def ci_ctr_timebase_dig_fltr_timebase_src(self, val): cfunc = lib_importer.windll.DAQmxSetCICtrTimebaseDigFltrTimebaseSrc 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ctr_timebase_dig_fltr_timebase_src.deleter def ci_ctr_timebase_dig_fltr_timebase_src(self): cfunc = lib_importer.windll.DAQmxResetCICtrTimebaseDigFltrTimebaseSrc 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, self._name) check_for_error(error_code) @property def ci_ctr_timebase_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.DAQmxGetCICtrTimebaseDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_ctr_timebase_dig_sync_enable.setter def ci_ctr_timebase_dig_sync_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCICtrTimebaseDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ctr_timebase_dig_sync_enable.deleter def ci_ctr_timebase_dig_sync_enable(self): cfunc = lib_importer.windll.DAQmxResetCICtrTimebaseDigSyncEnable 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, self._name) check_for_error(error_code) @property def ci_ctr_timebase_master_timebase_div(self): """ int: Specifies the divisor for an external counter timebase. You can divide the counter timebase in order to measure slower signals without causing the count register to roll over. """ val = ctypes.c_uint() cfunc = lib_importer.windll.DAQmxGetCICtrTimebaseMasterTimebaseDiv if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_ctr_timebase_master_timebase_div.setter def ci_ctr_timebase_master_timebase_div(self, val): cfunc = lib_importer.windll.DAQmxSetCICtrTimebaseMasterTimebaseDiv if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_uint] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ctr_timebase_master_timebase_div.deleter def ci_ctr_timebase_master_timebase_div(self): cfunc = lib_importer.windll.DAQmxResetCICtrTimebaseMasterTimebaseDiv 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, self._name) check_for_error(error_code) @property def ci_ctr_timebase_rate(self): """ float: Specifies in Hertz the frequency of the counter timebase. Specifying the rate of a counter timebase allows you to take measurements in terms of time or frequency rather than in ticks of the timebase. If you use an external timebase and do not specify the rate, you can take measurements only in terms of ticks of the timebase. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCICtrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_ctr_timebase_rate.setter def ci_ctr_timebase_rate(self, val): cfunc = lib_importer.windll.DAQmxSetCICtrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ctr_timebase_rate.deleter def ci_ctr_timebase_rate(self): cfunc = lib_importer.windll.DAQmxResetCICtrTimebaseRate 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, self._name) check_for_error(error_code) @property def ci_ctr_timebase_src(self): """ str: Specifies the terminal of the timebase to use for the counter. """ cfunc = lib_importer.windll.DAQmxGetCICtrTimebaseSrc if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_ctr_timebase_src.setter def ci_ctr_timebase_src(self, val): cfunc = lib_importer.windll.DAQmxSetCICtrTimebaseSrc 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_ctr_timebase_src.deleter def ci_ctr_timebase_src(self): cfunc = lib_importer.windll.DAQmxResetCICtrTimebaseSrc 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, self._name) check_for_error(error_code) @property def ci_custom_scale(self): """ :class:`nidaqmx.system.scale.Scale`: Specifies the name of a custom scale for the channel. """ cfunc = lib_importer.windll.DAQmxGetCICustomScaleName if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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 Scale(val.value.decode('ascii')) @ci_custom_scale.setter def ci_custom_scale(self, val): val = val.name cfunc = lib_importer.windll.DAQmxSetCICustomScaleName 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_custom_scale.deleter def ci_custom_scale(self): cfunc = lib_importer.windll.DAQmxResetCICustomScaleName 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, self._name) check_for_error(error_code) @property def ci_data_xfer_mech(self): """ :class:`nidaqmx.constants.DataTransferActiveTransferMode`: Specifies the data transfer mode for the channel. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIDataXferMech if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return DataTransferActiveTransferMode(val.value) @ci_data_xfer_mech.setter def ci_data_xfer_mech(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIDataXferMech 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_data_xfer_mech.deleter def ci_data_xfer_mech(self): cfunc = lib_importer.windll.DAQmxResetCIDataXferMech 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, self._name) check_for_error(error_code) @property def ci_data_xfer_req_cond(self): """ :class:`nidaqmx.constants.InputDataTransferCondition`: Specifies under what condition to transfer data from the onboard memory of the device to the buffer. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIDataXferReqCond if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return InputDataTransferCondition(val.value) @ci_data_xfer_req_cond.setter def ci_data_xfer_req_cond(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIDataXferReqCond 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_data_xfer_req_cond.deleter def ci_data_xfer_req_cond(self): cfunc = lib_importer.windll.DAQmxResetCIDataXferReqCond 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, self._name) check_for_error(error_code) @property def ci_dup_count_prevention(self): """ bool: Specifies whether to enable duplicate count prevention for the channel. Duplicate count prevention is enabled by default. Setting **ci_prescaler** disables duplicate count prevention unless you explicitly enable it. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIDupCountPrevent if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_dup_count_prevention.setter def ci_dup_count_prevention(self, val): cfunc = lib_importer.windll.DAQmxSetCIDupCountPrevent if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_dup_count_prevention.deleter def ci_dup_count_prevention(self): cfunc = lib_importer.windll.DAQmxResetCIDupCountPrevent 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, self._name) check_for_error(error_code) @property def ci_duty_cycle_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIDutyCycleDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_duty_cycle_dig_fltr_enable.setter def ci_duty_cycle_dig_fltr_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIDutyCycleDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_duty_cycle_dig_fltr_enable.deleter def ci_duty_cycle_dig_fltr_enable(self): cfunc = lib_importer.windll.DAQmxResetCIDutyCycleDigFltrEnable 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, self._name) check_for_error(error_code) @property def ci_duty_cycle_dig_fltr_min_pulse_width(self): """ float: Specifies in seconds the minimum pulse width the digital filter recognizes. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIDutyCycleDigFltrMinPulseWidth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_duty_cycle_dig_fltr_min_pulse_width.setter def ci_duty_cycle_dig_fltr_min_pulse_width(self, val): cfunc = lib_importer.windll.DAQmxSetCIDutyCycleDigFltrMinPulseWidth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_duty_cycle_dig_fltr_min_pulse_width.deleter def ci_duty_cycle_dig_fltr_min_pulse_width(self): cfunc = lib_importer.windll.DAQmxResetCIDutyCycleDigFltrMinPulseWidth 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, self._name) check_for_error(error_code) @property def ci_duty_cycle_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIDutyCycleDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_duty_cycle_dig_fltr_timebase_rate.setter def ci_duty_cycle_dig_fltr_timebase_rate(self, val): cfunc = lib_importer.windll.DAQmxSetCIDutyCycleDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_duty_cycle_dig_fltr_timebase_rate.deleter def ci_duty_cycle_dig_fltr_timebase_rate(self): cfunc = lib_importer.windll.DAQmxResetCIDutyCycleDigFltrTimebaseRate 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, self._name) check_for_error(error_code) @property def ci_duty_cycle_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = lib_importer.windll.DAQmxGetCIDutyCycleDigFltrTimebaseSrc if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_duty_cycle_dig_fltr_timebase_src.setter def ci_duty_cycle_dig_fltr_timebase_src(self, val): cfunc = lib_importer.windll.DAQmxSetCIDutyCycleDigFltrTimebaseSrc 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_duty_cycle_dig_fltr_timebase_src.deleter def ci_duty_cycle_dig_fltr_timebase_src(self): cfunc = lib_importer.windll.DAQmxResetCIDutyCycleDigFltrTimebaseSrc 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, self._name) check_for_error(error_code) @property def ci_duty_cycle_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the input line. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIDutyCycleLogicLvlBehavior if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_duty_cycle_logic_lvl_behavior.setter def ci_duty_cycle_logic_lvl_behavior(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIDutyCycleLogicLvlBehavior 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_duty_cycle_logic_lvl_behavior.deleter def ci_duty_cycle_logic_lvl_behavior(self): cfunc = lib_importer.windll.DAQmxResetCIDutyCycleLogicLvlBehavior 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, self._name) check_for_error(error_code) @property def ci_duty_cycle_starting_edge(self): """ :class:`nidaqmx.constants.Edge`: Specifies which edge of the input signal to begin the duty cycle measurement. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIDutyCycleStartingEdge if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return Edge(val.value) @ci_duty_cycle_starting_edge.setter def ci_duty_cycle_starting_edge(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIDutyCycleStartingEdge 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_duty_cycle_starting_edge.deleter def ci_duty_cycle_starting_edge(self): cfunc = lib_importer.windll.DAQmxResetCIDutyCycleStartingEdge 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, self._name) check_for_error(error_code) @property def ci_duty_cycle_term(self): """ str: Specifies the input terminal of the signal to measure. """ cfunc = lib_importer.windll.DAQmxGetCIDutyCycleTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_duty_cycle_term.setter def ci_duty_cycle_term(self, val): cfunc = lib_importer.windll.DAQmxSetCIDutyCycleTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_duty_cycle_term.deleter def ci_duty_cycle_term(self): cfunc = lib_importer.windll.DAQmxResetCIDutyCycleTerm 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, self._name) check_for_error(error_code) @property def ci_duty_cycle_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the input terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIDutyCycleTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_duty_cycle_term_cfg.setter def ci_duty_cycle_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIDutyCycleTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_duty_cycle_term_cfg.deleter def ci_duty_cycle_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCIDutyCycleTermCfg 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, self._name) check_for_error(error_code) @property def ci_encoder_a_input_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIEncoderAInputDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_a_input_dig_fltr_enable.setter def ci_encoder_a_input_dig_fltr_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderAInputDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_a_input_dig_fltr_enable.deleter def ci_encoder_a_input_dig_fltr_enable(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderAInputDigFltrEnable 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, self._name) check_for_error(error_code) @property def ci_encoder_a_input_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. DAQmxGetCIEncoderAInputDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_a_input_dig_fltr_min_pulse_width.setter def ci_encoder_a_input_dig_fltr_min_pulse_width(self, val): cfunc = (lib_importer.windll. DAQmxSetCIEncoderAInputDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_a_input_dig_fltr_min_pulse_width.deleter def ci_encoder_a_input_dig_fltr_min_pulse_width(self): cfunc = (lib_importer.windll. DAQmxResetCIEncoderAInputDigFltrMinPulseWidth) 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, self._name) check_for_error(error_code) @property def ci_encoder_a_input_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCIEncoderAInputDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_a_input_dig_fltr_timebase_rate.setter def ci_encoder_a_input_dig_fltr_timebase_rate(self, val): cfunc = (lib_importer.windll. DAQmxSetCIEncoderAInputDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_a_input_dig_fltr_timebase_rate.deleter def ci_encoder_a_input_dig_fltr_timebase_rate(self): cfunc = (lib_importer.windll. DAQmxResetCIEncoderAInputDigFltrTimebaseRate) 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, self._name) check_for_error(error_code) @property def ci_encoder_a_input_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = (lib_importer.windll. DAQmxGetCIEncoderAInputDigFltrTimebaseSrc) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_encoder_a_input_dig_fltr_timebase_src.setter def ci_encoder_a_input_dig_fltr_timebase_src(self, val): cfunc = (lib_importer.windll. DAQmxSetCIEncoderAInputDigFltrTimebaseSrc) 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_a_input_dig_fltr_timebase_src.deleter def ci_encoder_a_input_dig_fltr_timebase_src(self): cfunc = (lib_importer.windll. DAQmxResetCIEncoderAInputDigFltrTimebaseSrc) 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, self._name) check_for_error(error_code) @property def ci_encoder_a_input_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.DAQmxGetCIEncoderAInputDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_a_input_dig_sync_enable.setter def ci_encoder_a_input_dig_sync_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderAInputDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_a_input_dig_sync_enable.deleter def ci_encoder_a_input_dig_sync_enable(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderAInputDigSyncEnable 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, self._name) check_for_error(error_code) @property def ci_encoder_a_input_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the input line. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIEncoderAInputLogicLvlBehavior if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_encoder_a_input_logic_lvl_behavior.setter def ci_encoder_a_input_logic_lvl_behavior(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIEncoderAInputLogicLvlBehavior 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_a_input_logic_lvl_behavior.deleter def ci_encoder_a_input_logic_lvl_behavior(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderAInputLogicLvlBehavior 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, self._name) check_for_error(error_code) @property def ci_encoder_a_input_term(self): """ str: Specifies the terminal to which signal A is connected. """ cfunc = lib_importer.windll.DAQmxGetCIEncoderAInputTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_encoder_a_input_term.setter def ci_encoder_a_input_term(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderAInputTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_a_input_term.deleter def ci_encoder_a_input_term(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderAInputTerm 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, self._name) check_for_error(error_code) @property def ci_encoder_a_input_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the input terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIEncoderAInputTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_encoder_a_input_term_cfg.setter def ci_encoder_a_input_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIEncoderAInputTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_a_input_term_cfg.deleter def ci_encoder_a_input_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderAInputTermCfg 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, self._name) check_for_error(error_code) @property def ci_encoder_b_input_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIEncoderBInputDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_b_input_dig_fltr_enable.setter def ci_encoder_b_input_dig_fltr_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderBInputDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_b_input_dig_fltr_enable.deleter def ci_encoder_b_input_dig_fltr_enable(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderBInputDigFltrEnable 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, self._name) check_for_error(error_code) @property def ci_encoder_b_input_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. DAQmxGetCIEncoderBInputDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_b_input_dig_fltr_min_pulse_width.setter def ci_encoder_b_input_dig_fltr_min_pulse_width(self, val): cfunc = (lib_importer.windll. DAQmxSetCIEncoderBInputDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_b_input_dig_fltr_min_pulse_width.deleter def ci_encoder_b_input_dig_fltr_min_pulse_width(self): cfunc = (lib_importer.windll. DAQmxResetCIEncoderBInputDigFltrMinPulseWidth) 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, self._name) check_for_error(error_code) @property def ci_encoder_b_input_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCIEncoderBInputDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_b_input_dig_fltr_timebase_rate.setter def ci_encoder_b_input_dig_fltr_timebase_rate(self, val): cfunc = (lib_importer.windll. DAQmxSetCIEncoderBInputDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_b_input_dig_fltr_timebase_rate.deleter def ci_encoder_b_input_dig_fltr_timebase_rate(self): cfunc = (lib_importer.windll. DAQmxResetCIEncoderBInputDigFltrTimebaseRate) 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, self._name) check_for_error(error_code) @property def ci_encoder_b_input_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = (lib_importer.windll. DAQmxGetCIEncoderBInputDigFltrTimebaseSrc) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_encoder_b_input_dig_fltr_timebase_src.setter def ci_encoder_b_input_dig_fltr_timebase_src(self, val): cfunc = (lib_importer.windll. DAQmxSetCIEncoderBInputDigFltrTimebaseSrc) 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_b_input_dig_fltr_timebase_src.deleter def ci_encoder_b_input_dig_fltr_timebase_src(self): cfunc = (lib_importer.windll. DAQmxResetCIEncoderBInputDigFltrTimebaseSrc) 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, self._name) check_for_error(error_code) @property def ci_encoder_b_input_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.DAQmxGetCIEncoderBInputDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_b_input_dig_sync_enable.setter def ci_encoder_b_input_dig_sync_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderBInputDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_b_input_dig_sync_enable.deleter def ci_encoder_b_input_dig_sync_enable(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderBInputDigSyncEnable 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, self._name) check_for_error(error_code) @property def ci_encoder_b_input_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the input line. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIEncoderBInputLogicLvlBehavior if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_encoder_b_input_logic_lvl_behavior.setter def ci_encoder_b_input_logic_lvl_behavior(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIEncoderBInputLogicLvlBehavior 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_b_input_logic_lvl_behavior.deleter def ci_encoder_b_input_logic_lvl_behavior(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderBInputLogicLvlBehavior 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, self._name) check_for_error(error_code) @property def ci_encoder_b_input_term(self): """ str: Specifies the terminal to which signal B is connected. """ cfunc = lib_importer.windll.DAQmxGetCIEncoderBInputTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_encoder_b_input_term.setter def ci_encoder_b_input_term(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderBInputTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_b_input_term.deleter def ci_encoder_b_input_term(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderBInputTerm 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, self._name) check_for_error(error_code) @property def ci_encoder_b_input_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the input terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIEncoderBInputTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_encoder_b_input_term_cfg.setter def ci_encoder_b_input_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIEncoderBInputTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_b_input_term_cfg.deleter def ci_encoder_b_input_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderBInputTermCfg 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, self._name) check_for_error(error_code) @property def ci_encoder_decoding_type(self): """ :class:`nidaqmx.constants.EncoderType`: Specifies how to count and interpret the pulses the encoder generates on signal A and signal B. **EncoderType2.X_1**, **EncoderType2.X_2**, and **EncoderType2.X_4** are valid for quadrature encoders only. **EncoderType2.TWO_PULSE_COUNTING** is valid for two- pulse encoders only. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIEncoderDecodingType if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return EncoderType(val.value) @ci_encoder_decoding_type.setter def ci_encoder_decoding_type(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIEncoderDecodingType 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_decoding_type.deleter def ci_encoder_decoding_type(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderDecodingType 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, self._name) check_for_error(error_code) @property def ci_encoder_z_index_enable(self): """ bool: Specifies whether to use Z indexing for the channel. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIEncoderZIndexEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_z_index_enable.setter def ci_encoder_z_index_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderZIndexEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_index_enable.deleter def ci_encoder_z_index_enable(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderZIndexEnable 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, self._name) check_for_error(error_code) @property def ci_encoder_z_index_phase(self): """ :class:`nidaqmx.constants.EncoderZIndexPhase`: Specifies the states at which signal A and signal B must be while signal Z is high for NI-DAQmx to reset the measurement. If signal Z is never high while signal A and signal B are high, for example, you must choose a phase other than **EncoderZIndexPhase1.AHIGH_BHIGH**. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIEncoderZIndexPhase if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return EncoderZIndexPhase(val.value) @ci_encoder_z_index_phase.setter def ci_encoder_z_index_phase(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIEncoderZIndexPhase 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_index_phase.deleter def ci_encoder_z_index_phase(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderZIndexPhase 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, self._name) check_for_error(error_code) @property def ci_encoder_z_index_val(self): """ float: Specifies the value to which to reset the measurement when signal Z is high and signal A and signal B are at the states you specify with **ci_encoder_z_index_phase**. Specify this value in the units of the measurement. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIEncoderZIndexVal if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_z_index_val.setter def ci_encoder_z_index_val(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderZIndexVal if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_index_val.deleter def ci_encoder_z_index_val(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderZIndexVal 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, self._name) check_for_error(error_code) @property def ci_encoder_z_input_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIEncoderZInputDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_z_input_dig_fltr_enable.setter def ci_encoder_z_input_dig_fltr_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderZInputDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_input_dig_fltr_enable.deleter def ci_encoder_z_input_dig_fltr_enable(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderZInputDigFltrEnable 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, self._name) check_for_error(error_code) @property def ci_encoder_z_input_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. DAQmxGetCIEncoderZInputDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_z_input_dig_fltr_min_pulse_width.setter def ci_encoder_z_input_dig_fltr_min_pulse_width(self, val): cfunc = (lib_importer.windll. DAQmxSetCIEncoderZInputDigFltrMinPulseWidth) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_input_dig_fltr_min_pulse_width.deleter def ci_encoder_z_input_dig_fltr_min_pulse_width(self): cfunc = (lib_importer.windll. DAQmxResetCIEncoderZInputDigFltrMinPulseWidth) 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, self._name) check_for_error(error_code) @property def ci_encoder_z_input_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = (lib_importer.windll. DAQmxGetCIEncoderZInputDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_z_input_dig_fltr_timebase_rate.setter def ci_encoder_z_input_dig_fltr_timebase_rate(self, val): cfunc = (lib_importer.windll. DAQmxSetCIEncoderZInputDigFltrTimebaseRate) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_input_dig_fltr_timebase_rate.deleter def ci_encoder_z_input_dig_fltr_timebase_rate(self): cfunc = (lib_importer.windll. DAQmxResetCIEncoderZInputDigFltrTimebaseRate) 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, self._name) check_for_error(error_code) @property def ci_encoder_z_input_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = (lib_importer.windll. DAQmxGetCIEncoderZInputDigFltrTimebaseSrc) if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_encoder_z_input_dig_fltr_timebase_src.setter def ci_encoder_z_input_dig_fltr_timebase_src(self, val): cfunc = (lib_importer.windll. DAQmxSetCIEncoderZInputDigFltrTimebaseSrc) 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_input_dig_fltr_timebase_src.deleter def ci_encoder_z_input_dig_fltr_timebase_src(self): cfunc = (lib_importer.windll. DAQmxResetCIEncoderZInputDigFltrTimebaseSrc) 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, self._name) check_for_error(error_code) @property def ci_encoder_z_input_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.DAQmxGetCIEncoderZInputDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_encoder_z_input_dig_sync_enable.setter def ci_encoder_z_input_dig_sync_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderZInputDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_input_dig_sync_enable.deleter def ci_encoder_z_input_dig_sync_enable(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderZInputDigSyncEnable 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, self._name) check_for_error(error_code) @property def ci_encoder_z_input_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the input line. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIEncoderZInputLogicLvlBehavior if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_encoder_z_input_logic_lvl_behavior.setter def ci_encoder_z_input_logic_lvl_behavior(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIEncoderZInputLogicLvlBehavior 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_input_logic_lvl_behavior.deleter def ci_encoder_z_input_logic_lvl_behavior(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderZInputLogicLvlBehavior 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, self._name) check_for_error(error_code) @property def ci_encoder_z_input_term(self): """ str: Specifies the terminal to which signal Z is connected. """ cfunc = lib_importer.windll.DAQmxGetCIEncoderZInputTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_encoder_z_input_term.setter def ci_encoder_z_input_term(self, val): cfunc = lib_importer.windll.DAQmxSetCIEncoderZInputTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_input_term.deleter def ci_encoder_z_input_term(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderZInputTerm 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, self._name) check_for_error(error_code) @property def ci_encoder_z_input_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the input terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIEncoderZInputTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_encoder_z_input_term_cfg.setter def ci_encoder_z_input_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIEncoderZInputTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_encoder_z_input_term_cfg.deleter def ci_encoder_z_input_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCIEncoderZInputTermCfg 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, self._name) check_for_error(error_code) @property def ci_filter_delay(self): """ float: Indicates the amount of time between when the input signal transitions and when the filtered sample is read by the host device. This value is in the units specified with **ci_filter_delay_units**. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIFilterDelay if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @property def ci_filter_delay_units(self): """ :class:`nidaqmx.constants.DigitalWidthUnits`: Specifies the units of **ci_filter_delay**. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIFilterDelayUnits if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return DigitalWidthUnits(val.value) @ci_filter_delay_units.setter def ci_filter_delay_units(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIFilterDelayUnits 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_filter_delay_units.deleter def ci_filter_delay_units(self): cfunc = lib_importer.windll.DAQmxResetCIFilterDelayUnits 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, self._name) check_for_error(error_code) @property def ci_filter_enable(self): """ bool: Specifies the corresponding filter enable/disable state. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIFilterEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_filter_enable.setter def ci_filter_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIFilterEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_filter_enable.deleter def ci_filter_enable(self): cfunc = lib_importer.windll.DAQmxResetCIFilterEnable 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, self._name) check_for_error(error_code) @property def ci_filter_freq(self): """ float: Specifies the corresponding filter frequency (cutoff or center) of the filter response. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIFilterFreq if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_filter_freq.setter def ci_filter_freq(self, val): cfunc = lib_importer.windll.DAQmxSetCIFilterFreq if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_filter_freq.deleter def ci_filter_freq(self): cfunc = lib_importer.windll.DAQmxResetCIFilterFreq 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, self._name) check_for_error(error_code) @property def ci_filter_order(self): """ int: Specifies the corresponding filter order and defines the slope of the filter response. """ val = ctypes.c_uint() cfunc = lib_importer.windll.DAQmxGetCIFilterOrder if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_filter_order.setter def ci_filter_order(self, val): cfunc = lib_importer.windll.DAQmxSetCIFilterOrder if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_uint] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_filter_order.deleter def ci_filter_order(self): cfunc = lib_importer.windll.DAQmxResetCIFilterOrder 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, self._name) check_for_error(error_code) @property def ci_filter_response(self): """ :class:`nidaqmx.constants.FilterResponse`: Specifies the corresponding filter response and defines the shape of the filter response. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIFilterResponse if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return FilterResponse(val.value) @ci_filter_response.setter def ci_filter_response(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIFilterResponse 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_filter_response.deleter def ci_filter_response(self): cfunc = lib_importer.windll.DAQmxResetCIFilterResponse 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, self._name) check_for_error(error_code) @property def ci_freq_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIFreqDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_freq_dig_fltr_enable.setter def ci_freq_dig_fltr_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_dig_fltr_enable.deleter def ci_freq_dig_fltr_enable(self): cfunc = lib_importer.windll.DAQmxResetCIFreqDigFltrEnable 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, self._name) check_for_error(error_code) @property def ci_freq_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.DAQmxGetCIFreqDigFltrMinPulseWidth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_freq_dig_fltr_min_pulse_width.setter def ci_freq_dig_fltr_min_pulse_width(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqDigFltrMinPulseWidth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_dig_fltr_min_pulse_width.deleter def ci_freq_dig_fltr_min_pulse_width(self): cfunc = lib_importer.windll.DAQmxResetCIFreqDigFltrMinPulseWidth 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, self._name) check_for_error(error_code) @property def ci_freq_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIFreqDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_freq_dig_fltr_timebase_rate.setter def ci_freq_dig_fltr_timebase_rate(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_dig_fltr_timebase_rate.deleter def ci_freq_dig_fltr_timebase_rate(self): cfunc = lib_importer.windll.DAQmxResetCIFreqDigFltrTimebaseRate 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, self._name) check_for_error(error_code) @property def ci_freq_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = lib_importer.windll.DAQmxGetCIFreqDigFltrTimebaseSrc if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_freq_dig_fltr_timebase_src.setter def ci_freq_dig_fltr_timebase_src(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqDigFltrTimebaseSrc 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_dig_fltr_timebase_src.deleter def ci_freq_dig_fltr_timebase_src(self): cfunc = lib_importer.windll.DAQmxResetCIFreqDigFltrTimebaseSrc 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, self._name) check_for_error(error_code) @property def ci_freq_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.DAQmxGetCIFreqDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_freq_dig_sync_enable.setter def ci_freq_dig_sync_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_dig_sync_enable.deleter def ci_freq_dig_sync_enable(self): cfunc = lib_importer.windll.DAQmxResetCIFreqDigSyncEnable 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, self._name) check_for_error(error_code) @property def ci_freq_div(self): """ int: Specifies the value by which to divide the input signal if **ci_freq_meas_meth** is **CounterFrequencyMethod.LARGE_RANGE_2_COUNTERS**. The larger the divisor, the more accurate the measurement. However, too large a value could cause the count register to roll over, which results in an incorrect measurement. """ val = ctypes.c_uint() cfunc = lib_importer.windll.DAQmxGetCIFreqDiv if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_freq_div.setter def ci_freq_div(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqDiv if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_uint] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_div.deleter def ci_freq_div(self): cfunc = lib_importer.windll.DAQmxResetCIFreqDiv 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, self._name) check_for_error(error_code) @property def ci_freq_enable_averaging(self): """ bool: Specifies whether to enable averaging mode for Sample Clock-timed frequency measurements. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIFreqEnableAveraging if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_freq_enable_averaging.setter def ci_freq_enable_averaging(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqEnableAveraging if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_enable_averaging.deleter def ci_freq_enable_averaging(self): cfunc = lib_importer.windll.DAQmxResetCIFreqEnableAveraging 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, self._name) check_for_error(error_code) @property def ci_freq_hyst(self): """ float: Specifies a hysteresis level to apply to **ci_freq_thresh_voltage**. When **ci_freq_starting_edge** is rising, the source signal must first fall below **ci_freq_thresh_voltage** minus the hysteresis before a rising edge is detected at **ci_freq_thresh_voltage**. When **ci_freq_starting_edge** is falling, the source signal must first rise above **ci_freq_thresh_voltage** plus the hysteresis before a falling edge is detected at **ci_freq_thresh_voltage**. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIFreqHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_freq_hyst.setter def ci_freq_hyst(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_hyst.deleter def ci_freq_hyst(self): cfunc = lib_importer.windll.DAQmxResetCIFreqHyst 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, self._name) check_for_error(error_code) @property def ci_freq_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the input line. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIFreqLogicLvlBehavior if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_freq_logic_lvl_behavior.setter def ci_freq_logic_lvl_behavior(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIFreqLogicLvlBehavior 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_logic_lvl_behavior.deleter def ci_freq_logic_lvl_behavior(self): cfunc = lib_importer.windll.DAQmxResetCIFreqLogicLvlBehavior 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, self._name) check_for_error(error_code) @property def ci_freq_meas_meth(self): """ :class:`nidaqmx.constants.CounterFrequencyMethod`: Specifies the method to use to measure the frequency of the signal. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIFreqMeasMeth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return CounterFrequencyMethod(val.value) @ci_freq_meas_meth.setter def ci_freq_meas_meth(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIFreqMeasMeth 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_meas_meth.deleter def ci_freq_meas_meth(self): cfunc = lib_importer.windll.DAQmxResetCIFreqMeasMeth 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, self._name) check_for_error(error_code) @property def ci_freq_meas_time(self): """ float: Specifies in seconds the length of time to measure the frequency of the signal if **ci_freq_meas_meth** is **CounterFrequencyMethod.HIGH_FREQUENCY_2_COUNTERS**. Measurement accuracy increases with increased measurement time and with increased signal frequency. If you measure a high-frequency signal for too long, however, the count register could roll over, which results in an incorrect measurement. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIFreqMeasTime if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_freq_meas_time.setter def ci_freq_meas_time(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqMeasTime if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_meas_time.deleter def ci_freq_meas_time(self): cfunc = lib_importer.windll.DAQmxResetCIFreqMeasTime 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, self._name) check_for_error(error_code) @property def ci_freq_starting_edge(self): """ :class:`nidaqmx.constants.Edge`: Specifies between which edges to measure the frequency of the signal. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIFreqStartingEdge if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return Edge(val.value) @ci_freq_starting_edge.setter def ci_freq_starting_edge(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIFreqStartingEdge 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_starting_edge.deleter def ci_freq_starting_edge(self): cfunc = lib_importer.windll.DAQmxResetCIFreqStartingEdge 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, self._name) check_for_error(error_code) @property def ci_freq_term(self): """ str: Specifies the input terminal of the signal to measure. """ cfunc = lib_importer.windll.DAQmxGetCIFreqTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_freq_term.setter def ci_freq_term(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_term.deleter def ci_freq_term(self): cfunc = lib_importer.windll.DAQmxResetCIFreqTerm 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, self._name) check_for_error(error_code) @property def ci_freq_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the input terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIFreqTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_freq_term_cfg.setter def ci_freq_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIFreqTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_term_cfg.deleter def ci_freq_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCIFreqTermCfg 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, self._name) check_for_error(error_code) @property def ci_freq_thresh_voltage(self): """ float: Specifies the voltage level at which to recognize waveform repetitions. Select a voltage level that occurs only once within the entire period of a waveform. You also can select a voltage that occurs only once while the voltage rises or falls. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIFreqThreshVoltage if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_freq_thresh_voltage.setter def ci_freq_thresh_voltage(self, val): cfunc = lib_importer.windll.DAQmxSetCIFreqThreshVoltage if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_thresh_voltage.deleter def ci_freq_thresh_voltage(self): cfunc = lib_importer.windll.DAQmxResetCIFreqThreshVoltage 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, self._name) check_for_error(error_code) @property def ci_freq_units(self): """ :class:`nidaqmx.constants.FrequencyUnits`: Specifies the units to use to return frequency measurements. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIFreqUnits if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return FrequencyUnits(val.value) @ci_freq_units.setter def ci_freq_units(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIFreqUnits 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_freq_units.deleter def ci_freq_units(self): cfunc = lib_importer.windll.DAQmxResetCIFreqUnits 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, self._name) check_for_error(error_code) @property def ci_gps_sync_method(self): """ :class:`nidaqmx.constants.GpsSignalType`: Specifies the method to use to synchronize the counter to a GPS receiver. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIGPSSyncMethod if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return GpsSignalType(val.value) @ci_gps_sync_method.setter def ci_gps_sync_method(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIGPSSyncMethod 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_gps_sync_method.deleter def ci_gps_sync_method(self): cfunc = lib_importer.windll.DAQmxResetCIGPSSyncMethod 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, self._name) check_for_error(error_code) @property def ci_gps_sync_src(self): """ str: Specifies the terminal to which the GPS synchronization signal is connected. """ cfunc = lib_importer.windll.DAQmxGetCIGPSSyncSrc if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_gps_sync_src.setter def ci_gps_sync_src(self, val): cfunc = lib_importer.windll.DAQmxSetCIGPSSyncSrc 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_gps_sync_src.deleter def ci_gps_sync_src(self): cfunc = lib_importer.windll.DAQmxResetCIGPSSyncSrc 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, self._name) check_for_error(error_code) @property def ci_lin_encoder_dist_per_pulse(self): """ float: Specifies the distance to measure for each pulse the encoder generates on signal A or signal B. This value is in the units you specify with **ci_lin_encoder_units**. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCILinEncoderDistPerPulse if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_lin_encoder_dist_per_pulse.setter def ci_lin_encoder_dist_per_pulse(self, val): cfunc = lib_importer.windll.DAQmxSetCILinEncoderDistPerPulse if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_lin_encoder_dist_per_pulse.deleter def ci_lin_encoder_dist_per_pulse(self): cfunc = lib_importer.windll.DAQmxResetCILinEncoderDistPerPulse 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, self._name) check_for_error(error_code) @property def ci_lin_encoder_initial_pos(self): """ float: Specifies the position of the encoder when the measurement begins. This value is in the units you specify with **ci_lin_encoder_units**. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCILinEncoderInitialPos if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_lin_encoder_initial_pos.setter def ci_lin_encoder_initial_pos(self, val): cfunc = lib_importer.windll.DAQmxSetCILinEncoderInitialPos if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_lin_encoder_initial_pos.deleter def ci_lin_encoder_initial_pos(self): cfunc = lib_importer.windll.DAQmxResetCILinEncoderInitialPos 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, self._name) check_for_error(error_code) @property def ci_lin_encoder_units(self): """ :class:`nidaqmx.constants.LengthUnits`: Specifies the units to use to return linear encoder measurements from the channel. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCILinEncoderUnits if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LengthUnits(val.value) @ci_lin_encoder_units.setter def ci_lin_encoder_units(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCILinEncoderUnits 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_lin_encoder_units.deleter def ci_lin_encoder_units(self): cfunc = lib_importer.windll.DAQmxResetCILinEncoderUnits 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, self._name) check_for_error(error_code) @property def ci_max(self): """ float: Specifies the maximum value you expect to measure. This value is in the units you specify with a units property. When you query this property, it returns the coerced maximum value that the hardware can measure with the current settings. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIMax if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_max.setter def ci_max(self, val): cfunc = lib_importer.windll.DAQmxSetCIMax if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_max.deleter def ci_max(self): cfunc = lib_importer.windll.DAQmxResetCIMax 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, self._name) check_for_error(error_code) @property def ci_max_meas_period(self): """ float: Specifies the maximum period (in seconds) in which the device will recognize signals. For frequency measurements, a signal with a higher period than the one set in this property will return 0 Hz. For duty cycle, the device will return 0 or 1 depending on the state of the line during the max defined period of time. Period measurements will return NaN. Pulse width measurement will return zero. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIMaxMeasPeriod if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_max_meas_period.setter def ci_max_meas_period(self, val): cfunc = lib_importer.windll.DAQmxSetCIMaxMeasPeriod if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_max_meas_period.deleter def ci_max_meas_period(self): cfunc = lib_importer.windll.DAQmxResetCIMaxMeasPeriod 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, self._name) check_for_error(error_code) @property def ci_meas_type(self): """ :class:`nidaqmx.constants.UsageTypeCI`: Indicates the measurement to take with the channel. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIMeasType if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return UsageTypeCI(val.value) @property def ci_mem_map_enable(self): """ bool: Specifies for NI-DAQmx to map hardware registers to the memory space of the application, if possible. Normally, NI- DAQmx maps hardware registers to memory accessible only to the kernel. Mapping the registers to the memory space of the application increases performance. However, if the application accesses the memory space mapped to the registers, it can adversely affect the operation of the device and possibly result in a system crash. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIMemMapEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_mem_map_enable.setter def ci_mem_map_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIMemMapEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_mem_map_enable.deleter def ci_mem_map_enable(self): cfunc = lib_importer.windll.DAQmxResetCIMemMapEnable 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, self._name) check_for_error(error_code) @property def ci_min(self): """ float: Specifies the minimum value you expect to measure. This value is in the units you specify with a units property. When you query this property, it returns the coerced minimum value that the hardware can measure with the current settings. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIMin if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_min.setter def ci_min(self, val): cfunc = lib_importer.windll.DAQmxSetCIMin if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_min.deleter def ci_min(self): cfunc = lib_importer.windll.DAQmxResetCIMin 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, self._name) check_for_error(error_code) @property def ci_num_possibly_invalid_samps(self): """ int: Indicates the number of samples that the device might have overwritten before it could transfer them to the buffer. """ val = ctypes.c_uint() cfunc = lib_importer.windll.DAQmxGetCINumPossiblyInvalidSamps if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @property def ci_output_state(self): """ :class:`nidaqmx.constants.Level`: Indicates the current state of the out terminal of the counter. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIOutputState if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return Level(val.value) @property def ci_period_dig_fltr_enable(self): """ bool: Specifies whether to apply the pulse width filter to the signal. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIPeriodDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_period_dig_fltr_enable.setter def ci_period_dig_fltr_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodDigFltrEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_dig_fltr_enable.deleter def ci_period_dig_fltr_enable(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodDigFltrEnable 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, self._name) check_for_error(error_code) @property def ci_period_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.DAQmxGetCIPeriodDigFltrMinPulseWidth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_period_dig_fltr_min_pulse_width.setter def ci_period_dig_fltr_min_pulse_width(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodDigFltrMinPulseWidth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_dig_fltr_min_pulse_width.deleter def ci_period_dig_fltr_min_pulse_width(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodDigFltrMinPulseWidth 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, self._name) check_for_error(error_code) @property def ci_period_dig_fltr_timebase_rate(self): """ float: Specifies in hertz the rate of the pulse width filter timebase. NI-DAQmx uses this value to compute settings for the filter. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIPeriodDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_period_dig_fltr_timebase_rate.setter def ci_period_dig_fltr_timebase_rate(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodDigFltrTimebaseRate if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_dig_fltr_timebase_rate.deleter def ci_period_dig_fltr_timebase_rate(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodDigFltrTimebaseRate 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, self._name) check_for_error(error_code) @property def ci_period_dig_fltr_timebase_src(self): """ str: Specifies the input terminal of the signal to use as the timebase of the pulse width filter. """ cfunc = lib_importer.windll.DAQmxGetCIPeriodDigFltrTimebaseSrc if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_period_dig_fltr_timebase_src.setter def ci_period_dig_fltr_timebase_src(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodDigFltrTimebaseSrc 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_dig_fltr_timebase_src.deleter def ci_period_dig_fltr_timebase_src(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodDigFltrTimebaseSrc 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, self._name) check_for_error(error_code) @property def ci_period_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.DAQmxGetCIPeriodDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_period_dig_sync_enable.setter def ci_period_dig_sync_enable(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodDigSyncEnable if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_dig_sync_enable.deleter def ci_period_dig_sync_enable(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodDigSyncEnable 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, self._name) check_for_error(error_code) @property def ci_period_div(self): """ int: Specifies the value by which to divide the input signal if **ci_period_meas_meth** is **CounterFrequencyMethod.LARGE_RANGE_2_COUNTERS**. The larger the divisor, the more accurate the measurement. However, too large a value could cause the count register to roll over, which results in an incorrect measurement. """ val = ctypes.c_uint() cfunc = lib_importer.windll.DAQmxGetCIPeriodDiv if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_period_div.setter def ci_period_div(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodDiv if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_uint] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_div.deleter def ci_period_div(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodDiv 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, self._name) check_for_error(error_code) @property def ci_period_enable_averaging(self): """ bool: Specifies whether to enable averaging mode for Sample Clock-timed period measurements. """ val = c_bool32() cfunc = lib_importer.windll.DAQmxGetCIPeriodEnableAveraging if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(c_bool32)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_period_enable_averaging.setter def ci_period_enable_averaging(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodEnableAveraging if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, c_bool32] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_enable_averaging.deleter def ci_period_enable_averaging(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodEnableAveraging 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, self._name) check_for_error(error_code) @property def ci_period_hyst(self): """ float: Specifies a hysteresis level to apply to **ci_period_thresh_voltage**. When **ci_period_starting_edge** is rising, the source signal must first fall below **ci_period_thresh_voltage** minus the hysteresis before a rising edge is detected at **ci_period_thresh_voltage**. When **ci_period_starting_edge** is falling, the source signal must first rise above **ci_period_thresh_voltage** plus the hysteresis before a falling edge is detected at **ci_period_thresh_voltage**. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIPeriodHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_period_hyst.setter def ci_period_hyst(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodHyst if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_hyst.deleter def ci_period_hyst(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodHyst 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, self._name) check_for_error(error_code) @property def ci_period_logic_lvl_behavior(self): """ :class:`nidaqmx.constants.LogicLvlBehavior`: Specifies the logic level behavior on the input line. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIPeriodLogicLvlBehavior if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return LogicLvlBehavior(val.value) @ci_period_logic_lvl_behavior.setter def ci_period_logic_lvl_behavior(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIPeriodLogicLvlBehavior 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_logic_lvl_behavior.deleter def ci_period_logic_lvl_behavior(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodLogicLvlBehavior 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, self._name) check_for_error(error_code) @property def ci_period_meas_meth(self): """ :class:`nidaqmx.constants.CounterFrequencyMethod`: Specifies the method to use to measure the period of the signal. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIPeriodMeasMeth if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return CounterFrequencyMethod(val.value) @ci_period_meas_meth.setter def ci_period_meas_meth(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIPeriodMeasMeth 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_meas_meth.deleter def ci_period_meas_meth(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodMeasMeth 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, self._name) check_for_error(error_code) @property def ci_period_meas_time(self): """ float: Specifies in seconds the length of time to measure the period of the signal if **ci_period_meas_meth** is **CounterFrequencyMethod.HIGH_FREQUENCY_2_COUNTERS**. Measurement accuracy increases with increased measurement time and with increased signal frequency. If you measure a high-frequency signal for too long, however, the count register could roll over, which results in an incorrect measurement. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIPeriodMeasTime if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_period_meas_time.setter def ci_period_meas_time(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodMeasTime if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_meas_time.deleter def ci_period_meas_time(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodMeasTime 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, self._name) check_for_error(error_code) @property def ci_period_starting_edge(self): """ :class:`nidaqmx.constants.Edge`: Specifies between which edges to measure the period of the signal. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIPeriodStartingEdge if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return Edge(val.value) @ci_period_starting_edge.setter def ci_period_starting_edge(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIPeriodStartingEdge 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_starting_edge.deleter def ci_period_starting_edge(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodStartingEdge 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, self._name) check_for_error(error_code) @property def ci_period_term(self): """ str: Specifies the input terminal of the signal to measure. """ cfunc = lib_importer.windll.DAQmxGetCIPeriodTerm if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, 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, self._name, 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') @ci_period_term.setter def ci_period_term(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodTerm 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_term.deleter def ci_period_term(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodTerm 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, self._name) check_for_error(error_code) @property def ci_period_term_cfg(self): """ :class:`nidaqmx.constants.TerminalConfiguration`: Specifies the input terminal configuration. """ val = ctypes.c_int() cfunc = lib_importer.windll.DAQmxGetCIPeriodTermCfg if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_int)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return TerminalConfiguration(val.value) @ci_period_term_cfg.setter def ci_period_term_cfg(self, val): val = val.value cfunc = lib_importer.windll.DAQmxSetCIPeriodTermCfg 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] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_term_cfg.deleter def ci_period_term_cfg(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodTermCfg 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, self._name) check_for_error(error_code) @property def ci_period_thresh_voltage(self): """ float: Specifies the voltage level at which to recognize waveform repetitions. Select a voltage level that occurs only once within the entire period of a waveform. You also can select a voltage that occurs only once while the voltage rises or falls. """ val = ctypes.c_double() cfunc = lib_importer.windll.DAQmxGetCIPeriodThreshVoltage if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.POINTER(ctypes.c_double)] error_code = cfunc( self._handle, self._name, ctypes.byref(val)) check_for_error(error_code) return val.value @ci_period_thresh_voltage.setter def ci_period_thresh_voltage(self, val): cfunc = lib_importer.windll.DAQmxSetCIPeriodThreshVoltage if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str, ctypes.c_double] error_code = cfunc( self._handle, self._name, val) check_for_error(error_code) @ci_period_thresh_voltage.deleter def ci_period_thresh_voltage(self): cfunc = lib_importer.windll.DAQmxResetCIPeriodThreshVoltage if cfunc.argtypes is None: with cfunc.arglock: if cfunc.argtypes is None: cfunc.argtypes = [ lib_importer.task_handle, ctypes_byte_str] error_code