def digital_tsm_s(tsm, tests_pins):
"""Returns LabVIEW Cluster equivalent data
This fixture accepts single pin in string format or
multiple pins in list of string format"""
digital_tsms = []
for test_pin in tests_pins:
if isinstance(test_pin, str):
digital_tsms.append(dt_dpi.pins_to_sessions(tsm, test_pin))
elif isinstance(test_pin, list):
digital_tsms.append(dt_dpi.pins_to_sessions(tsm, test_pin))
else:
assert False # unexpected datatype
return digital_tsms
def hram(tsm: SMContext, pins: typing.List[str]):
dpi_pin1 = dt_dpi.pins_to_sessions(tsm, pins[0])
hram_configuration = dt_dpi.HRAMConfiguration()
hram_configuration.trigger_type = enums.HistoryRAMTriggerType.PATTERN_LABEL
hram_configuration.pattern_label = "start_burst"
hram_configuration.cycles_to_acquire = enums.HistoryRAMCyclesToAcquire.ALL
dpi_pin1.ssc.configure_hram(hram_configuration)
hram_configuration = dpi_pin1.get_hram_configuration()
dpi_pin1.ssc.burst_pattern("start_burst")
dpi_pin1.ssc.wait_until_done()
per_site_cycle_information = dpi_pin1.stream_hram_results()
for cycle_information in per_site_cycle_information:
assert not cycle_information
files_generated = dpi_pin1.log_hram_results(
[[
HistoryRAMCycleInformation(
"start_burst",
"time_set",
0,
0,
0,
[enums.PinState.X] * 3,
[enums.PinState.X] * 3,
[False] * 3,
)
] * 2] * 3,
"Pattern Name",
os.path.dirname(os.path.realpath(__file__)) + r"\log",
)
for file in files_generated:
assert isinstance(file, str)
def configuration(tsm: SMContext, pins: typing.List[str]):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_tsm.ssc.clear_start_trigger_signal()
dpi_tsm.ssc.configure_trigger_signal(dt_dpi.PXI_TRIGGER_LINE.PXI_TRIG0)
dpi_tsm.ssc.select_function(enums.SelectedFunction.DIGITAL)
dpi_tsm.ssc.export_opcode_trigger_signal(
dt_dpi.SIGNAL_ID.PATTERN_OPCODE_EVENT0, dt_dpi.PXI_TRIGGER_LINE.PXI_TRIG0
)
def session_properties_func(tsm: SMContext, pins: typing.List[str]):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
session_properties = dpi_tsm.ssc.get_properties()
for session_property in session_properties:
assert session_property[0].startswith("DPI")
assert math.isclose(session_property[1], 0.0015, abs_tol=5e-6)
assert math.isclose(session_property[2], 0.0015, abs_tol=5e-6)
assert math.isclose(session_property[3], 0.0015, abs_tol=5e-6)
assert math.isclose(session_property[4], 0.0015, abs_tol=5e-6)
assert math.isclose(session_property[5], 0.0015, abs_tol=5e-6)
def frequency_measurement_func(tsm: SMContext, pins: typing.List[str]):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_tsm.ssc.frequency_counter_configure_measurement_time(0.5)
per_site_per_pin_frequency_measurements = dpi_tsm.frequency_counter_measure_frequency()
assert isinstance(per_site_per_pin_frequency_measurements, list)
print(numpy.shape(per_site_per_pin_frequency_measurements))
assert numpy.shape(per_site_per_pin_frequency_measurements) == (1, 2)
for frequency_measurements in per_site_per_pin_frequency_measurements:
for frequency_measurement in frequency_measurements:
assert isinstance(frequency_measurement, float)
def clock_generation(tsm: SMContext, pins: typing.List[str]):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
frequency = 25000
dpi_tsm.ssc.modify_time_set_for_clock_generation(frequency, 0.5, "time_set")
dpi_tsm.ssc.clock_generator_generate_clock(frequency)
for ssc in dpi_tsm.ssc.sessions_sites_channels:
assert ssc._channels_session.clock_generator_is_running
assert round(ssc._channels_session.clock_generator_frequency) == frequency
dpi_tsm.ssc.clock_generator_abort()
for ssc in dpi_tsm.ssc.sessions_sites_channels:
assert not ssc._channels_session.clock_generator_is_running
def source_and_capture_waveforms(tsm: SMContext, pins: typing.List[str]):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_tsm.write_source_waveform_site_unique(
"SourceWaveform_SiteUnique", [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]], True
)
dpi_tsm.ssc.write_source_waveform_broadcast("SourceWaveform", [1, 2, 3, 4, 5], True)
dpi_tsm.ssc.burst_pattern("start_capture")
per_site_waveforms = dpi_tsm.fetch_capture_waveform("CaptureWaveform", 2)
assert isinstance(per_site_waveforms, list)
assert numpy.shape(per_site_waveforms) == (3, 2)
for waveforms in per_site_waveforms:
for waveform in waveforms:
assert isinstance(waveform, int)
def static(tsm: SMContext, pins: typing.List[str]):
dpi_pin1 = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_pin1.ssc.write_static(enums.WriteStaticPinState.ONE)
dpi_pin1.write_static_per_site([enums.WriteStaticPinState.ONE] * 3)
dpi_pin1.write_static_per_site_per_pin(
[[enums.WriteStaticPinState.ONE, enums.WriteStaticPinState.ONE]] * 3)
per_site_per_pin_data = dpi_pin1.read_static()
assert isinstance(per_site_per_pin_data, list)
print(numpy.shape(per_site_per_pin_data))
assert numpy.shape(per_site_per_pin_data) == (1, 2)
for data in per_site_per_pin_data:
for _data in data:
assert isinstance(_data, enums.PinState)
def pin_levels_and_timing(tsm: SMContext, pins: typing.List[str]):
# ctypes.windll.user32.MessageBoxW(None, "niPythonHost Process ID:" + str(os.getpid()), "Attach debugger", 0)
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_tsm.ssc.apply_levels_and_timing("PinLevels", "Timing")
dpi_tsm.apply_tdr_offsets_per_site_per_pin(
[
[
1e-9,
]
]
* 3
)
dpi_tsm.ssc.apply_tdr_offsets(
[
[
1e-9,
1e-9,
]
]
* 1,
)
dpi_tsm.ssc.configure_active_load(0.0015, 0.0015, -0.0015)
dpi_tsm.configure_single_level_per_site(dt_dpi.LevelTypeToSet.VIL, [0.0015, 0.0015, 0.0015])
dpi_tsm.ssc.configure_single_level(dt_dpi.LevelTypeToSet.VIL, 0.0015)
dpi_tsm.ssc.configure_termination_mode(enums.TerminationMode.HIGH_Z)
dpi_tsm.configure_time_set_compare_edge_per_site_per_pin(
"time_set",
[
[
40e-6,
]
]
* 3,
)
dpi_tsm.configure_time_set_compare_edge_per_site("time_set", [40e-6, 40e-6, 40e-6])
dpi_tsm.ssc.configure_time_set_compare_edge("time_set", 40e-6)
dpi_tsm.ssc.configure_voltage_levels(0.0015, 0.0015, 0.0015, 0.0015, 0.0015)
configured_period = dpi_tsm.ssc.configure_time_set_period("time_set", 40e-6)
assert math.isclose(configured_period, 40e-6, abs_tol=5e-6)
for ssc in dpi_tsm.ssc.sessions_sites_channels:
assert math.isclose(ssc._channels_session.active_load_ioh, -0.0015, abs_tol=5e-6)
assert math.isclose(ssc._channels_session.active_load_iol, 0.0015, abs_tol=5e-6)
assert math.isclose(ssc._channels_session.active_load_vcom, 0.0015, abs_tol=5e-6)
assert math.isclose(ssc._channels_session.vih, 0.0015, abs_tol=5e-6)
assert math.isclose(ssc._channels_session.vil, 0.0015, abs_tol=5e-6)
assert math.isclose(ssc._channels_session.voh, 0.0015, abs_tol=5e-6)
assert math.isclose(ssc._channels_session.vol, 0.0015, abs_tol=5e-6)
assert math.isclose(ssc._channels_session.vterm, 0.0015, abs_tol=5e-6)
assert ssc._channels_session.tdr_offset.femtoseconds == 1000000
def sequencer_flags_and_registers(tsm: SMContext, pins: typing.List[str]):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_tsm.ssc.write_sequencer_flag(enums.SequencerFlag.FLAG1, True)
dpi_tsm.ssc.write_sequencer_register(enums.SequencerRegister.REGISTER1, 1)
per_instrument_state = dpi_tsm.ssc.read_sequencer_flag(enums.SequencerFlag.FLAG1)
assert isinstance(per_instrument_state, list)
assert numpy.shape(per_instrument_state) == (1,)
for state in per_instrument_state:
assert isinstance(state, bool)
per_instrument_register_values = dpi_tsm.ssc.read_sequencer_register(
enums.SequencerRegister.REGISTER1
)
assert isinstance(per_instrument_register_values, list)
assert numpy.shape(per_instrument_register_values) == (1,)
for register_value in per_instrument_register_values:
assert isinstance(register_value, int)
def initialize_sessions(tsm: SMContext):
ctypes.windll.user32.MessageBoxW(
None,
"Process: niPythonHost.exe & ID: " + str(os.getpid()),
"Attach debugger",
0,
)
print(tsm.pin_map_file_path)
pins = SMContext.get_pin_names(
tsm, instrument_type_id=nitsm.enums.InstrumentTypeIdConstants.NI_DIGITAL_PATTERN
)
print(pins)
dt_dpi.initialize_sessions(tsm, options=OPTIONS)
dpi_tsm_i_o = dt_dpi.pins_to_sessions(tsm, ["DPI_PG_Inputs", "DPI_PG_Outputs"])
dpi_tsm_i_o.ssc.apply_levels_and_timing("I2C_Levels", "I2C_Timing")
dpi_tsm_i_o.ssc.select_function(dt_dpi.enums.SelectedFunction.DIGITAL)
def ppmu(tsm: SMContext, pins: typing.List[str]):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_tsm.ssc.ppmu_configure_aperture_time(0.01)
dpi_tsm.ssc.ppmu_configure_current_limit_range(0.01)
dpi_tsm.ssc.ppmu_configure_voltage_limits(0.01, 0.01)
dpi_tsm.ssc.ppmu_source_current(0.01)
dpi_tsm.ssc.ppmu_source_voltage_per_site_per_pin(0.01, [[0.01, 0.01]] * 3)
dpi_tsm.ppmu_source_voltage_per_site(0.01, [0.01, 0.01, 0.01])
dpi_tsm.ssc.ppmu_source()
per_site_per_pin_measurements = dpi_tsm.ppmu_measure_current()
assert isinstance(per_site_per_pin_measurements, list)
assert numpy.shape(per_site_per_pin_measurements) == (1, 2)
for measurements in per_site_per_pin_measurements:
for measurement in measurements:
assert isinstance(measurement, float)
dpi_tsm.ssc.ppmu_source_voltage(0.01, 0.01)
per_site_per_pin_measurements = dpi_tsm.ppmu_measure_voltage()
assert isinstance(per_site_per_pin_measurements, list)
assert numpy.shape(per_site_per_pin_measurements) == (1, 2)
for measurements in per_site_per_pin_measurements:
for measurement in measurements:
assert isinstance(measurement, float)
def pattern_actions(tsm: SMContext, pins: typing.List[str]):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_tsm.ssc.abort()
dpi_tsm.ssc.burst_pattern("start_burst")
dpi_tsm.ssc.wait_until_done()
per_site_pass = dpi_tsm.burst_pattern_pass_fail("start_burst")
assert isinstance(per_site_pass, list)
print(numpy.shape(per_site_pass))
assert numpy.shape(per_site_pass) == (1,)
for status in per_site_pass:
assert isinstance(status, bool)
per_site_per_pin_fail_counts = dpi_tsm.get_fail_count()
assert isinstance(per_site_per_pin_fail_counts, list)
print(numpy.shape(per_site_per_pin_fail_counts))
assert numpy.shape(per_site_per_pin_fail_counts) == (1, 2)
for fail_counts in per_site_per_pin_fail_counts:
for fail_count in fail_counts:
assert isinstance(fail_count, int)
per_site_pass = dpi_tsm.get_site_pass_fail()
assert isinstance(per_site_pass, list)
assert numpy.shape(per_site_pass) == (1,)
for status in per_site_pass:
assert isinstance(status, bool)
def burst_pattern(tsm: SMContext):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, ["DPI_DO_SCL", "DPI_DO_SDA"])
dpi_tsm.ssc.apply_levels_and_timing("I2C_Levels", "I2C_Timing")
per_site_pass = dpi_tsm.burst_pattern_pass_fail("I2C_Read_Loop")
print(per_site_pass)
def read_pins(tsm: SMContext):
dpi_tsm_i = dt_dpi.pins_to_sessions(tsm, ["DPI_PG_Inputs"])
# dpi_tsm_i.ssc.select_function(ni_dt_digital.enums.SelectedFunction.DIGITAL)
data = dpi_tsm_i.read_static()
print(data)
return data
def configure_pins(tsm: SMContext):
dpi_tsm_o = dt_dpi.pins_to_sessions(tsm, ["DPI_PG_Outputs"])
dpi_tsm_o.ssc.select_function(dt_dpi.enums.SelectedFunction.DIGITAL)
dpi_tsm_o.ssc.write_static(dt_dpi.enums.WriteStaticPinState.ZERO)
def misc(tsm: SMContext, pins: typing.List[str]):
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_tsm1 = dt_dpi.filter_sites(dpi_tsm, [0])
for ssc in dpi_tsm1.ssc.sessions_sites_channels:
assert ssc._pins == "site0"
dpi_tsm1 = dt_dpi.filter_sites(dpi_tsm, [1])
for ssc in dpi_tsm1.ssc.sessions_sites_channels:
assert ssc.site_list == "site1"
dpi_tsm1 = dt_dpi.filter_sites(dpi_tsm, [2])
for ssc in dpi_tsm1.ssc.sessions_sites_channels:
assert ssc.site_list == "site2"
dpi_tsm = dt_dpi.pins_to_sessions(tsm, pins[0])
dpi_tsm.ssc.initiate()
dpi_tsm.ssc.abort()
per_instrument_to_per_site_lut = dpi_tsm.ssc.calculate_per_instrument_to_per_site_lut(
dpi_tsm.sites
)
per_site_data = dt_dpi._apply_lut_per_instrument_to_per_site(
[False, False, False],
per_instrument_to_per_site_lut,
[[False, False, False], [True, True, True]],
)
assert len(per_site_data) == len([True, True, True])
# assert per_site_data == [True, True, True]
print(per_site_data)
per_site_data = dt_dpi._apply_lut_per_instrument_to_per_site(
[[False, False]] * 3,
per_instrument_to_per_site_lut,
[[[False, False]] * 3, [[True, True]] * 3],
)
# assert per_site_data == [[True, True]] * 3
print(per_site_data)
per_instrument_to_per_site_per_pin_lut = (
dpi_tsm.ssc.calculate_per_instrument_to_per_site_per_pin_lut(dpi_tsm.sites, dpi_tsm.pins)
)
per_site_per_pin_data = dt_dpi._apply_lut_per_instrument_to_per_site_per_pin(
[[0, 0], [0, 0], [0, 0]],
per_instrument_to_per_site_per_pin_lut,
[[1, 2, 3], [4, 5, 6]],
)
# assert per_site_per_pin_data == [[1, 4], [2, 5], [3, 6]]
print(per_site_per_pin_data)
(
per_site_to_per_instrument_lut,
_,
_,
) = dpi_tsm.ssc.calculate_per_site_to_per_instrument_lut(dpi_tsm.sites)
per_instrument_data = dt_dpi._apply_lut_per_site_to_per_instrument(
[[0, 0, 0], [0, 0, 0]], per_site_to_per_instrument_lut, [1, 2, 3]
)
# assert per_instrument_data == [[1, 2, 3], [0, 0, 0]]
print(per_instrument_data)
(
per_site_per_pin_to_per_instrument_lut,
_,
_,
) = dpi_tsm.ssc.calculate_per_site_per_pin_to_per_instrument_lut(dpi_tsm.sites, dpi_tsm.pins)
per_instrument_data = dt_dpi._apply_lut_per_site_per_pin_to_per_instrument(
[[0, 0, 0], [0, 0, 0]],
per_site_per_pin_to_per_instrument_lut,
[[1, 4], [2, 5], [3, 6]],
)
# assert per_instrument_data == [[1, 2, 3], [4, 5, 6]]
print(per_instrument_data)
# dpi_tsm.publish([1.0, 1.0, 1.0], "Publish_1")
dpi_tsm.publish([[1.0, 1.0, 1.0]], "Publish_1")
dpi_tsm.publish([[1.0, 1.0], [1.0, 1.0], [1.0, 1.0]], "Publish_2")
# dpi_tsm.publish([True, True, True], "Publish_3")
dpi_tsm.publish([[True, True, True]], "Publish_3")
dpi_tsm.publish([[True, True], [True, True], [True, True]], "Publish_4")
