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 __getitem__(self, index):
"""
Indexes a subset of physical channels on this physical channel
collection.
Args:
index: The value of the index. The following index types
are supported:
- str: Name of the physical channel, without the
device name prefix, e.g. 'ai0'. 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 physical channel in the
collection.
- slice: Range of the indexes/positions of physical
channels in the collection.
Returns:
nidaqmx.system.physical_channel.PhysicalChannel:
Indicates the subset of physical channels indexed.
"""
if isinstance(index, six.integer_types):
return PhysicalChannel(self.channel_names[index])
elif isinstance(index, slice):
return PhysicalChannel(self.channel_names[index])
elif isinstance(index, six.string_types):
return PhysicalChannel('{0}/{1}'.format(self._name, index))
else:
raise DaqError(
'Invalid index type "{0}" used to access collection.'.format(
type(index)), DAQmxErrors.UNKNOWN.value)
def _raise_invalid_write_num_chans_error(
self, number_of_channels, number_of_channels_in_data):
raise DaqError(
'Write cannot be performed, because the number of channels in the '
'data does not match the number of channels in the task.\n\n'
'When writing, supply data for all channels in the task. '
'Alternatively, modify the task to contain the same number of '
'channels as the data written.\n\n'
'Number of Channels in Task: {0}\n'
'Number of Channels in Data: {1}'
.format(number_of_channels, number_of_channels_in_data),
DAQmxErrors.WRITE_NUM_CHANS_MISMATCH.value, task_name=self.name)
def __getitem__(self, index):
"""
Indexes a subset of virtual channels on this channel collection.
Args:
index: The value of the index. The following index types are
supported:
- str: Name of the virtual channel. 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 virtual channel in the collection.
- slice: Range of the indexes/positions of virtual channels in
the collection.
Returns:
nidaqmx._task_modules.channels.channel.Channel:
Indicates a channel object representing the subset of virtual
channels indexed.
"""
if isinstance(index, six.integer_types):
channel_names = self.channel_names[index]
elif isinstance(index, slice):
channel_names = flatten_channel_string(self.channel_names[index])
elif isinstance(index, six.string_types):
channel_names = index
else:
raise DaqError(
'Invalid index type "{0}" used to access channels.'.format(
type(index)), DAQmxErrors.UNKNOWN)
if channel_names:
return Channel._factory(self._handle, channel_names)
else:
raise DaqError(
'You cannot specify an empty index when indexing channels.\n'
'Index used: {0}'.format(index), DAQmxErrors.UNKNOWN)
def _raise_invalid_num_lines_error(
self, num_lines_expected, num_lines_in_data):
raise DaqError(
'Specified read or write operation failed, because the number '
'of lines in the data for a channel does not match the number '
'of lines in the channel.\n\n'
'If you are using boolean data, make sure the array dimension '
'for lines in the data matches the number of lines in the '
'channel.\n\n'
'Number of Lines Per Channel in Task: {0}\n'
'Number of Lines Per Channel in Data: {1}'
.format(num_lines_expected, num_lines_in_data),
DAQmxErrors.NUM_LINES_MISMATCH_IN_READ_OR_WRITE.value,
task_name=self.name)
def __getitem__(self, index):
"""
Indexes an expiration state on this collection.
Args:
index (str): Name of the physical channel of which the
expiration state to retrieve.
Returns:
nidaqmx.system._watchdog_modules.expiration_state.ExpirationState:
The object representing the indexed expiration state.
"""
if isinstance(index, six.string_types):
return ExpirationState(self._handle, index)
else:
raise DaqError(
'Invalid index type "{0}" used to access expiration states.'.
format(type(index)), -1)
def unflatten_channel_string(channel_names):
"""
Converts a comma-delimited list of channel names to a list of names.
You can use this method to convert a comma-delimited list or range of
physical or virtual channels into a list of physical or virtual channel
names.
Args:
channel_names (str): The list or range of physical or virtual channels.
Returns:
List[str]:
The list of physical or virtual channel names. Each element of the
list contains a single channel.
"""
channel_list_to_return = []
channel_list = [c for c in channel_names.strip().split(',') if c]
for channel in channel_list:
channel = channel.strip()
colon_index = channel.find(':')
if colon_index == -1:
channel_list_to_return.append(channel)
else:
before = channel[:colon_index]
after = channel[colon_index + 1:]
m_before = re.match('(.*?)([0-9]+)$', before)
m_after = re.match('(.*?)([0-9]+)$', after)
if not m_before or not m_after:
raise DaqError(_invalid_range_syntax_message,
error_code=-200498)
if m_after.group(1) and (m_before.group(1).lower() !=
m_after.group(1).lower()):
raise DaqError(_invalid_range_syntax_message,
error_code=-200498)
num_before = int(m_before.group(2))
num_after = int(m_after.group(2))
num_max = max([num_before, num_after])
num_min = min([num_before, num_after])
number_of_channels = (num_max - num_min) + 1
if number_of_channels >= 15000:
raise DaqError(_invalid_range_syntax_message,
error_code=-200498)
colon_expanded_channel = []
for i in range(number_of_channels):
colon_expanded_channel.append('{0}{1}'.format(
m_before.group(1), num_min + i))
if num_after < num_before:
colon_expanded_channel.reverse()
channel_list_to_return.extend(colon_expanded_channel)
return channel_list_to_return
def read(self, number_of_samples_per_channel=NUM_SAMPLES_UNSET,
timeout=10.0):
"""
Reads samples from the task or virtual channels you specify.
This read method is dynamic, and is capable of inferring an appropriate
return type based on these factors:
- The channel type of the task.
- The number of channels to read.
- The number of samples per channel.
The data type of the samples returned is independently determined by
the channel type of the task.
For digital input measurements, the data type of the samples returned
is determined by the line grouping format of the digital lines.
If the line grouping format is set to "one channel for all lines", the
data type of the samples returned is int. If the line grouping
format is set to "one channel per line", the data type of the samples
returned is boolean.
If you do not set the number of samples per channel, this method
assumes one sample was requested. This method then returns either a
scalar (1 channel to read) or a list (N channels to read).
If you set the number of samples per channel to ANY value (even 1),
this method assumes multiple samples were requested. This method then
returns either a list (1 channel to read) or a list of lists (N
channels to read).
Args:
number_of_samples_per_channel (Optional[int]): Specifies the
number of samples to read. If this input is not set,
assumes samples to read is 1. Conversely, if this input
is set, assumes there are multiple samples to read.
If you set this input to nidaqmx.constants.
READ_ALL_AVAILABLE, NI-DAQmx determines how many samples
to read based on if the task acquires samples
continuously or acquires a finite number of samples.
If the task acquires samples continuously and you set
this input to nidaqmx.constants.READ_ALL_AVAILABLE, this
method reads all the samples currently available in the
buffer.
If the task acquires a finite number of samples and you
set this input to nidaqmx.constants.READ_ALL_AVAILABLE,
the method waits for the task to acquire all requested
samples, then reads those samples. If you set the
"read_all_avail_samp" property to True, the method reads
the samples currently available in the buffer and does
not wait for the task to acquire all requested samples.
timeout (Optional[float]): Specifies the amount of time in
seconds to wait for samples to become available. If the
time elapses, the method returns an error and any
samples read before the timeout elapsed. The default
timeout is 10 seconds. If you set timeout to
nidaqmx.constants.WAIT_INFINITELY, the method waits
indefinitely. If you set timeout to 0, the method tries
once to read the requested samples and returns an error
if it is unable to.
Returns:
dynamic:
The samples requested in the form of a scalar, a list, or a
list of lists. See method docstring for more info.
NI-DAQmx scales the data to the units of the measurement,
including any custom scaling you apply to the channels. Use a
DAQmx Create Channel method to specify these units.
Example:
>>> task = Task()
>>> task.ai_channels.add_voltage_channel('Dev1/ai0:3')
>>> data = task.read()
>>> type(data)
<type 'list'>
>>> type(data[0])
<type 'float'>
"""
channels_to_read = self.in_stream.channels_to_read
number_of_channels = len(channels_to_read.channel_names)
read_chan_type = channels_to_read.chan_type
num_samples_not_set = (number_of_samples_per_channel is
NUM_SAMPLES_UNSET)
number_of_samples_per_channel = self._calculate_num_samps_per_chan(
number_of_samples_per_channel)
# Determine the array shape and size to create
if number_of_channels > 1:
if not num_samples_not_set:
array_shape = (number_of_channels,
number_of_samples_per_channel)
else:
array_shape = number_of_channels
else:
array_shape = number_of_samples_per_channel
# Analog Input
if read_chan_type == ChannelType.ANALOG_INPUT:
data = numpy.zeros(array_shape, dtype=numpy.float64)
samples_read = _read_analog_f_64(
self._handle, data, number_of_samples_per_channel, timeout)
# Digital Input or Digital Output
elif (read_chan_type == ChannelType.DIGITAL_INPUT or
read_chan_type == ChannelType.DIGITAL_OUTPUT):
if self.in_stream.di_num_booleans_per_chan == 1:
data = numpy.zeros(array_shape, dtype=numpy.bool)
samples_read = _read_digital_lines(
self._handle, data, number_of_samples_per_channel, timeout
).samps_per_chan_read
else:
data = numpy.zeros(array_shape, dtype=numpy.uint32)
samples_read = _read_digital_u_32(
self._handle, data, number_of_samples_per_channel, timeout)
# Counter Input
elif read_chan_type == ChannelType.COUNTER_INPUT:
meas_type = channels_to_read.ci_meas_type
if meas_type == UsageTypeCI.PULSE_FREQ:
frequencies = numpy.zeros(array_shape, dtype=numpy.float64)
duty_cycles = numpy.zeros(array_shape, dtype=numpy.float64)
samples_read = _read_ctr_freq(
self._handle, frequencies, duty_cycles,
number_of_samples_per_channel, timeout)
data = []
for f, d in zip(frequencies, duty_cycles):
data.append(CtrFreq(freq=f, duty_cycle=d))
elif meas_type == UsageTypeCI.PULSE_TIME:
high_times = numpy.zeros(array_shape, dtype=numpy.float64)
low_times = numpy.zeros(array_shape, dtype=numpy.float64)
samples_read = _read_ctr_time(
self._handle, high_times, low_times,
number_of_samples_per_channel, timeout)
data = []
for h, l in zip(high_times, low_times):
data.append(CtrTime(high_time=h, low_time=l))
elif meas_type == UsageTypeCI.PULSE_TICKS:
high_ticks = numpy.zeros(array_shape, dtype=numpy.uint32)
low_ticks = numpy.zeros(array_shape, dtype=numpy.uint32)
samples_read = _read_ctr_ticks(
self._handle, high_ticks, low_ticks,
number_of_samples_per_channel, timeout)
data = []
for h, l in zip(high_ticks, low_ticks):
data.append(CtrTick(high_tick=h, low_tick=l))
elif meas_type == UsageTypeCI.COUNT_EDGES:
data = numpy.zeros(array_shape, dtype=numpy.uint32)
samples_read = _read_counter_u_32_ex(
self._handle, data, number_of_samples_per_channel, timeout)
else:
data = numpy.zeros(array_shape, dtype=numpy.float64)
samples_read = _read_counter_f_64_ex(
self._handle, data, number_of_samples_per_channel, timeout)
else:
raise DaqError(
'Read failed, because there are no channels in this task from '
'which data can be read.',
DAQmxErrors.READ_NO_INPUT_CHANS_IN_TASK.value,
task_name=self.name)
if (read_chan_type == ChannelType.COUNTER_INPUT and
(meas_type == UsageTypeCI.PULSE_FREQ or
meas_type == UsageTypeCI.PULSE_TICKS or
meas_type == UsageTypeCI.PULSE_TIME)):
if num_samples_not_set and array_shape == 1:
return data[0]
# Counter pulse measurements should not have N channel versions.
if samples_read != number_of_samples_per_channel:
return data[:samples_read]
return data
if num_samples_not_set and array_shape == 1:
return data.tolist()[0]
if samples_read != number_of_samples_per_channel:
if number_of_channels > 1:
return data[:,:samples_read].tolist()
else:
return data[:samples_read].tolist()
return data.tolist()
def write(self, data, auto_start=AUTO_START_UNSET, timeout=10.0):
"""
Writes samples to the task or virtual channels you specify.
This write method is dynamic, and is capable of accepting the
samples to write in the various forms for most operations:
- Scalar: Single sample for 1 channel.
- List/1D numpy.ndarray: Multiple samples for 1 channel or 1
sample for multiple channels.
- List of lists/2D numpy.ndarray: Multiple samples for multiple
channels.
The data type of the samples passed in must be appropriate for
the channel type of the task.
For counter output pulse operations, this write method only
accepts samples in these forms:
- Scalar CtrFreq, CtrTime, CtrTick (from nidaqmx.types):
Single sample for 1 channel.
- List of CtrFreq, CtrTime, CtrTick (from nidaqmx.types):
Multiple samples for 1 channel or 1 sample for multiple
channels.
If the task uses on-demand timing, this method returns only
after the device generates all samples. On-demand is the default
timing type if you do not use the timing property on the task to
configure a sample timing type. If the task uses any timing type
other than on-demand, this method returns immediately and does
not wait for the device to generate all samples. Your
application must determine if the task is done to ensure that
the device generated all samples.
Args:
data (dynamic): Contains the samples to write to the task.
The data you write must be in the units of the
generation, including any custom scales. Use the DAQmx
Create Channel methods to specify these units.
auto_start (Optional[bool]): Specifies if this method
automatically starts the task if you did not explicitly
start it with the DAQmx Start Task method.
The default value of this parameter depends on whether
you specify one sample or many samples to write to each
channel. If one sample per channel was specified, the
default value is True. If multiple samples per channel
were specified, the default value is False.
timeout (Optional[float]): Specifies the amount of time in
seconds to wait for the method to write all samples.
NI-DAQmx performs a timeout check only if the method
must wait before it writes data. This method returns an
error if the time elapses. The default timeout is 10
seconds. If you set timeout to
nidaqmx.constants.WAIT_INFINITELY, the method waits
indefinitely. If you set timeout to 0, the method tries
once to write the submitted samples. If the method could
not write all the submitted samples, it returns an error
and the number of samples successfully written.
Returns:
int:
Specifies the actual number of samples this method
successfully wrote.
"""
channels_to_write = self.channels
number_of_channels = len(channels_to_write.channel_names)
write_chan_type = channels_to_write.chan_type
element = None
if number_of_channels == 1:
if isinstance(data, list):
if isinstance(data[0], list):
self._raise_invalid_write_num_chans_error(
number_of_channels, len(data))
number_of_samples_per_channel = len(data)
element = data[0]
elif isinstance(data, numpy.ndarray):
if len(data.shape) == 2:
self._raise_invalid_write_num_chans_error(
number_of_channels, data.shape[0])
number_of_samples_per_channel = len(data)
element = data[0]
else:
number_of_samples_per_channel = 1
element = data
else:
if isinstance(data, list):
if len(data) != number_of_channels:
self._raise_invalid_write_num_chans_error(
number_of_channels, len(data))
if isinstance(data[0], list):
number_of_samples_per_channel = len(data[0])
element = data[0][0]
else:
number_of_samples_per_channel = 1
element = data[0]
elif isinstance(data, numpy.ndarray):
if data.shape[0] != number_of_channels:
self._raise_invalid_write_num_chans_error(
number_of_channels, data.shape[0])
if len(data.shape) == 2:
number_of_samples_per_channel = data.shape[1]
element = data[0][0]
else:
number_of_samples_per_channel = 1
element = data[0]
else:
self._raise_invalid_write_num_chans_error(
number_of_channels, 1)
if auto_start is AUTO_START_UNSET:
if number_of_samples_per_channel > 1:
auto_start = False
else:
auto_start = True
# Analog Input
if write_chan_type == ChannelType.ANALOG_OUTPUT:
data = numpy.asarray(data, dtype=numpy.float64)
return _write_analog_f_64(
self._handle, data, number_of_samples_per_channel, auto_start,
timeout)
# Digital Input
elif write_chan_type == ChannelType.DIGITAL_OUTPUT:
if self.out_stream.do_num_booleans_per_chan == 1:
if (not isinstance(element, bool) and
not isinstance(element, numpy.bool_)):
raise DaqError(
'Write failed, because this write method only accepts '
'boolean samples when there is one digital line per '
'channel in a task.\n\n'
'Requested sample type: {0}'.format(type(element)),
DAQmxErrors.UNKNOWN.value, task_name=self.name)
data = numpy.asarray(data, dtype=numpy.bool)
return _write_digital_lines(
self._handle, data, number_of_samples_per_channel,
auto_start, timeout)
else:
if (not isinstance(element, six.integer_types) and
not isinstance(element, numpy.uint32)):
raise DaqError(
'Write failed, because this write method only accepts '
'unsigned 32-bit integer samples when there are '
'multiple digital lines per channel in a task.\n\n'
'Requested sample type: {0}'.format(type(element)),
DAQmxErrors.UNKNOWN.value, task_name=self.name)
data = numpy.asarray(data, dtype=numpy.uint32)
return _write_digital_u_32(
self._handle, data, number_of_samples_per_channel,
auto_start, timeout)
# Counter Input
elif write_chan_type == ChannelType.COUNTER_OUTPUT:
output_type = channels_to_write.co_output_type
if number_of_samples_per_channel == 1:
data = [data]
if output_type == UsageTypeCO.PULSE_FREQUENCY:
frequencies = []
duty_cycles = []
for sample in data:
frequencies.append(sample.duty_cycle)
duty_cycles.append(sample.freq)
frequencies = numpy.asarray(frequencies, dtype=numpy.float64)
duty_cycles = numpy.asarray(duty_cycles, dtype=numpy.float64)
return _write_ctr_freq(
self._handle, frequencies, duty_cycles,
number_of_samples_per_channel, auto_start, timeout)
elif output_type == UsageTypeCO.PULSE_TIME:
high_times = []
low_times = []
for sample in data:
high_times.append(sample.high_time)
low_times.append(sample.low_time)
high_times = numpy.asarray(high_times, dtype=numpy.float64)
low_times = numpy.asarray(low_times, dtype=numpy.float64)
return _write_ctr_time(
self._handle, high_times, low_times,
number_of_samples_per_channel, auto_start, timeout)
elif output_type == UsageTypeCO.PULSE_TICKS:
high_ticks = []
low_ticks = []
for sample in data:
high_ticks.append(sample.high_tick)
low_ticks.append(sample.low_tick)
high_ticks = numpy.asarray(high_ticks, dtype=numpy.uint32)
low_ticks = numpy.asarray(low_ticks, dtype=numpy.uint32)
return _write_ctr_ticks(
self._handle, high_ticks, low_ticks,
number_of_samples_per_channel, auto_start, timeout)
else:
raise DaqError(
'Write failed, because there are no output channels in this '
'task to which data can be written.',
DAQmxErrors.WRITE_NO_OUTPUT_CHANS_IN_TASK.value,
task_name=self.name)