def dig_pattern_src(self):
"""
:class:`nidaqmx.system.physical_channel.PhysicalChannel`:
Specifies the physical channels to use for pattern matching.
The order of the physical channels determines the order of
the pattern. If a port is included, the lines within the
port are in ascending order.
"""
cfunc = lib_importer.windll.DAQmxGetDigPatternPauseTrigSrc
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return PhysicalChannel(val.value.decode('ascii'))
def anlg_win_src(self):
"""
str: Specifies the name of a virtual channel or terminal where
there is an analog signal to use as the source of the
trigger.
"""
cfunc = lib_importer.windll.DAQmxGetAnlgWinPauseTrigSrc
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
def dig_pattern_pattern(self):
"""
str: Specifies the digital pattern that must be met for the
Pause Trigger to occur.
"""
cfunc = lib_importer.windll.DAQmxGetDigPatternPauseTrigPattern
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
def overtemperature_chans(self):
"""
List[str]: Indicates a list of names of any overtemperature
virtual channels. You must read
**overtemperature_chans_exist** before you read this
property. Otherwise, you will receive an error. The list of
names may be empty if the device cannot determine the source
of the overtemperature.
"""
cfunc = lib_importer.windll.DAQmxGetWriteOvertemperatureChans
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return unflatten_channel_string(val.value.decode('ascii'))
def channel_names(self):
"""
List[str]: Specifies the entire list of virtual channels on this
channel collection.
"""
cfunc = lib_importer.windll.DAQmxGetTaskChannels
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return unflatten_channel_string(val.value.decode('ascii'))
def ai_input_srcs(self):
"""
List[str]: Indicates the list of input sources supported by the
channel. Channels may support using the signal from the I/O
connector or one of several calibration signals.
"""
cfunc = lib_importer.windll.DAQmxGetPhysicalChanAIInputSrcs
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'))
def physical_channel(self):
"""
:class:`nidaqmx.system.physical_channel.PhysicalChannel`:
Specifies the name of the physical channel upon which this
virtual channel is based.
"""
cfunc = lib_importer.windll.DAQmxGetPhysicalChanName
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 PhysicalChannel(val.value.decode('ascii'))
def device_names(self):
"""
List[str]: Indicates the names of all devices on this device
collection.
"""
if not self.debug_mode:
cfunc = lib_importer.windll.DAQmxGetSysDevNames
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes.c_char_p, ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
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'))
else:
return ["cDAQ1Mod1","cDAQ1Mod2"]
def power_supply_fault_chans(self):
"""
List[str]: Indicates a list of names of any virtual channels in
the task that have a power supply fault. You must read
**power_supply_fault_chans_exist** before you read this
property. Otherwise, you will receive an error.
"""
cfunc = lib_importer.windll.DAQmxGetWritePowerSupplyFaultChans
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return unflatten_channel_string(val.value.decode('ascii'))
def co_pulse_term(self):
"""
str: Specifies on which terminal to generate pulses.
"""
cfunc = lib_importer.windll.DAQmxGetCOPulseTerm
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')
def author(self):
"""
str: Indicates the author of the task.
"""
cfunc = lib_importer.windll.DAQmxGetPersistedTaskAuthor
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')
def scaled_units(self):
"""
str: Specifies the units to use for scaled values. You can use
an arbitrary string.
"""
cfunc = lib_importer.windll.DAQmxGetScaleScaledUnits
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')
def sync_unlocked_chans(self):
"""
List[str]: Indicates the channels from devices in an unlocked
target.
"""
cfunc = lib_importer.windll.DAQmxGetWriteSyncUnlockedChans
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return unflatten_channel_string(val.value.decode('ascii'))
def devs_with_inserted_or_removed_accessories(self):
"""
List[str]: Indicates the names of any devices that detected the
insertion or removal of an accessory since the task started.
You must read **accessory_insertion_or_removal_detected**
before you read this property. Otherwise, you will receive
an error.
"""
cfunc = (lib_importer.windll.
DAQmxGetWriteDevsWithInsertedOrRemovedAccessories)
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return unflatten_channel_string(val.value.decode('ascii'))
def teds_version_letter(self):
"""
str: Indicates the version letter of the sensor.
"""
cfunc = lib_importer.windll.DAQmxGetPhysicalChanTEDSVersionLetter
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')
def open_current_loop_chans(self):
"""
List[str]: Indicates a list of names of any virtual channels in
the task for which the device(s) detected an open current
loop. You must read **open_current_loop_chans_exist** before
you read this property. Otherwise, you will receive an
error.
"""
cfunc = lib_importer.windll.DAQmxGetWriteOpenCurrentLoopChans
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return unflatten_channel_string(val.value.decode('ascii'))
def dig_edge_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.DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseSrc)
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
def devices(self):
"""
List[:class:`nidaqmx.system.device.Device`]: Indicates a list
of Device objects representing all the devices in the task.
"""
cfunc = lib_importer.windll.DAQmxGetTaskDevices
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(
self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return [Device(v) for v in
unflatten_channel_string(val.value.decode('ascii'))]
def co_ctr_timebase_src(self):
"""
str: Specifies the terminal of the timebase to use for the
counter. Typically, NI-DAQmx uses one of the internal
counter timebases when generating pulses. Use this property
to specify an external timebase and produce custom pulse
widths that are not possible using the internal timebases.
"""
cfunc = lib_importer.windll.DAQmxGetCOCtrTimebaseSrc
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')
def description(self):
"""
str: Specifies a description for the scale.
"""
cfunc = lib_importer.windll.DAQmxGetScaleDescr
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')
def external_overvoltage_chans(self):
"""
List[str]: Indicates a list of names of any virtual channels in
the task for which an External Overvoltage condition has
been detected. You must read External OvervoltageChansExist
before you read this property. Otherwise, you will receive
an error.
"""
cfunc = lib_importer.windll.DAQmxGetWriteExternalOvervoltageChans
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return unflatten_channel_string(val.value.decode('ascii'))
def di_dig_fltr_timebase_src(self):
"""
str: Specifies the terminal of the signal to use as the timebase
of the digital filter.
"""
cfunc = lib_importer.windll.DAQmxGetDIDigFltrTimebaseSrc
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')
def _all_channels_name(self):
"""
str: Specifies the flattened names of all the virtual channels in
the task.
"""
cfunc = lib_importer.windll.DAQmxGetTaskChannels
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
def interlocked_src(self):
"""
str: Specifies the source terminal of the Handshake Trigger.
"""
cfunc = lib_importer.windll.DAQmxGetInterlockedHshkTrigSrc
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p, ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
def term(self):
"""
str: Indicates the name of the internal Arm Start Trigger
terminal for the task. This property does not return the
name of the trigger source terminal.
"""
cfunc = lib_importer.windll.DAQmxGetArmStartTerm
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
def dig_edge_src(self):
"""
str: Specifies the name of a terminal where there is a digital
signal to use as the source of the Arm Start Trigger.
"""
cfunc = lib_importer.windll.DAQmxGetDigEdgeArmStartTrigSrc
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
lib_importer.task_handle, ctypes.c_char_p,
ctypes.c_uint
]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(self._handle, val, temp_size)
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
temp_size = 0
elif size_or_code > 0 and temp_size == 0:
# Buffer size obtained, use to retrieve data.
temp_size = size_or_code
else:
break
check_for_error(size_or_code)
return val.value.decode('ascii')
def scale_names(self):
"""
List[str]: Indicates the names of all the custom scales on this
collection.
"""
cfunc = lib_importer.windll.DAQmxGetSysScales
cfunc.argtypes = [ctypes.c_char_p, ctypes.c_uint]
temp_size = 0
while True:
val = ctypes.create_string_buffer(temp_size)
size_or_code = cfunc(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'))
def channel_names(self):
cfunc = lib_importer.windll.DAQmxGetDevDOPorts
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'))
def auto_configure_cdaq_sync_connections(
self, chassis_devices_ports="", timeout=WAIT_INFINITELY):
"""
Detects and configures cDAQ Sync connections between devices.
Stop all NI-DAQmx tasks running on the devices prior to running
this function because any running tasks cause auto-configuration
to fail.
Args:
chassis_devices_ports (Optional[str]): Specifies the names of the
CompactDAQ chassis, C Series modules, or cDAQ Sync ports in
comma separated form to search. If no names are specified, all
cDAQ Sync ports on connected, non-simulated devices are
scanned.
timeout (Optional[float]): Specifies the time in seconds to
wait for the device to respond before timing out. If a
timeout occurs, no configuration is changed.
Returns:
List[nidaqmx.types.CDAQSyncConnection]:
Returns the configured port-to-port connections.
"""
cfunc = lib_importer.windll.DAQmxAutoConfigureCDAQSyncConnections
cfunc.argtypes = [
ctypes_byte_str, ctypes.c_double]
error_code = cfunc(
chassis_devices_ports, timeout)
check_for_error(error_code)
cfunc = lib_importer.windll.DAQmxGetAutoConfiguredCDAQSyncConnections
cfunc.argtypes = [
ctypes.c_char_p, ctypes.POINTER(ctypes.c_uint)]
port_list_size = ctypes.c_uint()
while True:
size_or_code = cfunc(
None, ctypes.byref(port_list_size))
if size_or_code < 0:
break
port_list = ctypes.create_string_buffer(size_or_code)
size_or_code = cfunc(
port_list, ctypes.byref(port_list_size))
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
continue
else:
break
check_for_error(size_or_code)
ports = unflatten_channel_string(port_list.value.decode('ascii'))
output_ports = ports[::2]
input_ports = ports[1::2]
connections = []
for output_port, input_port in zip(output_ports, input_ports):
connections.append(
CDAQSyncConnection(output_port=output_port,
input_port=input_port))
return connections
def are_configured_cdaq_sync_ports_disconnected(
self, chassis_devices_ports="", timeout=WAIT_INFINITELY):
"""
Verifies configured cDAQ Sync connections between devices.
Failures generally indicate a wiring issue or that a device has
been powered off or removed. Stop all NI-DAQmx tasks running on
the devices prior to running this function because any running
tasks cause the verification process to fail.
Args:
chassis_devices_ports (Optional[str]): Specifies the names
of the CompactDAQ chassis, C Series modules, or cDAQ
Sync ports in comma separated form to search. If no
names are specified, all cDAQ Sync ports on connected,
non-simulated devices are scanned.
timeout (Optional[float]): Specifies the time in seconds to
wait for the device to respond before timing out.
Returns:
List[nidaqmx.types.CDAQSyncConnection]:
Returns the port-to-port connections that failed verification.
"""
disconnected_ports_exist = c_bool32()
cfunc = lib_importer.windll.DAQmxAreConfiguredCDAQSyncPortsDisconnected
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes_byte_str, ctypes.c_double,
ctypes.POINTER(c_bool32)]
error_code = cfunc(
chassis_devices_ports, timeout,
ctypes.byref(disconnected_ports_exist))
check_for_error(error_code)
cfunc = lib_importer.windll.DAQmxGetDisconnectedCDAQSyncPorts
if cfunc.argtypes is None:
with cfunc.arglock:
if cfunc.argtypes is None:
cfunc.argtypes = [
ctypes.c_char_p, ctypes.POINTER(ctypes.c_uint)]
port_list_size = ctypes.c_uint()
while True:
size_or_code = cfunc(
None, ctypes.byref(port_list_size))
if size_or_code < 0:
break
port_list = ctypes.create_string_buffer(size_or_code)
size_or_code = cfunc(
port_list, ctypes.byref(port_list_size))
if is_string_buffer_too_small(size_or_code):
# Buffer size must have changed between calls; check again.
continue
else:
break
check_for_error(size_or_code)
ports = unflatten_channel_string(port_list.value.decode('ascii'))
output_ports = ports[::2]
input_ports = ports[1::2]
connections = []
for output_port, input_port in zip(output_ports, input_ports):
connections.append(
CDAQSyncConnection(output_port=output_port,
input_port=input_port))
return connections
