Examples
You can download all nidcpower examples for latest version here
nidcpower_advanced_sequence.py
1#!/usr/bin/python
2
3import argparse
4import hightime
5import nidcpower
6import sys
7
8
9def example(resource_name, options, voltage_max, current_max, points_per_output_function, source_delay):
10 with nidcpower.Session(resource_name=resource_name, options=options) as session:
11 # Configure the session.
12 session.source_mode = nidcpower.SourceMode.SEQUENCE
13 session.voltage_level_autorange = True
14 session.current_limit_autorange = True
15 session.source_delay = hightime.timedelta(seconds=source_delay)
16 properties_used = ['output_function', 'voltage_level', 'current_level']
17 session.create_advanced_sequence(sequence_name='my_sequence', property_names=properties_used, set_as_active_sequence=True)
18
19 voltage_per_step = voltage_max / points_per_output_function
20 for i in range(points_per_output_function):
21 session.create_advanced_sequence_step(set_as_active_step=False)
22 session.output_function = nidcpower.OutputFunction.DC_VOLTAGE
23 session.voltage_level = voltage_per_step * i
24
25 current_per_step = current_max / points_per_output_function
26 for i in range(points_per_output_function):
27 session.create_advanced_sequence_step(set_as_active_step=False)
28 session.output_function = nidcpower.OutputFunction.DC_CURRENT
29 session.current_level = current_per_step * i
30
31 # Calculate the timeout.
32 aperture_time = session.aperture_time
33 total_points = points_per_output_function * 2
34 timeout = hightime.timedelta(seconds=((source_delay + aperture_time) * total_points + 1.0))
35
36 with session.initiate():
37 channel_indices = f'0-{session.channel_count - 1}'
38 channels = session.get_channel_names(channel_indices)
39 measurement_group = [session.channels[name].fetch_multiple(total_points, timeout=timeout) for name in channels]
40
41 session.delete_advanced_sequence(sequence_name='my_sequence')
42 line_format = '{:<15} {:<4} {:<10} {:<10} {:<6}'
43 print(line_format.format('Channel', 'Num', 'Voltage', 'Current', 'In Compliance'))
44 for i, measurements in enumerate(measurement_group):
45 num = 0
46 channel_name = channels[i].strip()
47 for measurement in measurements:
48 print(line_format.format(channel_name, num, measurement.voltage, measurement.current, str(measurement.in_compliance)))
49 num += 1
50
51
52def _main(argsv):
53 parser = argparse.ArgumentParser(description='Output ramping voltage to voltage max, then ramping current to current max.', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
54 parser.add_argument('-n', '--resource-name', default='PXI1Slot2/0, PXI1Slot3/0-1', help='Resource names of NI SMUs.')
55 parser.add_argument('-s', '--number-steps', default=256, type=int, help='Number of steps per output function')
56 parser.add_argument('-v', '--voltage-max', default=1.0, type=float, help='Maximum voltage (V)')
57 parser.add_argument('-i', '--current-max', default=0.001, type=float, help='Maximum Current (I)')
58 parser.add_argument('-d', '--delay', default=0.05, type=float, help='Source delay (s)')
59 parser.add_argument('-op', '--option-string', default='', type=str, help='Option string')
60 args = parser.parse_args(argsv)
61 example(args.resource_name, args.option_string, args.voltage_max, args.current_max, args.number_steps, args.delay)
62
63
64def main():
65 _main(sys.argv[1:])
66
67
68def test_main():
69 cmd_line = ['--option-string', 'Simulate=1, DriverSetup=Model:4162; BoardType:PXIe', ]
70 _main(cmd_line)
71
72
73def test_example():
74 options = {'simulate': True, 'driver_setup': {'Model': '4162', 'BoardType': 'PXIe', }, }
75 example('PXI1Slot2/0, PXI1Slot3/1', options, 1.0, 0.001, 256, 0.05)
76
77
78if __name__ == '__main__':
79 main()
80
81
nidcpower_lcr_source_ac_voltage.py
1#!/usr/bin/python
2
3import argparse
4import nidcpower
5import sys
6
7
8def example(
9 resource_name,
10 options,
11 lcr_frequency,
12 lcr_impedance_range,
13 cable_length,
14 lcr_voltage_rms,
15 lcr_dc_bias_source,
16 lcr_dc_bias_voltage_level,
17 lcr_measurement_time,
18 lcr_custom_measurement_time,
19 lcr_source_delay_mode,
20 source_delay,
21):
22 with nidcpower.Session(resource_name=resource_name, options=options) as session:
23 # Configure the session.
24 session.instrument_mode = nidcpower.InstrumentMode.LCR
25 session.lcr_stimulus_function = nidcpower.LCRStimulusFunction.VOLTAGE
26 session.lcr_frequency = lcr_frequency
27 session.lcr_impedance_range = lcr_impedance_range
28 session.cable_length = cable_length
29 session.lcr_voltage_amplitude = lcr_voltage_rms
30 session.lcr_dc_bias_source = lcr_dc_bias_source
31 session.lcr_dc_bias_voltage_level = lcr_dc_bias_voltage_level
32 session.lcr_measurement_time = lcr_measurement_time
33 session.lcr_custom_measurement_time = lcr_custom_measurement_time
34 session.lcr_source_delay_mode = lcr_source_delay_mode
35 session.source_delay = source_delay
36
37 with session.initiate():
38 # Low frequencies require longer settling times than the default timeout for
39 # wait_for_event(), hence 5.0s is set here as a reasonable timeout value
40 session.wait_for_event(event_id=nidcpower.Event.SOURCE_COMPLETE, timeout=5.0)
41 measurements = session.measure_multiple_lcr()
42 for measurement in measurements:
43 print(measurement)
44
45 session.reset()
46
47
48def _main(argsv):
49 parser = argparse.ArgumentParser(
50 description='Output the specified AC voltage and DC bias voltage, then takes LCR measurements',
51 formatter_class=argparse.ArgumentDefaultsHelpFormatter
52 )
53 parser.add_argument('-n', '--resource-name', default='PXI1Slot2/0', help='Resource names of NI SMUs')
54 parser.add_argument('-f', '--lcr-frequency', default=10.0e3, type=float, help='LCR frequency (Hz)')
55 parser.add_argument('-i', '--lcr-impedance-range', default=100.0, type=float, help='LCR impedance range (Ω)')
56 parser.add_argument('-c', '--cable-length', default='NI_STANDARD_2M', type=str, choices=tuple(nidcpower.CableLength.__members__.keys()), help='Cable length')
57 parser.add_argument('-v', '--lcr-voltage-rms', default=700.0e-3, type=float, help='LCR voltage RMS (V RMS)')
58 parser.add_argument('-d', '--lcr-dc-bias-source', default='OFF', type=str, choices=tuple(nidcpower.LCRDCBiasSource.__members__.keys()), help='LCR DC bias source')
59 parser.add_argument('-dv', '--lcr-dc-bias-voltage_level', default=0.0, type=float, help='LCR DC bias voltage (V)')
60 parser.add_argument('-t', '--lcr-measurement-time', default='MEDIUM', type=str, choices=tuple(nidcpower.LCRMeasurementTime.__members__.keys()), help='LCR measurement time')
61 parser.add_argument('-ct', '--lcr-custom-measurement-time', default=10.0e-3, type=float, help='LCR custom measurement time (s)')
62 parser.add_argument('-sm', '--lcr-source-delay-mode', default='AUTOMATIC', type=str, choices=tuple(nidcpower.LCRSourceDelayMode.__members__.keys()), help='LCR source delay mode')
63 parser.add_argument('-s', '--source-delay', default=16.66e-3, type=float, help='Source delay (s)')
64 parser.add_argument('-op', '--option-string', default='', type=str, help='Option string')
65 args = parser.parse_args(argsv)
66 example(
67 resource_name=args.resource_name,
68 options=args.option_string,
69 lcr_frequency=args.lcr_frequency,
70 lcr_impedance_range=args.lcr_impedance_range,
71 cable_length=getattr(nidcpower.CableLength, args.cable_length),
72 lcr_voltage_rms=args.lcr_voltage_rms,
73 lcr_dc_bias_source=getattr(nidcpower.LCRDCBiasSource, args.lcr_dc_bias_source),
74 lcr_dc_bias_voltage_level=args.lcr_dc_bias_voltage_level,
75 lcr_measurement_time=getattr(nidcpower.LCRMeasurementTime, args.lcr_measurement_time),
76 lcr_custom_measurement_time=args.lcr_custom_measurement_time,
77 lcr_source_delay_mode=getattr(nidcpower.LCRSourceDelayMode, args.lcr_source_delay_mode),
78 source_delay=args.source_delay,
79 )
80
81
82def main():
83 _main(sys.argv[1:])
84
85
86def test_example():
87 example(
88 resource_name='PXI1Slot2/0',
89 options={'simulate': True, 'driver_setup': {'Model': '4190', 'BoardType': 'PXIe', }, },
90 lcr_frequency=10.0e3,
91 lcr_impedance_range=100.0,
92 cable_length=nidcpower.CableLength.NI_STANDARD_2M,
93 lcr_voltage_rms=700.0e-3,
94 lcr_dc_bias_source=nidcpower.LCRDCBiasSource.OFF,
95 lcr_dc_bias_voltage_level=0.0,
96 lcr_measurement_time=nidcpower.LCRMeasurementTime.MEDIUM,
97 lcr_custom_measurement_time=10.0e-3,
98 lcr_source_delay_mode=nidcpower.LCRSourceDelayMode.AUTOMATIC,
99 source_delay=16.66e-3,
100 )
101
102
103def test_main():
104 cmd_line = ['--option-string', 'Simulate=1, DriverSetup=Model:4190; BoardType:PXIe', ]
105 _main(cmd_line)
106
107
108if __name__ == '__main__':
109 main()
nidcpower_measure_record.py
1#!/usr/bin/python
2
3import argparse
4import nidcpower
5import sys
6
7
8def example(resource_name, options, voltage, length):
9 with nidcpower.Session(resource_name=resource_name, options=options) as session:
10 # Configure the session.
11 session.measure_record_length = length
12 session.measure_record_length_is_finite = True
13 session.measure_when = nidcpower.MeasureWhen.AUTOMATICALLY_AFTER_SOURCE_COMPLETE
14 session.output_function = nidcpower.OutputFunction.DC_VOLTAGE
15 session.voltage_level = voltage
16
17 session.commit()
18 print(f'Effective measurement rate: {session.measure_record_delta_time / 1} S/s')
19
20 print('Channel Num Voltage Current In Compliance')
21 row_format = '{0:15} {1:3d} {2:8.6f} {3:8.6f} {4}'
22 with session.initiate():
23 channel_indices = f'0-{session.channel_count - 1}'
24 channels = session.get_channel_names(channel_indices)
25 for i, channel_name in enumerate(channels):
26 samples_acquired = 0
27 while samples_acquired < length:
28 measurements = session.channels[channel_name].fetch_multiple(count=session.fetch_backlog)
29 samples_acquired += len(measurements)
30 for i in range(len(measurements)):
31 print(row_format.format(channel_name, i, measurements[i].voltage, measurements[i].current, measurements[i].in_compliance))
32
33
34def _main(argsv):
35 parser = argparse.ArgumentParser(description='Outputs the specified voltage, then takes the specified number of voltage and current readings.', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
36 parser.add_argument('-n', '--resource-name', default='PXI1Slot2/0, PXI1Slot3/0-1', help='Resource names of NI SMUs.')
37 parser.add_argument('-l', '--length', default='20', type=int, help='Measure record length per channel')
38 parser.add_argument('-v', '--voltage', default=5.0, type=float, help='Voltage level (V)')
39 parser.add_argument('-op', '--option-string', default='', type=str, help='Option string')
40 args = parser.parse_args(argsv)
41 example(args.resource_name, args.option_string, args.voltage, args.length)
42
43
44def main():
45 _main(sys.argv[1:])
46
47
48def test_example():
49 options = {'simulate': True, 'driver_setup': {'Model': '4162', 'BoardType': 'PXIe', }, }
50 example('PXI1Slot2/0, PXI1Slot3/1', options, 5.0, 20)
51
52
53def test_main():
54 cmd_line = ['--option-string', 'Simulate=1, DriverSetup=Model:4162; BoardType:PXIe', ]
55 _main(cmd_line)
56
57
58if __name__ == '__main__':
59 main()
nidcpower_source_delay_measure.py
1#!/usr/bin/python
2
3import argparse
4import hightime
5import nidcpower
6import sys
7
8
9def print_fetched_measurements(measurements):
10 print(f' Voltage : {measurements[0].voltage:f} V')
11 print(f' Current: {measurements[0].current:f} A')
12 print(f' In compliance: {measurements[0].in_compliance}')
13
14
15def example(resource_name, options, voltage1, voltage2, delay):
16 timeout = hightime.timedelta(seconds=(delay + 1.0))
17
18 with nidcpower.Session(resource_name=resource_name, options=options) as session:
19 # Configure the session.
20 session.source_mode = nidcpower.SourceMode.SINGLE_POINT
21 session.output_function = nidcpower.OutputFunction.DC_VOLTAGE
22 session.current_limit = .06
23 session.voltage_level_range = 5.0
24 session.current_limit_range = .06
25 session.source_delay = hightime.timedelta(seconds=delay)
26 session.measure_when = nidcpower.MeasureWhen.AUTOMATICALLY_AFTER_SOURCE_COMPLETE
27 session.voltage_level = voltage1
28
29 with session.initiate():
30 channel_indices = f'0-{session.channel_count - 1}'
31 channels = session.get_channel_names(channel_indices)
32 for channel_name in channels:
33 print(f'Channel: {channel_name}')
34 print('---------------------------------')
35 print('Voltage 1:')
36 print_fetched_measurements(session.channels[channel_name].fetch_multiple(count=1, timeout=timeout))
37 session.voltage_level = voltage2 # on-the-fly set
38 print('Voltage 2:')
39 print_fetched_measurements(session.channels[channel_name].fetch_multiple(count=1, timeout=timeout))
40 session.output_enabled = False
41 print('')
42
43
44def _main(argsv):
45 parser = argparse.ArgumentParser(description='Outputs voltage 1, waits for source delay, and then takes a measurement. Then orepeat with voltage 2.', formatter_class=argparse.ArgumentDefaultsHelpFormatter)
46 parser.add_argument('-n', '--resource-name', default='PXI1Slot2/0, PXI1Slot3/0-1', help='Resource names of an NI SMUs.')
47 parser.add_argument('-v1', '--voltage1', default=1.0, type=float, help='Voltage level 1 (V)')
48 parser.add_argument('-v2', '--voltage2', default=2.0, type=float, help='Voltage level 2 (V)')
49 parser.add_argument('-d', '--delay', default=0.05, type=float, help='Source delay (s)')
50 parser.add_argument('-op', '--option-string', default='', type=str, help='Option string')
51 args = parser.parse_args(argsv)
52 example(args.resource_name, args.option_string, args.voltage1, args.voltage2, args.delay)
53
54
55def main():
56 _main(sys.argv[1:])
57
58
59def test_main():
60 cmd_line = ['--option-string', 'Simulate=1, DriverSetup=Model:4162; BoardType:PXIe', ]
61 _main(cmd_line)
62
63
64def test_example():
65 options = {'simulate': True, 'driver_setup': {'Model': '4162', 'BoardType': 'PXIe', }, }
66 example('PXI1Slot2/0, PXI1Slot3/1', options, 1.0, 2.0, 0.05)
67
68
69if __name__ == '__main__':
70 main()
71
72