# Do not edit this file; it was automatically generated.
import ctypes
import numpy
from nidaqmx._lib import (
lib_importer, wrapped_ndpointer, enum_bitfield_to_list, ctypes_byte_str,
c_bool32)
from nidaqmx.errors import (
check_for_error, is_string_buffer_too_small, is_array_buffer_too_small)
from nidaqmx.utils import unflatten_channel_string
from nidaqmx.system._collections.physical_channel_collection import (
AIPhysicalChannelCollection, AOPhysicalChannelCollection,
CIPhysicalChannelCollection, COPhysicalChannelCollection,
DILinesCollection, DIPortsCollection, DOLinesCollection, DOPortsCollection)
from nidaqmx.constants import (
AcquisitionType, BusType, Coupling, FilterType, ProductCategory,
TriggerUsage, UsageTypeAI, UsageTypeAO, UsageTypeCI, UsageTypeCO,
_CouplingTypes, _TriggerUsageTypes)
__all__ = ['Device']
[docs]class Device(object):
"""
Represents a DAQmx device.
"""
__slots__ = ['_name', '__weakref__']
[docs] def __init__(self, name):
"""
Args:
name (str): Specifies the name of the device.
"""
self._name = name
[docs] def __eq__(self, other):
if isinstance(other, self.__class__):
return self._name == other._name
return False
[docs] def __hash__(self):
return hash(self._name)
[docs] def __ne__(self, other):
return not self.__eq__(other)
[docs] def __repr__(self):
return 'Device(name={0})'.format(self._name)
@property
def name(self):
"""
str: Specifies the name of this device.
"""
return self._name
# region Physical Channel Collections
@property
def ai_physical_chans(self):
"""
List[nidaqmx.system._collections.PhysicalChannelCollection]:
Indicates a collection that contains all the analog input
physical channels available on the device.
"""
return AIPhysicalChannelCollection(self._name)
@property
def ao_physical_chans(self):
"""
List[nidaqmx.system._collections.PhysicalChannelCollection]:
Indicates a collection that contains all the analog output
physical channels available on the device.
"""
return AOPhysicalChannelCollection(self._name)
@property
def ci_physical_chans(self):
"""
List[nidaqmx.system._collections.PhysicalChannelCollection]:
Indicates a collection that contains all the counter input
physical channels available on the device.
"""
return CIPhysicalChannelCollection(self._name)
@property
def co_physical_chans(self):
"""
List[nidaqmx.system._collections.PhysicalChannelCollection]:
Indicates a collection that contains all the counter output
physical channels available on the device.
"""
return COPhysicalChannelCollection(self._name)
@property
def di_lines(self):
"""
List[nidaqmx.system._collections.PhysicalChannelCollection]:
Indicates a collection that contains all the digital input
lines available on the device.
"""
return DILinesCollection(self._name)
@property
def di_ports(self):
"""
List[nidaqmx.system._collections.PhysicalChannelCollection]:
Indicates a collection that contains all the digital input
ports available on the device.
"""
return DIPortsCollection(self._name)
@property
def do_lines(self):
"""
List[nidaqmx.system._collections.PhysicalChannelCollection]:
Indicates a collection that contains all the digital output
lines available on the device.
"""
return DOLinesCollection(self._name)
@property
def do_ports(self):
"""
List[nidaqmx.system._collections.PhysicalChannelCollection]:
Indicates a collection that contains all the digital output
ports available on the device.
"""
return DOPortsCollection(self._name)
# endregion
@property
def accessory_product_nums(self):
"""
List[int]: Indicates the unique hardware identification number
for accessories connected to the device. Each list element
corresponds to a connector. For example, index 0 corresponds
to connector 0. The list contains 0 for each connector with
no accessory connected.
"""
cfunc = lib_importer.windll.DAQmxGetDevAccessoryProductNums
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.uint32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.uint32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def accessory_product_types(self):
"""
List[str]: Indicates the model names of accessories connected to
the device. Each list element corresponds to a connector.
For example, index 0 corresponds to connector 0. The list
contains an empty string for each connector with no
accessory connected.
"""
cfunc = lib_importer.windll.DAQmxGetDevAccessoryProductTypes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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 unflatten_channel_string(val.value.decode('ascii'))
@property
def accessory_serial_nums(self):
"""
List[int]: Indicates the serial number for accessories connected
to the device. Each list element corresponds to a connector.
For example, index 0 corresponds to connector 0. The list
contains 0 for each connector with no accessory connected.
"""
cfunc = lib_importer.windll.DAQmxGetDevAccessorySerialNums
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.uint32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.uint32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_bridge_rngs(self):
"""
List[float]: Indicates pairs of input voltage ratio ranges, in
volts per volt, supported by devices that acquire using
ratiometric measurements. Each pair consists of the low
value followed by the high value.
"""
cfunc = lib_importer.windll.DAQmxGetDevAIBridgeRngs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_charge_rngs(self):
"""
List[float]: Indicates in coulombs pairs of input charge ranges
for the device. Each pair consists of the low value followed
by the high value.
"""
cfunc = lib_importer.windll.DAQmxGetDevAIChargeRngs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_couplings(self):
"""
List[:class:`nidaqmx.constants.Coupling`]: Indicates the
coupling types supported by this device.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDevAICouplings
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return enum_bitfield_to_list(
val.value, _CouplingTypes, Coupling)
@property
def ai_current_int_excit_discrete_vals(self):
"""
List[float]: Indicates the set of discrete internal current
excitation values supported by this device.
"""
cfunc = lib_importer.windll.DAQmxGetDevAICurrentIntExcitDiscreteVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_current_rngs(self):
"""
List[float]: Indicates the pairs of current input ranges
supported by this device. Each pair consists of the low
value, followed by the high value.
"""
cfunc = lib_importer.windll.DAQmxGetDevAICurrentRngs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_dig_fltr_lowpass_cutoff_freq_discrete_vals(self):
"""
List[float]: Indicates the set of discrete lowpass cutoff
frequencies supported by this device. If the device supports
ranges of lowpass cutoff frequencies, use
AI.DigFltr.Lowpass.CutoffFreq.RangeVals to determine
supported frequencies.
"""
cfunc = (lib_importer.windll.
DAQmxGetDevAIDigFltrLowpassCutoffFreqDiscreteVals)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_dig_fltr_lowpass_cutoff_freq_range_vals(self):
"""
List[float]: Indicates pairs of lowpass cutoff frequency ranges
supported by this device. Each pair consists of the low
value, followed by the high value. If the device supports a
set of discrete lowpass cutoff frequencies, use
AI.DigFltr.Lowpass.CutoffFreq.DiscreteVals to determine the
supported frequencies.
"""
cfunc = (lib_importer.windll.
DAQmxGetDevAIDigFltrLowpassCutoffFreqRangeVals)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_dig_fltr_types(self):
"""
List[:class:`nidaqmx.constants.FilterType`]: Indicates the AI
digital filter types supported by the device.
"""
cfunc = lib_importer.windll.DAQmxGetAIDigFltrTypes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.int32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [FilterType(e) for e in val]
@property
def ai_freq_rngs(self):
"""
List[float]: Indicates the pairs of frequency input ranges
supported by this device. Each pair consists of the low
value, followed by the high value.
"""
cfunc = lib_importer.windll.DAQmxGetDevAIFreqRngs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_gains(self):
"""
List[float]: Indicates the input gain settings supported by this
device.
"""
cfunc = lib_importer.windll.DAQmxGetDevAIGains
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_lowpass_cutoff_freq_discrete_vals(self):
"""
List[float]: Indicates the set of discrete lowpass cutoff
frequencies supported by this device. If the device supports
ranges of lowpass cutoff frequencies, use
**ai_lowpass_cutoff_freq_range_vals** to determine supported
frequencies.
"""
cfunc = (lib_importer.windll.
DAQmxGetDevAILowpassCutoffFreqDiscreteVals)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_lowpass_cutoff_freq_range_vals(self):
"""
List[float]: Indicates pairs of lowpass cutoff frequency ranges
supported by this device. Each pair consists of the low
value, followed by the high value. If the device supports a
set of discrete lowpass cutoff frequencies, use
**ai_lowpass_cutoff_freq_discrete_vals** to determine the
supported frequencies.
"""
cfunc = lib_importer.windll.DAQmxGetDevAILowpassCutoffFreqRangeVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_max_multi_chan_rate(self):
"""
float: Indicates the maximum sampling rate for an analog input
task from this device. To find the maximum rate for the
task, take the minimum of **ai_max_single_chan_rate** or the
indicated sampling rate of this device divided by the number
of channels to acquire data from (including cold-junction
compensation and autozero channels).
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetDevAIMaxMultiChanRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ai_max_single_chan_rate(self):
"""
float: Indicates the maximum rate for an analog input task if
the task contains only a single channel from this device.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetDevAIMaxSingleChanRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ai_meas_types(self):
"""
List[:class:`nidaqmx.constants.UsageTypeAI`]: Indicates the
measurement types supported by the physical channels of the
device. Refer to **ai_meas_types** for information on
specific channels.
"""
cfunc = lib_importer.windll.DAQmxGetDevAISupportedMeasTypes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.int32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [UsageTypeAI(e) for e in val]
@property
def ai_min_rate(self):
"""
float: Indicates the minimum rate for an analog input task on
this device. NI-DAQmx returns a warning or error if you
attempt to sample at a slower rate.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetDevAIMinRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ai_num_samp_timing_engines(self):
"""
int: Indicates the number of Analog Input sample timing engines
supported by the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevAINumSampTimingEngines
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ai_num_sync_pulse_srcs(self):
"""
int: Indicates the number of Analog Input synchronization pulse
sources supported by the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevAINumSyncPulseSrcs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ai_resistance_rngs(self):
"""
List[float]: Indicates pairs of input resistance ranges, in
ohms, supported by devices that have the necessary signal
conditioning to measure resistances. Each pair consists of
the low value followed by the high value.
"""
cfunc = lib_importer.windll.DAQmxGetDevAIResistanceRngs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_samp_modes(self):
"""
List[:class:`nidaqmx.constants.AcquisitionType`]: Indicates
sample modes supported by devices that support sample
clocked analog input.
"""
cfunc = lib_importer.windll.DAQmxGetDevAISampModes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.int32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [AcquisitionType(e) for e in val]
@property
def ai_simultaneous_sampling_supported(self):
"""
bool: Indicates if the device supports simultaneous sampling.
"""
val = c_bool32()
cfunc = (lib_importer.windll.
DAQmxGetDevAISimultaneousSamplingSupported)
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ai_trig_usage(self):
"""
List[:class:`nidaqmx.constants.TriggerUsage`]: Indicates the
triggers supported by this device for an analog input task.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDevAITrigUsage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return enum_bitfield_to_list(
val.value, _TriggerUsageTypes, TriggerUsage)
@property
def ai_voltage_int_excit_discrete_vals(self):
"""
List[float]: Indicates the set of discrete internal voltage
excitation values supported by this device. If the device
supports ranges of internal excitation values, use
**ai_voltage_int_excit_range_vals** to determine supported
excitation values.
"""
cfunc = lib_importer.windll.DAQmxGetDevAIVoltageIntExcitDiscreteVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_voltage_int_excit_range_vals(self):
"""
List[float]: Indicates pairs of internal voltage excitation
ranges supported by this device. Each pair consists of the
low value, followed by the high value. If the device
supports a set of discrete internal excitation values, use
**ai_voltage_int_excit_discrete_vals** to determine the
supported excitation values.
"""
cfunc = lib_importer.windll.DAQmxGetDevAIVoltageIntExcitRangeVals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ai_voltage_rngs(self):
"""
List[float]: Indicates pairs of input voltage ranges supported
by this device. Each pair consists of the low value,
followed by the high value.
"""
cfunc = lib_importer.windll.DAQmxGetDevAIVoltageRngs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def anlg_trig_supported(self):
"""
bool: Indicates if the device supports analog triggering.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDevAnlgTrigSupported
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ao_current_rngs(self):
"""
List[float]: Indicates pairs of output current ranges supported
by this device. Each pair consists of the low value,
followed by the high value.
"""
cfunc = lib_importer.windll.DAQmxGetDevAOCurrentRngs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ao_gains(self):
"""
List[float]: Indicates the output gain settings supported by
this device.
"""
cfunc = lib_importer.windll.DAQmxGetDevAOGains
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def ao_max_rate(self):
"""
float: Indicates the maximum analog output rate of the device.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetDevAOMaxRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ao_min_rate(self):
"""
float: Indicates the minimum analog output rate of the device.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetDevAOMinRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ao_num_samp_timing_engines(self):
"""
int: Indicates the number of Analog Output sample timing engines
supported by the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevAONumSampTimingEngines
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ao_num_sync_pulse_srcs(self):
"""
int: Indicates the number of Analog Output synchronization pulse
sources supported by the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevAONumSyncPulseSrcs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ao_output_types(self):
"""
List[:class:`nidaqmx.constants.UsageTypeAO`]: Indicates the
generation types supported by the physical channels of the
device. Refer to **ao_output_types** for information on
specific channels.
"""
cfunc = lib_importer.windll.DAQmxGetDevAOSupportedOutputTypes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.int32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [UsageTypeAO(e) for e in val]
@property
def ao_samp_clk_supported(self):
"""
bool: Indicates if the device supports the sample clock timing
type for analog output tasks.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDevAOSampClkSupported
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ao_samp_modes(self):
"""
List[:class:`nidaqmx.constants.AcquisitionType`]: Indicates
sample modes supported by devices that support sample
clocked analog output.
"""
cfunc = lib_importer.windll.DAQmxGetDevAOSampModes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.int32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [AcquisitionType(e) for e in val]
@property
def ao_trig_usage(self):
"""
List[:class:`nidaqmx.constants.TriggerUsage`]: Indicates the
triggers supported by this device for analog output tasks.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDevAOTrigUsage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return enum_bitfield_to_list(
val.value, _TriggerUsageTypes, TriggerUsage)
@property
def ao_voltage_rngs(self):
"""
List[float]: Indicates pairs of output voltage ranges supported
by this device. Each pair consists of the low value,
followed by the high value.
"""
cfunc = lib_importer.windll.DAQmxGetDevAOVoltageRngs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str,
wrapped_ndpointer(dtype=numpy.float64,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.float64)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.tolist()
@property
def bus_type(self):
"""
:class:`nidaqmx.constants.BusType`: Indicates the bus type of
the device.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDevBusType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return BusType(val.value)
@property
def carrier_serial_num(self):
"""
int: Indicates the serial number of the device carrier. This
value is zero if the carrier does not have a serial number.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetCarrierSerialNum
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def chassis_module_devices(self):
"""
List[:class:`nidaqmx.system.device.Device`]: Indicates a list
containing the names of the modules in the chassis.
"""
cfunc = lib_importer.windll.DAQmxGetDevChassisModuleDevNames
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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 [Device(v)
for v in unflatten_channel_string(val.value.decode('ascii'))]
@property
def ci_max_size(self):
"""
int: Indicates in bits the size of the counters on the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevCIMaxSize
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ci_max_timebase(self):
"""
float: Indicates in hertz the maximum counter timebase
frequency.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetDevCIMaxTimebase
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ci_meas_types(self):
"""
List[:class:`nidaqmx.constants.UsageTypeCI`]: Indicates the
measurement types supported by the physical channels of the
device. Refer to **ci_meas_types** for information on
specific channels.
"""
cfunc = lib_importer.windll.DAQmxGetDevCISupportedMeasTypes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.int32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [UsageTypeCI(e) for e in val]
@property
def ci_samp_clk_supported(self):
"""
bool: Indicates if the device supports the sample clock timing
type for counter input tasks.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDevCISampClkSupported
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def ci_samp_modes(self):
"""
List[:class:`nidaqmx.constants.AcquisitionType`]: Indicates
sample modes supported by devices that support sample
clocked counter input.
"""
cfunc = lib_importer.windll.DAQmxGetDevCISampModes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.int32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [AcquisitionType(e) for e in val]
@property
def ci_trig_usage(self):
"""
List[:class:`nidaqmx.constants.TriggerUsage`]: Indicates the
triggers supported by this device for counter input tasks.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDevCITrigUsage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return enum_bitfield_to_list(
val.value, _TriggerUsageTypes, TriggerUsage)
@property
def co_max_size(self):
"""
int: Indicates in bits the size of the counters on the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevCOMaxSize
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def co_max_timebase(self):
"""
float: Indicates in hertz the maximum counter timebase
frequency.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetDevCOMaxTimebase
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def co_output_types(self):
"""
List[:class:`nidaqmx.constants.UsageTypeCO`]: Indicates the
generation types supported by the physical channels of the
device. Refer to **co_output_types** for information on
specific channels.
"""
cfunc = lib_importer.windll.DAQmxGetDevCOSupportedOutputTypes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.int32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [UsageTypeCO(e) for e in val]
@property
def co_samp_clk_supported(self):
"""
bool: Indicates if the device supports Sample Clock timing for
counter output tasks.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDevCOSampClkSupported
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def co_samp_modes(self):
"""
List[:class:`nidaqmx.constants.AcquisitionType`]: Indicates
sample modes supported by devices that support sample
clocked counter output.
"""
cfunc = lib_importer.windll.DAQmxGetDevCOSampModes
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, wrapped_ndpointer(dtype=numpy.int32,
flags=('C','W')), ctypes.c_uint]
temp_size = 0
while True:
val = numpy.zeros(temp_size, dtype=numpy.int32)
size_or_code = cfunc(
self._name, val, temp_size)
if is_array_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [AcquisitionType(e) for e in val]
@property
def co_trig_usage(self):
"""
List[:class:`nidaqmx.constants.TriggerUsage`]: Indicates the
triggers supported by this device for counter output tasks.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDevCOTrigUsage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return enum_bitfield_to_list(
val.value, _TriggerUsageTypes, TriggerUsage)
@property
def compact_daq_chassis_device(self):
"""
:class:`nidaqmx.system.device.Device`: Indicates the name of the
CompactDAQ chassis that contains this module.
"""
cfunc = lib_importer.windll.DAQmxGetDevCompactDAQChassisDevName
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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 Device(val.value.decode('ascii'))
@property
def compact_daq_slot_num(self):
"""
int: Indicates the slot number in which this module is located
in the CompactDAQ chassis.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevCompactDAQSlotNum
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def compact_rio_chassis_device(self):
"""
:class:`nidaqmx.system.device.Device`: Indicates the name of the
CompactRIO chassis that contains this module.
"""
cfunc = lib_importer.windll.DAQmxGetDevCompactRIOChassisDevName
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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 Device(val.value.decode('ascii'))
@property
def compact_rio_slot_num(self):
"""
int: Indicates the slot number of the CompactRIO chassis where
this module is located.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevCompactRIOSlotNum
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def dev_is_simulated(self):
"""
bool: Indicates if the device is a simulated device.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDevIsSimulated
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def dev_serial_num(self):
"""
int: Indicates the serial number of the device. This value is
zero if the device does not have a serial number.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevSerialNum
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def di_max_rate(self):
"""
float: Indicates the maximum digital input rate of the device.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetDevDIMaxRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def di_num_samp_timing_engines(self):
"""
int: Indicates the number of Digital Input sample timing engines
supported by the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevDINumSampTimingEngines
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def di_trig_usage(self):
"""
List[:class:`nidaqmx.constants.TriggerUsage`]: Indicates the
triggers supported by this device for digital input tasks.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDevDITrigUsage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return enum_bitfield_to_list(
val.value, _TriggerUsageTypes, TriggerUsage)
@property
def dig_trig_supported(self):
"""
bool: Indicates if the device supports digital triggering.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDevDigTrigSupported
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def do_max_rate(self):
"""
float: Indicates the maximum digital output rate of the device.
"""
val = ctypes.c_double()
cfunc = lib_importer.windll.DAQmxGetDevDOMaxRate
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_double)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def do_num_samp_timing_engines(self):
"""
int: Indicates the number of Digital Output synchronization
pulse sources supported by the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevDONumSampTimingEngines
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def do_trig_usage(self):
"""
List[:class:`nidaqmx.constants.TriggerUsage`]: Indicates the
triggers supported by this device for digital output tasks.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDevDOTrigUsage
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return enum_bitfield_to_list(
val.value, _TriggerUsageTypes, TriggerUsage)
@property
def field_daq_bank_devices(self):
"""
List[:class:`nidaqmx.system.device.Device`]: Indicates a list
containing the names of the banks in the FieldDAQ.
"""
cfunc = lib_importer.windll.DAQmxGetFieldDAQBankDevNames
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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 [Device(v)
for v in unflatten_channel_string(val.value.decode('ascii'))]
@property
def field_daq_device(self):
"""
:class:`nidaqmx.system.device.Device`: Indicates the parent
device which this bank is located in.
"""
cfunc = lib_importer.windll.DAQmxGetFieldDAQDevName
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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 Device(val.value.decode('ascii'))
@property
def num_dma_chans(self):
"""
int: Indicates the number of DMA channels on the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevNumDMAChans
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def num_time_trigs(self):
"""
int: Indicates the number of time triggers available on the
device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevNumTimeTrigs
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def num_timestamp_engines(self):
"""
int: Indicates the number of timestamp engines available on the
device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevNumTimestampEngines
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def pci_bus_num(self):
"""
int: Indicates the PCI bus number of the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevPCIBusNum
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def pci_dev_num(self):
"""
int: Indicates the PCI slot number of the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevPCIDevNum
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def product_category(self):
"""
:class:`nidaqmx.constants.ProductCategory`: Indicates the
product category of the device. This category corresponds to
the category displayed in MAX when creating NI-DAQmx
simulated devices.
"""
val = ctypes.c_int()
cfunc = lib_importer.windll.DAQmxGetDevProductCategory
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_int)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return ProductCategory(val.value)
@property
def product_num(self):
"""
int: Indicates the unique hardware identification number for the
device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevProductNum
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def product_type(self):
"""
str: Indicates the product name of the device.
"""
cfunc = lib_importer.windll.DAQmxGetDevProductType
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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')
@property
def pxi_chassis_num(self):
"""
int: Indicates the PXI chassis number of the device, as
identified in MAX.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevPXIChassisNum
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def pxi_slot_num(self):
"""
int: Indicates the PXI slot number of the device.
"""
val = ctypes.c_uint()
cfunc = lib_importer.windll.DAQmxGetDevPXISlotNum
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(ctypes.c_uint)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def tcpip_ethernet_ip(self):
"""
str: Indicates the IPv4 address of the Ethernet interface in
dotted decimal format. This property returns 0.0.0.0 if the
Ethernet interface cannot acquire an address.
"""
cfunc = lib_importer.windll.DAQmxGetDevTCPIPEthernetIP
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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')
@property
def tcpip_hostname(self):
"""
str: Indicates the IPv4 hostname of the device.
"""
cfunc = lib_importer.windll.DAQmxGetDevTCPIPHostname
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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')
@property
def tcpip_wireless_ip(self):
"""
str: Indicates the IPv4 address of the 802.11 wireless interface
in dotted decimal format. This property returns 0.0.0.0 if
the wireless interface cannot acquire an address.
"""
cfunc = lib_importer.windll.DAQmxGetDevTCPIPWirelessIP
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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')
@property
def tedshwteds_supported(self):
"""
bool: Indicates whether the device supports hardware TEDS.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDevTEDSHWTEDSSupported
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
@property
def terminals(self):
"""
List[str]: Indicates a list of all terminals on the device.
"""
cfunc = lib_importer.windll.DAQmxGetDevTerminals
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
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._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 unflatten_channel_string(val.value.decode('ascii'))
@property
def time_trig_supported(self):
"""
bool: Indicates whether the device supports time triggering.
"""
val = c_bool32()
cfunc = lib_importer.windll.DAQmxGetDevTimeTrigSupported
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.POINTER(c_bool32)]
error_code = cfunc(
self._name, ctypes.byref(val))
check_for_error(error_code)
return val.value
[docs] def reset_device(self):
"""
Immediately aborts all active tasks associated with a device,
disconnects any routes, and returns the device to an initialized
state. Aborting a task immediately terminates the currently
active operation, such as a read or a write. Aborting a task
puts the task into an unstable but recoverable state. To recover
the task, use DAQmx Start to restart the task or use DAQmx Stop
to reset the task without starting it.
"""
cfunc = lib_importer.windll.DAQmxResetDevice
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str]
error_code = cfunc(
self._name)
check_for_error(error_code)
[docs] def self_test_device(self):
"""
Performs a brief test of device resources. If a failure occurs,
refer to your device documentation for more information.
"""
cfunc = lib_importer.windll.DAQmxSelfTestDevice
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str]
error_code = cfunc(
self._name)
check_for_error(error_code)
# region Network Device Functions
[docs] @staticmethod
def add_network_device(
ip_address, device_name="", attempt_reservation=False,
timeout=10.0):
"""
Adds a Network cDAQ device to the system and, if specified,
attempts to reserve it.
Args:
ip_address (str): Specifies the string containing the IP
address (in dotted decimal notation) or hostname of the
device to add to the system.
device_name (Optional[str]): Indicates the name to assign to
the device. If unspecified, NI-DAQmx chooses the device
name.
attempt_reservation (Optional[bool]): Indicates if a
reservation should be attempted after the device is
successfully added. By default, this parameter is set to
False.
timeout (Optional[float]): Specifies the time in seconds to
wait for the device to respond before timing out.
Returns:
nidaqmx.system.device.Device:
Specifies the object that represents the device this
operation applied to.
"""
cfunc = lib_importer.windll.DAQmxAddNetworkDevice
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes_byte_str, c_bool32,
ctypes.c_double, ctypes.c_char_p, ctypes.c_uint]
temp_size = 0
while True:
device_name_out = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
ip_address, device_name, attempt_reservation, timeout,
device_name_out, 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 Device(device_name_out.value.decode('ascii'))
[docs] def delete_network_device(self):
"""
Deletes a Network DAQ device previously added to the host. If
the device is reserved, it is unreserved before it is removed.
"""
cfunc = lib_importer.windll.DAQmxDeleteNetworkDevice
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str]
error_code = cfunc(
self._name)
check_for_error(error_code)
[docs] def reserve_network_device(self, override_reservation=None):
"""
Reserves the Network DAQ device for the current host.
Reservation is required to run NI-DAQmx tasks, and the device
must be added in MAX before it can be reserved.
Args:
override_reservation (Optional[bool]): Indicates if an
existing reservation on the device should be overridden
by this reservation. By default, this parameter is set
to false.
"""
cfunc = lib_importer.windll.DAQmxReserveNetworkDevice
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, c_bool32]
error_code = cfunc(
self._name, override_reservation)
check_for_error(error_code)
[docs] def unreserve_network_device(self):
"""
Unreserves or releases a Network DAQ device previously reserved
by the host.
"""
cfunc = lib_importer.windll.DAQmxUnreserveNetworkDevice
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str]
error_code = cfunc(
self._name)
check_for_error(error_code)
# endregion