From 7c29721b3bcaa54a04a11b909e951662f9bf2b9f Mon Sep 17 00:00:00 2001 From: bkumarng Date: Tue, 11 Aug 2026 17:23:08 +0530 Subject: [PATCH 1/3] Adding one example each in NI-DMM, NI-DCPower, and NI-SWITCH. Adding one new example each in NI-DMM, NI-DCPower, and NI-SWITCH. --- .../nidcpower_hardware_timed_single_point.py | 135 +++++++++ .../nidmm_triggered_fetch_waveform.py | 263 ++++++++++++++++++ .../examples/niswitch_software_scanning.py | 155 +++++++++++ 3 files changed, 553 insertions(+) create mode 100644 src/nidcpower/examples/nidcpower_hardware_timed_single_point.py create mode 100644 src/nidmm/examples/nidmm_triggered_fetch_waveform.py create mode 100644 src/niswitch/examples/niswitch_software_scanning.py diff --git a/src/nidcpower/examples/nidcpower_hardware_timed_single_point.py b/src/nidcpower/examples/nidcpower_hardware_timed_single_point.py new file mode 100644 index 0000000000..4437b04fc9 --- /dev/null +++ b/src/nidcpower/examples/nidcpower_hardware_timed_single_point.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python3 +"""NI-DCPower Hardware-Timed Single Point. + +This example demonstrates how to set up a hardware-timed Single Point operation. + +The hardware is configured to source a voltage, wait for a specified delay and +then take a measurement. + +The example uses the default resource name, channel, current level, +and voltage limit. Modify these values as needed for your measurement setup + +HOW TO RUN: +----------- +i. From terminal (with default values): + python nidcpower_hardware_timed_single_point.py + +ii. From terminal (with custom values): + python nidcpower_hardware_timed_single_point.py -n "PXI1Slot1" \ + -vl1 3.0 -vl2 5.0 -sd 0.1 + +iii. To simulate without hardware: + PowerShell: python nidcpower_hardware_timed_single_point.py \ + -op 'Simulate=1, DriverSetup=Model:4139; BoardType:PXIe' + cmd.exe: python nidcpower_hardware_timed_single_point.py \ + -op "Simulate=1, DriverSetup=Model:4139; BoardType:PXIe" + +""" + +# Module imports +import argparse # For parsing command-line arguments +import sys # For accessing command-line arguments via sys.argv + +import nidcpower # NI-DCPower instrument driver + + +def example(resource_name, options, voltage_level_1, voltage_level_2, + voltage_level_range, current_limit, current_limit_range, + source_delay): + """Core measurement logic — sources two voltage levels sequentially and returns both measurements. + + Args: + resource_name (str) : NI-MAX resource name, eg: "PXI1Slot1" + options (str or dict) : Driver options, eg: "" for real HW or simulate dict for simulation + voltage_level_1 (float) : First voltage level to source (V) — must be <= voltage_level_range + voltage_level_2 (float) : Second voltage level to source (V) — must be <= voltage_level_range + voltage_level_range (float) : Voltage range — must be >= both voltage levels (V) + current_limit (float) : Current limit (A) — must be <= current_limit_range + current_limit_range (float) : Current range — must be >= current_limit (A) + source_delay (float) : Delay before Source Complete Event fires(s) + """ + # 'with' block ensures session.abort() + session.close() are called automatically on exit. + # channels=0 targets channel 0; reset=True clears any previous session state. + with nidcpower.Session(resource_name=resource_name, reset=True, channels=0, options=options) as session: + + # Configure source mode and output function. + # SINGLE_POINT: sources one value and holds; voltage_level can be changed mid-session. + # measure_when = AUTOMATICALLY_AFTER_SOURCE_COMPLETE: required for fetch_multiple(). + session.source_mode = nidcpower.SourceMode.SINGLE_POINT + session.output_function = nidcpower.OutputFunction.DC_VOLTAGE + session.voltage_level = voltage_level_1 + session.voltage_level_range = voltage_level_range + session.current_limit = current_limit + session.current_limit_range = current_limit_range + session.source_delay = source_delay + session.measure_when = nidcpower.MeasureWhen.AUTOMATICALLY_AFTER_SOURCE_COMPLETE + + # Commit sends all settings to hardware before initiate. + session.commit() + + # Initiate output, fetch at voltage_level_1, change to voltage_level_2, fetch again. + # timeout=1.0 s — adjust if source_delay is longer than 1 s. + with session.initiate(): + measurements1 = session.fetch_multiple(count=1, timeout=1.0) + session.voltage_level = voltage_level_2 + measurements2 = session.fetch_multiple(count=1, timeout=1.0) + + print(f'Measurements 1: \n- Voltage: {measurements1[0][0]:f} V' + f'\n- Current: {measurements1[0][1]:f} A' + f'\n- In Compliance: {measurements1[0][2]}') + print(f'Measurements 2: \n- Voltage: {measurements2[0][0]:f} V' + f'\n- Current: {measurements2[0][1]:f} A' + f'\n- In Compliance: {measurements2[0][2]}') + + return measurements1, measurements2 + + +def _main(argsv): + """Parses command-line arguments and calls example() with the parsed values.""" + parser = argparse.ArgumentParser( + description='Hardware-timed single point: source two voltage levels and measure.', + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + parser.add_argument('-n', '--resource-name', default='PXI1Slot1', help='Resource name of NI SMU') + parser.add_argument('-vl1', '--voltage-level-1', default=2.0, type=float, help='First voltage level (V)') + parser.add_argument('-vl2', '--voltage-level-2', default=4.0, type=float, help='Second voltage level (V)') + parser.add_argument('-vr', '--voltage-level-range', default=10.0, type=float, help='Voltage level range — must be >= both voltage levels (V)') + parser.add_argument('-cl', '--current-limit', default=0.01, type=float, help='Current limit (A)') + parser.add_argument('-clr', '--current-limit-range', default=0.01, type=float, help='Current limit range — must be >= current-limit (A)') + parser.add_argument('-sd', '--source-delay', default=0.05, type=float, help='Source delay in seconds') + parser.add_argument('-op', '--option-string', default='', type=str, help='Driver option string, eg: "Simulate=1, DriverSetup=Model:4130; BoardType:PXIe"') + args = parser.parse_args(argsv) + example( + resource_name=args.resource_name, + options=args.option_string, + voltage_level_1=args.voltage_level_1, + voltage_level_2=args.voltage_level_2, + voltage_level_range=args.voltage_level_range, + current_limit=args.current_limit, + current_limit_range=args.current_limit_range, + source_delay=args.source_delay, + ) + + +def main(): + """Entry point — passes real CLI args to _main().""" + _main(sys.argv[1:]) + + +def test_example(): + """Simulated hardware test — runs example() with a virtual PXIe-4139 (no real HW needed).""" + options = {'simulate': True, 'driver_setup': {'Model': '4139', 'BoardType': 'PXIe'}} + example('PXI1Slot1', options, 2.0, 4.0, 10.0, 0.01, 0.01, 0.05) + + +def test_main(): + """Simulated CLI test — runs _main() with simulate option string.""" + cmd_line = ['--option-string', 'Simulate=1, DriverSetup=Model:4139; BoardType:PXIe'] + _main(cmd_line) + + +# ------------------------------------------------------------ +# Script execution starts here +# ------------------------------------------------------------ +if __name__ == '__main__': + main() diff --git a/src/nidmm/examples/nidmm_triggered_fetch_waveform.py b/src/nidmm/examples/nidmm_triggered_fetch_waveform.py new file mode 100644 index 0000000000..b5e89b0f15 --- /dev/null +++ b/src/nidmm/examples/nidmm_triggered_fetch_waveform.py @@ -0,0 +1,263 @@ +#!/usr/bin/env python3 +"""NI-DMM Triggered Fetch Waveform. + +This example demonstrates how to take a waveform voltage measurement on two +NI-DMMs synchronized via PXI_TRIG0. + +Since DMMs are incapable of sourcing a trigger by themselves, an NI-DCPower +SMU is used to route its SourceCompleteEvent to PXI_TRIG0. Both DMMs wait +on this trigger line before starting their waveform acquisition. + +The SMU is configured in Sequence source mode with a single voltage step. +When the SMU completes sourcing, it fires the trigger that starts both DMMs. + +Note: SMU and DMMs must be in the same PXI chassis to share PXI_TRIG0. Also, +preferably on the same bus of the PXI chassis, to avoid any issues with timing +and synchronization. + +The example uses the default resource names and measurement parameters. +Modify these values as needed for your measurement setup. + +HOW TO RUN: +----------- +i. From terminal (with default values): + python nidmm_triggered_fetch_waveform.py + +ii. From terminal (with custom values): + python nidmm_triggered_fetch_waveform.py \ + -srn "PXI1Slot1" -d1rn "PXI1Slot2" -d2rn "PXI1Slot3" \ + -vl 2.0 -cl 0.01 -mrl 100 -at 0.1 -dr 10 -drt 1e6 -dwp 50 + +iii. To simulate without hardware: + PowerShell: python nidmm_triggered_fetch_waveform.py \ + -sop 'Simulate=1, DriverSetup=Model:4139; BoardType:PXIe' \ + -dop 'Simulate=1, DriverSetup=Model:4081' + cmd.exe: python nidmm_triggered_fetch_waveform.py \ + -sop "Simulate=1, DriverSetup=Model:4139; BoardType:PXIe" \ + -dop "Simulate=1, DriverSetup=Model:4081" + +""" + +# Module imports +import argparse # For parsing command-line arguments +import sys # For accessing command-line arguments via sys.argv + +import nidcpower # NI-DCPower instrument driver (SMU trigger source) + +import nidmm # NI-DMM instrument driver + + +def example( + smu_resource_name, dmm1_resource_name, dmm2_resource_name, + smu_options, dmm_options, + voltage_level, current_limit, measure_record_length, aperture_time, + dmm_range, dmm_rate, dmm_waveform_points +): + """Perform a triggered waveform voltage measurement on two NI-DMMs via PXI_TRIG0. + + Synchronized via PXI_TRIG0 sourced by an NI-DCPower SMU SourceCompleteEvent. + + Args: + smu_resource_name (str): + NI-DCPower device identifier for the SMU (eg: "PXI1Slot1") + + dmm1_resource_name (str): + NI-DMM device identifier for DMM 1 (eg: "PXI1Slot2") + + dmm2_resource_name (str): + NI-DMM device identifier for DMM 2 (eg: "PXI1Slot3") + + smu_options (str or dict): + SMU driver options, eg: "" for real HW or simulate string for simulation + + dmm_options (str or dict): + DMM driver options, eg: "" for real HW or simulate string for simulation + + voltage_level (float): + SMU output voltage level (V) + eg: 2.0 → 2 V + + current_limit (float): + SMU current limit (A) + eg: 0.01 → 10 mA + + measure_record_length (int): + Number of measurement samples in the SMU measure record + eg: 100 → 100 samples + + aperture_time (float): + SMU aperture time per sample (s) + eg: 0.1 → 100 ms + + dmm_range (float): + DMM voltage measurement range (V) + eg: 10 → ±10 V range + + dmm_rate (float): + DMM waveform acquisition rate (S/s) + eg: 1e6 → 1 MS/s + + dmm_waveform_points (int): + Number of waveform points per DMM acquisition + eg: 50 → 50 points per acquisition + + Returns: + None — results are printed to console + """ + + # -> Initialize SMU and DMM Sessions + # - Opens communication with all three instruments + # - 'with' ensures automatic cleanup of session resources + with ( + nidcpower.Session( + resource_name=smu_resource_name, + channels=None, + reset=False, + options=smu_options, + independent_channels=True, + ) as smu_session, + nidmm.Session( + resource_name=dmm1_resource_name, + id_query=False, + reset_device=False, + options=dmm_options, + ) as dmm1_session, + nidmm.Session( + resource_name=dmm2_resource_name, + id_query=False, + reset_device=False, + options=dmm_options, + ) as dmm2_session, + ): + + # -> Configure SMU Channel Settings + # - source_mode → SEQUENCE (single-point sequence fires SourceCompleteEvent) + # - output_function → DC_VOLTAGE + # - Single voltage step; source_delays=[0.0] — no delay before sourcing + smu_session.source_mode = nidcpower.SourceMode.SEQUENCE + smu_session.output_function = nidcpower.OutputFunction.DC_VOLTAGE + smu_session.voltage_level_autorange = True + smu_session.current_limit_autorange = True + smu_session.current_limit = current_limit + smu_session.set_sequence(values=[voltage_level], source_delays=[0.0]) + + smu_session.measure_record_length = measure_record_length + smu_session.aperture_time = aperture_time + + # -> Configure SMU Trigger Settings + # - source_trigger_type → NONE (SMU advances without waiting for an external trigger) + # - Route SourceCompleteEvent to PXI_TRIG0 to synchronize both DMMs + smu_session.source_trigger_type = nidcpower.TriggerType.NONE + smu_session.source_complete_event_output_terminal = f"/{smu_resource_name}/PXI_Trig0" + + # -> Configure DMM Measurement Settings. + # - WAVEFORM_VOLTAGE acquisition mode on both DMMs + # - Both DMMs wait on PXI_TRIG0 with zero trigger delay before acquiring their waveform + for dmm_session in [dmm1_session, dmm2_session]: + dmm_session.configure_waveform_acquisition( + measurement_function=nidmm.Function.WAVEFORM_VOLTAGE, + range=dmm_range, + rate=dmm_rate, + waveform_points=dmm_waveform_points, + ) + dmm_session.configure_trigger( + trigger_source=nidmm.TriggerSource.PXI_TRIG0, + trigger_delay=0.0, # no delay after trigger before starting acquisition + ) + + # -> Initiate and Acquire + # - DMMs initiate first (waiting for PXI_TRIG0 from the SMU) + # - SMU initiates last and fires SourceCompleteEvent to PXI_TRIG0, + # when it completes sourcing the voltage step. + for dmm_session in [dmm1_session, dmm2_session]: + dmm_session.initiate() + + # Commit SMU settings (ensures trigger routing is applied before initiate) + smu_session.commit() + + smu_session.initiate() + + # -> Fetch and Print Results + # - fetch waveform from both DMMs based on the number of points specified in dmm_waveform_points + # - print DMM1 and DMM2 measurements to console. + dmm1_measurements = dmm1_session.fetch_waveform(dmm_waveform_points) + dmm2_measurements = dmm2_session.fetch_waveform(dmm_waveform_points) + + print("DMM1: ", dmm1_measurements, + "\n\nDMM2: ", dmm2_measurements) + + +def _main(argsv): + """Parses command-line arguments and calls example() with the parsed values.""" + parser = argparse.ArgumentParser( + description='Triggered waveform fetch: synchronize two DMMs via PXI_TRIG0 from an SMU SourceCompleteEvent.', + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + parser.add_argument('-srn', '--smu-resource-name', default='PXI1Slot1', help='SMU resource name') + parser.add_argument('-d1rn', '--dmm1-resource-name', default='PXI1Slot2', help='DMM 1 resource name') + parser.add_argument('-d2rn', '--dmm2-resource-name', default='PXI1Slot3', help='DMM 2 resource name') + parser.add_argument('-vl', '--voltage-level', default=2.0, type=float, help='SMU output voltage level (V)') + parser.add_argument('-cl', '--current-limit', default=0.01, type=float, help='SMU current limit (A)') + parser.add_argument('-mrl', '--measure-record-length', default=100, type=int, help='SMU measure record length (samples)') + parser.add_argument('-at', '--aperture-time', default=0.1, type=float, help='SMU aperture time per sample (s)') + parser.add_argument('-dr', '--dmm-range', default=10.0, type=float, help='DMM voltage range (V)') + parser.add_argument('-drt', '--dmm-rate', default=1e6, type=float, help='DMM waveform rate (S/s)') + parser.add_argument('-dwp', '--dmm-waveform-points', default=50, type=int, help='DMM waveform points per acquisition') + parser.add_argument('-sop', '--smu-option-string', default='', type=str, help='SMU driver option string, eg: "Simulate=1, DriverSetup=Model:4139; BoardType:PXIe"') + parser.add_argument('-dop', '--dmm-option-string', default='', type=str, help='DMM driver option string, eg: "Simulate=1, DriverSetup=Model:4081"') + args = parser.parse_args(argsv) + example( + smu_resource_name=args.smu_resource_name, + dmm1_resource_name=args.dmm1_resource_name, + dmm2_resource_name=args.dmm2_resource_name, + smu_options=args.smu_option_string, + dmm_options=args.dmm_option_string, + voltage_level=args.voltage_level, + current_limit=args.current_limit, + measure_record_length=args.measure_record_length, + aperture_time=args.aperture_time, + dmm_range=args.dmm_range, + dmm_rate=args.dmm_rate, + dmm_waveform_points=args.dmm_waveform_points, + ) + + +def main(): + """Entry point — passes real CLI args to _main().""" + _main(sys.argv[1:]) + + +def test_example(): + """Simulated hardware test — runs example() with virtual NI-4139 SMU and NI-4080 DMMs (no real HW needed).""" + smu_options = {'simulate': True, 'driver_setup': {'Model': '4139', 'BoardType': 'PXIe'}} + dmm_options = {'simulate': True, 'driver_setup': {'Model': '4081'}} + example( + smu_resource_name='PXI1Slot1', + dmm1_resource_name='PXI1Slot2', + dmm2_resource_name='PXI1Slot3', + smu_options=smu_options, + dmm_options=dmm_options, + voltage_level=2.0, + current_limit=0.01, + measure_record_length=100, + aperture_time=0.1, + dmm_range=10.0, + dmm_rate=1e6, + dmm_waveform_points=50, + ) + + +def test_main(): + """Simulated CLI test — runs _main() with simulate option strings.""" + cmd_line = [ + '--smu-option-string', 'Simulate=1, DriverSetup=Model:4139; BoardType:PXIe', + '--dmm-option-string', 'Simulate=1, DriverSetup=Model:4081', + ] + _main(cmd_line) + + +# ------------------------------------------------------------ +# Script execution starts here +# ------------------------------------------------------------ +if __name__ == '__main__': + main() diff --git a/src/niswitch/examples/niswitch_software_scanning.py b/src/niswitch/examples/niswitch_software_scanning.py new file mode 100644 index 0000000000..c8dd1ba9e1 --- /dev/null +++ b/src/niswitch/examples/niswitch_software_scanning.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python3 +"""NI-Switch Software Scanning. + +This example demonstrates how to scan a series of channels on an NI-SWITCH +module using software scanning. The session is configured with a scan list, +a trigger input source, and continuous scan mode. A software trigger is then +sent to advance through the scan sequence. + +Note : This example supports only single channel scanning, for example, +"ch0->com0;". Multi-channel scanning requires additional configuration +and is not covered in this example. + +The example uses the default resource name and scan parameters. +Modify these values as needed for your measurement setup. + +HOW TO RUN: +----------- +i. From terminal (with default values): + python niswitch_software_scanning.py + +ii. From terminal (with custom values): + python niswitch_software_scanning.py \ + -n "PXI2568" -tp "2568/31-SPST" -sl "ch0->com0;" + +iii. To simulate without hardware: + PowerShell: python niswitch_software_scanning.py -sim + cmd.exe: python niswitch_software_scanning.py -sim + +""" + +# Module imports +import argparse # For parsing command-line arguments +import sys # For accessing command-line arguments via sys.argv + +import niswitch # NI-SWITCH instrument driver + + +def example( + resource_name, topology, scan_list, continuous_scan, simulate, reset_device +): + """Perform software scanning on an NI-SWITCH module. + + Args: + resource_name (str): + NI-SWITCH device identifier + eg: "PXI2568" + + topology (str): + Switch topology string + eg: "2568/31-SPST" + + scan_list (str): + Semicolon-delimited list of channel connections to scan + eg: "ch0->com0;" -> close relay 0 (ch0 to com0) + "ch1->com1;" -> close relay 1 (ch1 to com1) + "ch2->com2;" -> close relay 2 (ch2 to com2) + + continuous_scan (bool): + If True, the scan loops continuously until aborted + If False, the scan completes a single pass and stops + + simulate (bool): + If True, the session runs in simulation mode (no real hardware needed) + + reset_device (bool): + If True, resets the device at session open + + Returns: + None — result is printed to console + """ + # trigger_input is set to SOFTWARE_TRIG, which means the scan advances + # on each call to send_software_trigger() + trig = niswitch.TriggerInput.SOFTWARE_TRIG + + # -> Open NI-SWITCH Session + # - Opens communication with the switch module using the specified topology + # - 'with' ensures automatic cleanup of session resources + with niswitch.Session( + resource_name=resource_name, + topology=topology, + simulate=simulate, + reset_device=reset_device, + ) as session: + + # -> Configure Scan Settings + # - scan_list → defines the channel connections to scan through + # - trigger_input → SOFTWARE_TRIG: scan advances on each send_software_trigger() call + # - continuous_scan → controls whether the scan loops or runs once + session.scan_list = scan_list + session.trigger_input = trig + session.continuous_scan = continuous_scan + + # -> Initiate Scan + # - Arms the switch module and waits for the first trigger + session.initiate() + + # -> Send Software Trigger + # - Advances the scan to the next step in the scan list + session.send_software_trigger() + + # - print confirmation message to console + print(f"Software trigger sent. Scan '{scan_list}' initiated on '{resource_name}'.") + + +def _main(argsv): + """Parses command-line arguments and calls example() with the parsed values.""" + parser = argparse.ArgumentParser( + description='NI-SWITCH Software Scanning: scan a series of channels using a configurable trigger source.', + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + parser.add_argument('-n', '--resource-name', default='PXI2568', help='NI-SWITCH device resource name') + parser.add_argument('-tp', '--topology', default='2568/31-SPST', help='Switch topology string') + parser.add_argument('-sl', '--scan-list', default='ch0->com0;', help='Scan list of channel connections (eg: "ch0->com0;")') + parser.add_argument('-cs', '--continuous-scan', action='store_true', default=False, help='Enable continuous scan (loops until aborted; default: single pass)') + parser.add_argument('-sim', '--simulate', action='store_true', default=False, help='Run in simulation mode (no hardware required)') + parser.add_argument('-rst', '--reset-device', action='store_true', default=False, help='Reset device at session open') + args = parser.parse_args(argsv) + example( + resource_name=args.resource_name, + topology=args.topology, + scan_list=args.scan_list, + continuous_scan=args.continuous_scan, + simulate=args.simulate, + reset_device=args.reset_device, + ) + + +def main(): + """Entry point — passes real CLI args to _main().""" + _main(sys.argv[1:]) + + +def test_example(): + """Simulated hardware test — runs example() with virtual NI-2568 switch (no real HW needed).""" + example( + resource_name='PXI2568', + topology='2568/31-SPST', + scan_list='ch0->com0;', + continuous_scan=True, + simulate=True, + reset_device=False, + ) + + +def test_main(): + """Simulated CLI test — runs _main() with simulate flag.""" + cmd_line = ['--simulate', '--continuous-scan'] + _main(cmd_line) + + +# ------------------------------------------------------------ +# Script execution starts here +# ------------------------------------------------------------ +if __name__ == '__main__': + main() From ecda1b29d6af5168e422e1063ada90e3f39badbf Mon Sep 17 00:00:00 2001 From: bkumarng Date: Tue, 11 Aug 2026 19:19:31 +0530 Subject: [PATCH 2/3] updated CHANGELOG.md updated CHANGELOG.md to include additional examples added in nidcpower, nidmm, niswitch in "unreleased section. --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2d03a32cfe..108835571c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -52,6 +52,7 @@ #### [nidcpower] Unreleased - Added + -`nidcpower_hardware_timed_single_point.py` example - Changed - Removed @@ -795,6 +796,7 @@ #### [nidmm] Unreleased - Added + -`nidmm_triggered_fetch_waveform.py` example - Changed - Removed @@ -2483,6 +2485,7 @@ #### [niswitch] Unreleased - Added + -`niswitch_software_scanning.py` example - Changed - Removed From 7a997bcd7752c45845eb835bd406006b1e14dd0c Mon Sep 17 00:00:00 2001 From: bkumarng-NI Date: Thu, 13 Aug 2026 09:41:55 +0000 Subject: [PATCH 3/3] Regenerate example documentation of NI-DCPower, NI-DMM, NI-Switch --- docs/nidcpower/examples.rst | 9 +++++++++ docs/nidmm/examples.rst | 9 +++++++++ docs/niswitch/examples.rst | 9 +++++++++ 3 files changed, 27 insertions(+) diff --git a/docs/nidcpower/examples.rst b/docs/nidcpower/examples.rst index 7e372bb610..47b8536d88 100644 --- a/docs/nidcpower/examples.rst +++ b/docs/nidcpower/examples.rst @@ -21,6 +21,15 @@ nidcpower_constant_resistance_and_constant_power.py :encoding: utf8 :caption: `(nidcpower_constant_resistance_and_constant_power.py) `_ +nidcpower_hardware_timed_single_point.py +---------------------------------------- + +.. literalinclude:: ../../src/nidcpower/examples/nidcpower_hardware_timed_single_point.py + :language: python + :linenos: + :encoding: utf8 + :caption: `(nidcpower_hardware_timed_single_point.py) `_ + nidcpower_lcr_source_ac_voltage.py ---------------------------------- diff --git a/docs/nidmm/examples.rst b/docs/nidmm/examples.rst index 972a1dbc9e..0a00c1f5e6 100644 --- a/docs/nidmm/examples.rst +++ b/docs/nidmm/examples.rst @@ -30,3 +30,12 @@ nidmm_multi_point_measurement.py :encoding: utf8 :caption: `(nidmm_multi_point_measurement.py) `_ +nidmm_triggered_fetch_waveform.py +--------------------------------- + +.. literalinclude:: ../../src/nidmm/examples/nidmm_triggered_fetch_waveform.py + :language: python + :linenos: + :encoding: utf8 + :caption: `(nidmm_triggered_fetch_waveform.py) `_ + diff --git a/docs/niswitch/examples.rst b/docs/niswitch/examples.rst index f2c8dfef12..4ab7c54dae 100644 --- a/docs/niswitch/examples.rst +++ b/docs/niswitch/examples.rst @@ -30,3 +30,12 @@ niswitch_relay_control.py :encoding: utf8 :caption: `(niswitch_relay_control.py) `_ +niswitch_software_scanning.py +----------------------------- + +.. literalinclude:: ../../src/niswitch/examples/niswitch_software_scanning.py + :language: python + :linenos: + :encoding: utf8 + :caption: `(niswitch_software_scanning.py) `_ +