def example(resource_name, options, voltage1, voltage2, delay):
timeout = hightime.timedelta(seconds=(delay + 1.0))
with nidcpower.Session(resource_name=resource_name,
options=options) as session:
# Configure the session.
session.source_mode = nidcpower.SourceMode.SINGLE_POINT
session.output_function = nidcpower.OutputFunction.DC_VOLTAGE
session.current_limit = .06
session.voltage_level_range = 5.0
session.current_limit_range = .06
session.source_delay = hightime.timedelta(seconds=delay)
session.measure_when = nidcpower.MeasureWhen.AUTOMATICALLY_AFTER_SOURCE_COMPLETE
session.voltage_level = voltage1
with session.initiate():
channel_indices = '0-{0}'.format(session.channel_count - 1)
channels = session.get_channel_names(channel_indices)
for channel_name in channels:
print('Channel: {0}'.format(channel_name))
print('---------------------------------')
print('Voltage 1:')
print_fetched_measurements(
session.channels[channel_name].fetch_multiple(
count=1, timeout=timeout))
session.voltage_level = voltage2 # on-the-fly set
print('Voltage 2:')
print_fetched_measurements(
session.channels[channel_name].fetch_multiple(
count=1, timeout=timeout))
session.output_enabled = False
print('')
def test_reset_with_defaults(session):
deault_meas_time_histogram_high_time = session.meas_time_histogram_high_time
assert deault_meas_time_histogram_high_time == hightime.timedelta(microseconds=500)
session.meas_time_histogram_high_time = hightime.timedelta(microseconds=1000)
non_default_meas_time_histogram_high_time = session.meas_time_histogram_high_time
assert non_default_meas_time_histogram_high_time == hightime.timedelta(microseconds=1000)
session.reset_device()
assert session.meas_time_histogram_high_time == hightime.timedelta(microseconds=500)
def test_datetime_utcoffset():
assert datetime().utcoffset() is None
assert (datetime(tzinfo=std_datetime.timezone.utc).utcoffset() ==
std_datetime.timedelta())
assert datetime(tzinfo=tzinfo(
hours=1)).utcoffset() == std_datetime.timedelta(hours=1)
assert datetime(tzinfo=std_datetime.timezone(hightime.timedelta(
hours=1))).utcoffset() == hightime.timedelta(hours=1)
def test_convert_timedeltas_to_seconds_real64():
time_values = [10.5, -5e-10]
test_result = convert_timedeltas_to_seconds_real64(time_values)
assert all([actual.value == pytest.approx(expected) for actual, expected in zip(test_result, time_values)])
assert all([isinstance(i, _visatype.ViReal64) for i in test_result])
test_input = [hightime.timedelta(seconds=10.5), hightime.timedelta(nanoseconds=-0.5)]
test_result = convert_timedeltas_to_seconds_real64(test_input)
assert all([actual.value == pytest.approx(expected) for actual, expected in zip(test_result, time_values)])
assert all([isinstance(i, _visatype.ViReal64) for i in test_result])
def example(resource_name, options, voltage_max, current_max,
points_per_output_function, delay_in_seconds):
timeout = hightime.timedelta(seconds=(delay_in_seconds + 1.0))
with nidcpower.Session(resource_name=resource_name,
options=options) as session:
# Configure the session.
session.source_mode = nidcpower.SourceMode.SEQUENCE
session.voltage_level_autorange = True
session.current_limit_autorange = True
session.source_delay = hightime.timedelta(seconds=delay_in_seconds)
properties_used = ['output_function', 'voltage_level', 'current_level']
session.create_advanced_sequence(sequence_name='my_sequence',
property_names=properties_used,
set_as_active_sequence=True)
voltage_per_step = voltage_max / points_per_output_function
for i in range(points_per_output_function):
session.create_advanced_sequence_step(set_as_active_step=False)
session.output_function = nidcpower.OutputFunction.DC_VOLTAGE
session.voltage_level = voltage_per_step * i
current_per_step = current_max / points_per_output_function
for i in range(points_per_output_function):
session.create_advanced_sequence_step(set_as_active_step=False)
session.output_function = nidcpower.OutputFunction.DC_CURRENT
session.current_level = current_per_step * i
with session.initiate():
session.wait_for_event(nidcpower.Event.SEQUENCE_ENGINE_DONE)
channel_indices = '0-{0}'.format(session.channel_count - 1)
channels = session.get_channel_names(channel_indices)
measurement_group = [
session.channels[name].fetch_multiple(
points_per_output_function * 2, timeout=timeout)
for name in channels
]
session.delete_advanced_sequence(sequence_name='my_sequence')
line_format = '{:<15} {:<4} {:<10} {:<10} {:<6}'
print(
line_format.format('Channel', 'Num', 'Voltage', 'Current',
'In Compliance'))
for i, measurements in enumerate(measurement_group):
num = 0
channel_name = channels[i].strip()
for measurement in measurements:
print(
line_format.format(channel_name, num, measurement.voltage,
measurement.current,
str(measurement.in_compliance)))
num += 1
def test_reset_with_defaults(multi_instrument_session):
deault_meas_time_histogram_high_time = multi_instrument_session.meas_time_histogram_high_time
assert deault_meas_time_histogram_high_time == hightime.timedelta(
microseconds=500)
multi_instrument_session.meas_time_histogram_high_time = hightime.timedelta(
microseconds=1000)
non_default_meas_time_histogram_high_time = multi_instrument_session.meas_time_histogram_high_time
assert non_default_meas_time_histogram_high_time == hightime.timedelta(
microseconds=1000)
multi_instrument_session.reset_device()
assert multi_instrument_session.meas_time_histogram_high_time == hightime.timedelta(
microseconds=500)
def test_convert_timedelta_to_seconds_double():
test_result = convert_timedelta_to_seconds_real64(hightime.timedelta(seconds=10))
assert test_result.value == 10.0
assert isinstance(test_result, _visatype.ViReal64)
test_result = convert_timedelta_to_seconds_real64(hightime.timedelta(nanoseconds=-0.5))
assert test_result.value == pytest.approx(-5e-10)
assert isinstance(test_result, _visatype.ViReal64)
test_result = convert_timedelta_to_seconds_real64(10.5)
assert test_result.value == 10.5
assert isinstance(test_result, _visatype.ViReal64)
test_result = convert_timedelta_to_seconds_real64(-1)
assert test_result.value == -1
assert isinstance(test_result, _visatype.ViReal64)
def test_convert_timedelta_to_milliseconds_int32():
test_result = convert_timedelta_to_milliseconds_int32(hightime.timedelta(seconds=10))
assert test_result.value == 10000
assert isinstance(test_result, _visatype.ViInt32)
test_result = convert_timedelta_to_milliseconds_int32(hightime.timedelta(seconds=-5))
assert test_result.value == -5000
assert isinstance(test_result, _visatype.ViInt32)
test_result = convert_timedelta_to_milliseconds_int32(10.5)
assert test_result.value == 10500
assert isinstance(test_result, _visatype.ViInt32)
test_result = convert_timedelta_to_milliseconds_int32(-1)
assert test_result.value == -1000
assert isinstance(test_result, _visatype.ViInt32)
def test_set_timedelta_as_timedelta(self):
session = nitclk.SessionReference(SESSION_NUM_FOR_TEST)
self.patched_library.niTClk_SetAttributeViReal64.side_effect = self.side_effects_helper.niTClk_SetAttributeViReal64
attribute_id = 11
test_number = 4.2
session.sample_clock_delay = hightime.timedelta(seconds=test_number)
self.patched_library.niTClk_SetAttributeViReal64.assert_called_once_with(_matchers.ViSessionMatcher(SESSION_NUM_FOR_TEST), _matchers.ViStringMatcher(''), _matchers.ViAttrMatcher(attribute_id), _matchers.ViReal64Matcher(test_number))
def wait_for_debounce(self,
maximum_time_ms=hightime.timedelta(milliseconds=-1)):
r'''wait_for_debounce
Waits for all of the switches in the NI Switch Executive virtual device
to debounce. This method does not return until either the switching
system is completely debounced and settled or the maximum time has
elapsed and the system is not yet debounced. In the event that the
maximum time elapses, the method returns an error indicating that a
timeout has occurred. To ensure that all of the switches have settled,
NI recommends calling wait_for_debounce after a series of connection
or disconnection operations and before taking any measurements of the
signals connected to the switching system.
Args:
maximum_time_ms (hightime.timedelta, datetime.timedelta, or int in milliseconds): The amount of time to wait (in milliseconds) for the debounce to
complete. A value of 0 checks for debouncing once and returns an error
if the system is not debounced at that time. A value of -1 means to
block for an infinite period of time until the system is debounced.
'''
vi_ctype = _visatype.ViSession(self._vi) # case S110
maximum_time_ms_ctype = _converters.convert_timedelta_to_milliseconds_int32(
maximum_time_ms) # case S140
error_code = self._library.niSE_WaitForDebounce(
vi_ctype, maximum_time_ms_ctype)
errors.handle_error(self,
error_code,
ignore_warnings=False,
is_error_handling=False)
return
def test_fetch_array_measurement(multi_instrument_session,
measurement_wfm_length):
test_voltage = 1.0
test_record_length = 1000
test_num_channels = 2
test_meas_wfm_length = measurement_wfm_length.passed_in
test_array_meas_function = niscope.ArrayMeasurement.ARRAY_GAIN
test_starting_record_number = 2
test_num_records_to_acquire = 5
test_num_records_to_fetch = test_num_records_to_acquire - test_starting_record_number
multi_instrument_session.configure_vertical(test_voltage,
niscope.VerticalCoupling.AC)
multi_instrument_session.configure_horizontal_timing(
50000000, test_record_length, 50.0, test_num_records_to_acquire, True)
with multi_instrument_session.initiate():
waveforms = multi_instrument_session.channels[
test_channels].fetch_array_measurement(
array_meas_function=test_array_meas_function,
meas_wfm_size=test_meas_wfm_length,
relative_to=niscope.FetchRelativeTo.PRETRIGGER,
offset=5,
record_number=test_starting_record_number,
num_records=test_num_records_to_fetch,
meas_num_samples=2000,
timeout=hightime.timedelta(seconds=4))
assert len(waveforms) == test_num_channels * test_num_records_to_fetch
expected_channels = test_channels.split(',') * test_num_records_to_fetch
expected_records = [2, 2, 3, 3, 4, 4]
for i in range(len(waveforms)):
assert len(waveforms[i].samples) == measurement_wfm_length.expected
assert waveforms[i].channel == expected_channels[i]
assert waveforms[i].record == expected_records[i]
def __hash__(self):
t = self.replace(fold=0) if getattr(self, "fold", 0) else self
offset = t.utcoffset()
if offset is None:
return hash((
self.year,
self.month,
self.day,
self.hour,
self.minute,
self.second,
self.microsecond,
self.femtosecond,
self.yoctosecond,
))
else:
return hash(
hightime.timedelta(
days=self.toordinal(),
hours=self.hour,
minutes=self.minute,
seconds=self.second,
microseconds=self.microsecond,
femtoseconds=self.femtosecond,
yoctoseconds=self.yoctosecond,
) - offset)
def test_fetch_measurement_stats(multi_instrument_session):
test_voltage = 1.0
test_record_length = 1000
test_num_channels = 2
test_num_records = 3
test_starting_record_number = 2
test_num_records_to_acquire = 5
test_num_records_to_fetch = test_num_records_to_acquire - test_starting_record_number
multi_instrument_session.configure_vertical(test_voltage,
niscope.VerticalCoupling.AC)
multi_instrument_session.configure_horizontal_timing(
50000000, test_record_length, 50.0, test_num_records_to_acquire, True)
with multi_instrument_session.initiate():
measurement_stats = multi_instrument_session.channels[
test_channels].fetch_measurement_stats(
scalar_meas_function=niscope.enums.ScalarMeasurement.
NO_MEASUREMENT,
relative_to=niscope.FetchRelativeTo.PRETRIGGER,
offset=5,
record_number=test_starting_record_number,
num_records=test_num_records_to_fetch,
timeout=hightime.timedelta(seconds=4))
assert len(measurement_stats) == test_num_channels * test_num_records
expected_channels = test_channels.split(',') * test_num_records_to_fetch
expected_records = [2, 2, 3, 3, 4, 4]
for i in range(len(measurement_stats)):
assert measurement_stats[i].result == 0.0
assert measurement_stats[i].channel == expected_channels[i]
assert measurement_stats[i].record == expected_records[i]
def __add__(self, other):
"Add a datetime and a timedelta."
if not isinstance(other, std_datetime.timedelta):
return NotImplemented
delta = hightime.timedelta(
self.toordinal(),
hours=self.hour,
minutes=self.minute,
seconds=self.second,
microseconds=self.microsecond,
femtoseconds=self.femtosecond,
yoctoseconds=self.yoctosecond,
)
delta += other
if 0 < delta.days <= datetime.max.toordinal():
date = std_datetime.date.fromordinal(delta.days)
hour, minute = divmod(delta.seconds, 3600)
minute, second = divmod(minute, 60)
return datetime(
date.year,
date.month,
date.day,
hour,
minute,
second,
delta.microseconds,
delta.femtoseconds,
delta.yoctoseconds,
tzinfo=self.tzinfo,
)
raise OverflowError("result out of range")
def __sub__(self, other):
"Subtract two datetimes, or a datetime and a timedelta."
if not isinstance(other, std_datetime.datetime):
if isinstance(other, std_datetime.timedelta):
return self + -other
return NotImplemented
base = hightime.timedelta(
days=self.toordinal() - other.toordinal(),
hours=self.hour - other.hour,
minutes=self.minute - other.minute,
seconds=self.second - other.second,
microseconds=self.microsecond - other.microsecond,
femtoseconds=self.femtosecond - getattr(other, "femtosecond", 0),
yoctoseconds=self.yoctosecond - getattr(other, "yoctosecond", 0),
)
if self.tzinfo is other.tzinfo:
return base
my_offset = self.utcoffset()
other_offset = other.utcoffset()
if my_offset == other_offset:
return base
if my_offset is None or other_offset is None:
raise TypeError("cannot mix naive and timezone-aware time")
return base + other_offset - my_offset
def test_synchronize_timedelta(self):
min_time = hightime.timedelta(seconds=0.042)
self.patched_library.niTClk_Synchronize.side_effect = self.side_effects_helper.niTClk_Synchronize
nitclk.synchronize(multiple_session_references, min_time)
self.patched_library.niTClk_Synchronize.assert_called_once_with(
_matchers.ViUInt32Matcher(len(multiple_sessions)),
_matchers.ViSessionBufferMatcher(multiple_sessions),
_matchers.ViReal64Matcher(min_time.total_seconds()))
return
def test_fetch_waveform_error(session):
number_of_points_to_read = 100
try:
session.configure_waveform_acquisition(nidmm.Function.WAVEFORM_VOLTAGE, 10, 1800000, number_of_points_to_read)
with session.initiate():
session.fetch_waveform(number_of_points_to_read * 2, maximum_time=hightime.timedelta(milliseconds=1)) # trying to fetch points more than configured
assert False
except nidmm.Error as e:
assert e.code == -1074126845 # Max Time exceeded before operation completed
def example(resource_name, channels, options, steps, voltage_start,
voltage_final, current_start, current_final):
# The Python API should provide these values. But it doesn't. Issue #504. For now, put magic values here.
attribute_ids = [
1150008, # output_function
1250001, # voltage_level
1150009, # current_level
]
with nidcpower.Session(resource_name=resource_name,
channels=channels,
options=options) as session:
session.source_mode = nidcpower.SourceMode.SEQUENCE
session.source_delay = hightime.timedelta(seconds=0.1)
session.voltage_level_autorange = True
session.current_level_autorange = True
session._create_advanced_sequence(sequence_name='my_sequence',
attribute_ids=attribute_ids)
voltages = create_sweep(voltage_start, voltage_final, steps)
currents = create_sweep(current_start, current_final, steps)
for v in voltages:
session._create_advanced_sequence_step()
session.output_function = nidcpower.OutputFunction.DC_VOLTAGE
session.voltage_level = v
for c in currents:
session._create_advanced_sequence_step()
session.output_function = nidcpower.OutputFunction.DC_CURRENT
session.current_level = c
with session.initiate():
session.wait_for_event(nidcpower.Event.SEQUENCE_ENGINE_DONE)
measurements = session.fetch_multiple(count=steps * 2)
# Print a table with the measurements
programmed_levels = voltages + currents
units = ['V'] * steps + ['A'] * steps
row_format = '{:<8} {:4} {:<25} {:<25} {}'
print(
row_format.format('Sourced', '', 'Measured voltage',
'Measured current', 'In-compliance'))
for i in range(steps * 2):
print(
row_format.format(programmed_levels[i], units[i],
measurements[i].voltage,
measurements[i].current,
measurements[i].in_compliance))
def example(resource_name, channels, options, voltage1, voltage2, delay):
timeout = hightime.timedelta(seconds=(delay + 1.0))
with nidcpower.Session(resource_name=resource_name,
channels=channels,
options=options) as session:
while True:
# Configure the session.
session.source_mode = nidcpower.SourceMode.SINGLE_POINT
session.output_function = nidcpower.OutputFunction.DC_VOLTAGE
session.current_limit = .06
session.voltage_level_range = 5.0
session.current_limit_range = .9
session.source_delay = hightime.timedelta(seconds=delay)
session.measure_when = nidcpower.MeasureWhen.AUTOMATICALLY_AFTER_SOURCE_COMPLETE
session.voltage_level = voltage1
with session.initiate():
session.output_enabled = True
session.output_connected = True
print("V1:")
print_fetched_measurements(
session.fetch_multiple(count=1, timeout=timeout))
def example(resource_name, options, total_acquisition_time_in_seconds, voltage,
sample_rate_in_hz, samples_per_fetch):
total_samples = int(total_acquisition_time_in_seconds * sample_rate_in_hz)
# 1. Opening session
with niscope.Session(resource_name=resource_name,
options=options) as session:
# We will acquire on all channels of the device
channel_list = [c for c in range(session.channel_count)
] # Need an actual list and not a range
# 2. Creating numpy arrays
waveforms = [
np.ndarray(total_samples, dtype=np.float64) for c in channel_list
]
# 3. Configuring
session.configure_horizontal_timing(min_sample_rate=sample_rate_in_hz,
min_num_pts=1,
ref_position=0.0,
num_records=1,
enforce_realtime=True)
session.channels[channel_list].configure_vertical(
voltage, coupling=niscope.VerticalCoupling.DC, enabled=True)
# Configure software trigger, but never send the trigger.
# This starts an infinite acquisition, until you call session.abort() or session.close()
session.configure_trigger_software()
current_pos = 0
# 4. initiating
with session.initiate():
while current_pos < total_samples:
# We fetch each channel at a time so we don't have to de-interleave afterwards
# We do not keep the wfm_info returned from fetch_into
for channel, waveform in zip(channel_list, waveforms):
# 5. fetching - we return the slice of the waveform array that we want to "fetch into"
session.channels[channel].fetch_into(
waveform[current_pos:current_pos + samples_per_fetch],
relative_to=niscope.FetchRelativeTo.READ_POINTER,
offset=0,
record_number=0,
num_records=1,
timeout=hightime.timedelta(seconds=5.0))
current_pos += samples_per_fetch
def convert_month_to_timedelta(months):
return hightime.timedelta(days=(30.4167 * months))
def convert_seconds_real64_to_timedelta(value):
return hightime.timedelta(seconds=value)
def timedelta(*args, **kwargs):
"""Instantiate a hightime.timedelta, allowing unit shorthand kwargs"""
_replace(kwargs, plural=True)
return hightime.timedelta(*args, **kwargs)
def test_wait_until_done(session):
session.wait_until_done(hightime.timedelta(milliseconds=20))
def __get__(self, session, session_type):
return hightime.timedelta(seconds=session._get_attribute_vi_real64(self._attribute_id))
def __get__(self, session, session_type):
return hightime.timedelta(milliseconds=session._get_attribute_vi_int32(self._attribute_id))
def test_vi_real64_attribute(session):
session.settling_time = hightime.timedelta(seconds=0.1)
assert session.settling_time.total_seconds() == 0.1
def test_wait_for_event_with_timeout(session):
with session.initiate():
session.wait_for_event(nidcpower.Event.SOURCE_COMPLETE,
hightime.timedelta(seconds=0.5))
