def channel_names(self):
"""
List[str]: Specifies the unflattened list of the virtual channels.
"""
if self._name:
return unflatten_channel_string(self._name)
else:
return unflatten_channel_string(self._all_channels_name)
def test_unflatten_channel_string(self, x_series_device, seed):
# Reset the pseudorandom number generator with seed.
random.seed(seed)
channels = ['Dev1/ai0', 'Dev1/ai1', 'Dev1/ai3', 'Dev2/ai0']
flattened_channels = 'Dev1/ai0:1,Dev1/ai3,Dev2/ai0'
assert unflatten_channel_string(flattened_channels) == channels
assert unflatten_channel_string('') == []
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 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 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 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 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 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 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 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 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 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 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 __getitem__(self, index):
"""
Indexes a subset of custom scales on this collection.
Args:
index: The value of the index. The following index types
are supported:
- str: Name of the custom scale. You also can specify
a string that contains a list or range of names to
this input. If you have a list of names, use the
DAQmx Flatten Channel String function to convert
the list to a string.
- int: Index/position of the custom scale in the
collection.
- slice: Range of the indexes/positions of custom scales
in the collection.
Returns:
List[nidaqmx.system.storage.persisted_scale.PersistedScale]:
Indicates the subset of custom scales indexed.
"""
if isinstance(index, six.integer_types):
return PersistedScale(self.scale_names[index])
elif isinstance(index, slice):
return [PersistedScale(name) for name in self.scale_names[index]]
elif isinstance(index, six.string_types):
names = unflatten_channel_string(index)
if len(names) == 1:
return PersistedScale(names[0])
return [PersistedScale(name) for name in names]
else:
raise DaqError(
'Invalid index type "{0}" used to access collection.'.format(
type(index)), DAQmxErrors.UNKNOWN.value)
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 _create_chan(self, physical_channel, name_to_assign_to_channel=''):
"""
Creates and returns an AOChannel object.
Args:
physical_channel (str): Specifies the names of the physical
channels to use to create virtual channels.
name_to_assign_to_channel (Optional[str]): Specifies a name to
assign to the virtual channel this method creates.
Returns:
nidaqmx._task_modules.channels.ao_channel.AOChannel:
Specifies the newly created AOChannel object.
"""
if not self.debug_mode:
if name_to_assign_to_channel:
num_channels = len(unflatten_channel_string(physical_channel))
if num_channels > 1:
name = '{0}0:{1}'.format(name_to_assign_to_channel,
num_channels - 1)
else:
name = name_to_assign_to_channel
else:
name = physical_channel
return AOChannel(self._handle, name)
else:
print("ao_chann_coll - Assigned name to channel lines:\t",
name_to_assign_to_channel)
self.num_channels = self.num_channels + 1
name = name_to_assign_to_channel
return AOChannel(self._handle, name, self.debug_mode,
ChannelType.ANALOG_OUTPUT)
def _create_chan(self, physical_channel, name_to_assign_to_channel=''):
"""
Creates and returns an AOChannel object.
Args:
physical_channel (str): Specifies the names of the physical
channels to use to create virtual channels.
name_to_assign_to_channel (Optional[str]): Specifies a name to
assign to the virtual channel this method creates.
Returns:
nidaqmx._task_modules.channels.ao_channel.AOChannel:
Specifies the newly created AOChannel object.
"""
if name_to_assign_to_channel:
num_channels = len(unflatten_channel_string(physical_channel))
if num_channels > 1:
name = '{0}0:{1}'.format(name_to_assign_to_channel,
num_channels - 1)
else:
name = name_to_assign_to_channel
else:
name = physical_channel
return AOChannel(self._handle, name)
def _create_chan(self, counter, name_to_assign_to_channel=''):
"""
Creates and returns a CIChannel object.
Args:
counter (str): Specifies the names of the counters to use to
create virtual channels.
name_to_assign_to_channel (Optional[str]): Specifies a name to
assign to the virtual channel this method creates.
Returns:
nidaqmx._task_modules.channels.ci_channel.CIChannel:
Specifies the newly created CIChannel object.
"""
if name_to_assign_to_channel:
num_counters = len(unflatten_channel_string(counter))
if num_counters > 1:
name = '{0}0:{1}'.format(
name_to_assign_to_channel, num_counters-1)
else:
name = name_to_assign_to_channel
else:
name = counter
return CIChannel(self._handle, name)
def __contains__(self, item):
scale_names = self.scale_names
if isinstance(item, six.string_types):
items = unflatten_channel_string(item)
return all([i in scale_names for i in items])
elif isinstance(item, PersistedScale):
return item._name in scale_names
def __contains__(self, item):
channel_names = self.channel_names
if isinstance(item, six.string_types):
items = unflatten_channel_string(item)
return all([i in channel_names for i in items])
elif isinstance(item, PhysicalChannel):
return item._name in channel_names
return False
def __contains__(self, item):
device_names = self.device_names
if isinstance(item, six.string_types):
items = unflatten_channel_string(item)
return all([i in device_names for i in items])
elif isinstance(item, Device):
return item.name in device_names
return False
def __contains__(self, item):
channel_names = self.channel_names
if isinstance(item, six.string_types):
items = unflatten_channel_string(item)
elif isinstance(item, Channel):
items = item.channel_names
return all([item in channel_names for item in items])
def _create_chan(self, lines, line_grouping, name_to_assign_to_lines=''):
"""
Creates and returns a DOChannel object.
Args:
lines (str): Specifies the names of the lines to use to
create virtual channels.
line_grouping (Optional[nidaqmx.constants.LineGrouping]):
Specifies how to group digital lines into one or more
virtual channels.
name_to_assign_to_lines (Optional[str]): Specifies a name to
assign to the virtual channel this method creates.
Returns:
nidaqmx._task_modules.channels.do_channel.DOChannel:
Specifies the newly created DOChannel object.
"""
if not self.debug_mode:
unflattened_lines = unflatten_channel_string(lines)
num_lines = len(unflattened_lines)
if line_grouping == LineGrouping.CHAN_FOR_ALL_LINES:
if name_to_assign_to_lines or num_lines == 1:
name = lines
else:
name = unflattened_lines[0] + '...'
else:
if name_to_assign_to_lines:
if num_lines > 1:
name = '{0}0:{1}'.format(name_to_assign_to_lines,
num_lines - 1)
else:
name = name_to_assign_to_lines
else:
name = lines
return DOChannel(self._handle, name)
else:
# print("do_chann_coll - Assigned name to channel lines")
name = name_to_assign_to_lines
self.num_channels = self.num_channels + 1
return DOChannel(self._handle, name, self.debug_mode,
ChannelType.DIGITAL_OUTPUT)
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
