Using 2 NI Cards with 2 analog outputs each instead of one Card with 4 for scanning

[fabi122]

Hi guys,

I'm currently setting up qudi (scanning setup) to work with a NI USB-6212 (BNC) and NI-USB 6346 card, each providing only two analog output channels (ao0 and ao1). I want to preserve the full functionality and all capabilities that are available when using just a single NI device with 4 analog outputs. So all of qudi’s scanning, motion, and data acquisition features should remain intact.

The main challenge I think is that qudi and its modules, such as the scanning_probe_logic, ni_scanning_probe_interfuse, ni_x_series_finite_sampling_io, and ni_x_series_analog_output modules, were originally designed with the expectation of a single device providing all required channels. The configuration files and internal logic currently assume a single device name, and attempts to simply provide multiple device names in the configuration have led to errors indicating that channels could not be recognized or that device names were invalid and countless more.

I’ve had the idea of creating a virtual NI device that aggregates both physical devices into one logical device, but as far as I know, NI MAX or DAQmx does not offer a straightforward way to virtually combine two separate devices into a single unified device with a continuous set of AO channels.

Before making deep modifications to the qudi codebase, I want to be sure there is no simpler or more elegant solution. Perhaps there is a known NI MAX or DAQmx feature that allows device aliasing or channel remapping in a way that is transparent to qudi and works for my specific purpose.

I'm rather new to qudi so maybe (I hope) I am missing something and there is an easy way.

Thank you in advance for your help.

[prithviulm]

Hi! Thanks for your interest in Qudi. This is a use-case that is already supported. I think you may have a mistake in your config file. Can you share that here?

Here's a dummy config for a confocal with two arms i.e. one NI card controls one xyz stage and another NI card controls a 4f scanner. Below this dummy is also a real config file that should work for the same. It's important to note that the device_name option for the NI cards in the real config file must be distinct. They should follow the naming that NIMax reports.

Having said that, there are still a few bugs to iron out. You may experience crashes/ errors if you run both the counters and both the confocal scanners simultaneously. We welcome PRs to address these.

Let us know if this works for you!

gui:
    counter_normal:
        module.Class: 'time_series.time_series_gui.TimeSeriesGui'
        options:
            use_antialias: True  # optional, set to False if you encounter performance issues
        connect:
            _time_series_logic_con: time_series_reader_logic_normal

    counter_4f:
        module.Class: 'time_series.time_series_gui.TimeSeriesGui'
        options:
            use_antialias: True  # optional, set to False if you encounter performance issues
        connect:
            _time_series_logic_con: time_series_reader_logic_4f

    scanner_normal:
        module.Class: 'scanning.scannergui.ScannerGui'
        options:  
            image_axes_padding: 0.02
            default_position_unit_prefix: 'u'  # optional, use unit prefix characters, e.g. 'u' or 'n'
            optimizer_plot_dimensions: [2,1]
        connect:
            scanning_logic: scanning_probe_logic_normal
            data_logic: scanning_data_logic_normal
            optimize_logic: scanning_optimize_logic_normal

    scanner_4f:
        module.Class: 'scanning.scannergui.ScannerGui'
        options:  
            image_axes_padding: 0.02
            default_position_unit_prefix: 'u'  # optional, use unit prefix characters, e.g. 'u' or 'n'
            optimizer_plot_dimensions: [2,1]
        connect:
            scanning_logic: scanning_probe_logic_4f
            data_logic: scanning_data_logic_4f
            optimize_logic: scanning_optimize_logic_4f

logic:
    time_series_reader_logic_normal:
        module.Class: 'time_series_reader_logic.TimeSeriesReaderLogic'
        options:
            max_frame_rate: 20  # optional (10Hz by default)
            calc_digital_freq: True  # optional (True by default)
        connect:
            streamer: ni_instreamer_normal

    time_series_reader_logic_4f:
        module.Class: 'time_series_reader_logic.TimeSeriesReaderLogic'
        options:
            max_frame_rate: 20  # optional (10Hz by default)
            calc_digital_freq: True  # optional (True by default)
        connect:
            streamer: ni_instreamer_4f

    scanning_probe_logic_normal:
        module.Class: 'scanning_probe_logic.ScanningProbeLogic'
        options:  
            max_history_length: 20
            max_scan_update_interval: 2
            position_update_interval: 1
        connect:
            scanner: ni_scanner_normal

    scanning_probe_logic_4f:
        module.Class: 'scanning_probe_logic.ScanningProbeLogic'
        options:  
            max_history_length: 20
            max_scan_update_interval: 2
            position_update_interval: 1
        connect:
            scanner: ni_scanner_4f

    scanning_data_logic_normal:
        module.Class: 'scanning_data_logic.ScanningDataLogic'
        options:  
            max_history_length: 20
        connect:
            scan_logic: scanning_probe_logic_normal

    scanning_data_logic_4f:
        module.Class: 'scanning_data_logic.ScanningDataLogic'
        options:  
            max_history_length: 20
        connect:
            scan_logic: scanning_probe_logic_4f

    scanning_optimize_logic_normal:
        module.Class: 'scanning_optimize_logic.ScanningOptimizeLogic'
        connect:
            scan_logic: scanning_probe_logic_normal

    scanning_optimize_logic_4f:
        module.Class: 'scanning_optimize_logic.ScanningOptimizeLogic'
        connect:
            scan_logic: scanning_probe_logic_4f

hardware:
    ni_instreamer_normal:
        module.Class: 'dummy.data_instream_dummy.InStreamDummy'
        options:
            device_name: 'Dev1'
            channel_names:  # optional
              - 'PFI8'
            channel_signals:  # Can be 'counts' or 'sine'
                - 'counts'
            channel_units:
                - 'Hz'
            adc_voltage_range: [0, 10]  # optional
            max_channel_samples_buffer: 10000000  # optional
            read_write_timeout: 10  # optional

    ni_instreamer_4f:
        module.Class: 'dummy.data_instream_dummy.InStreamDummy'
        options:
            device_name: 'Dev2'
            channel_names:  # optional
              - 'PFI8'
            channel_signals:  # Can be 'counts' or 'sine'
                - 'counts'
            channel_units:
                - 'Hz'
            adc_voltage_range: [0, 10]  # optional
            max_channel_samples_buffer: 10000000  # optional
            read_write_timeout: 10  # optional

    ni_scanner_normal:
        module.Class: 'dummy.scanning_probe_dummy.ScanningProbeDummy'
        options:
            position_ranges:
                'x': [0, 200e-6]
                'y': [0, 200e-6]
                'z': [-100e-6, 100e-6]
            frequency_ranges:
                'x': [0, 10000]
                'y': [0, 10000]
                'z': [0, 5000]
            resolution_ranges:
                'x': [2, 2147483647]
                'y': [2, 2147483647]
                'z': [2, 2147483647]
            position_accuracy:
                'x': 10e-9
                'y': 10e-9
                'z': 50e-9
            spot_density: 1e11

    ni_scanner_4f:
        module.Class: 'dummy.scanning_probe_dummy.ScanningProbeDummy'
        options:
            position_ranges:
                'x': [0, 200e-6]
                'y': [0, 200e-6]
                'z': [-100e-6, 100e-6]
            frequency_ranges:
                'x': [0, 10000]
                'y': [0, 10000]
                'z': [0, 5000]
            resolution_ranges:
                'x': [2, 2147483647]
                'y': [2, 2147483647]
                'z': [2, 2147483647]
            position_accuracy:
                'x': 10e-9
                'y': 10e-9
                'z': 50e-9
            spot_density: 1e11

    ni_io_normal:
        module.Class: 'dummy.finite_sampling_io_dummy.FiniteSamplingIODummy'
        options:
            sample_rate_limits: [1, 1e6]
            frame_size_limits: [1, 1e9]
            default_output_mode: 'JUMP_LIST'
            input_channel_units:
                'APD counts': 'c/s'
                'Photodiode': 'V'
            output_channel_units:
                'Frequency': 'Hz'
                'Voltage': 'V'

    ni_ao_normal:
        module.Class: 'dummy.finite_sampling_output_dummy.FiniteSamplingOutputDummy'
        options:
            sample_rate_limits: [1, 1e6]
            frame_size_limits: [1, 1e9]
            output_mode: 'JUMP_LIST'
            channel_units:
                'Frequency': 'Hz'
                'Voltage': 'V'

    ni_io_4f:
        module.Class: 'dummy.finite_sampling_io_dummy.FiniteSamplingIODummy'
        options:
            sample_rate_limits: [1, 1e6]
            frame_size_limits: [1, 1e9]
            default_output_mode: 'JUMP_LIST'
            input_channel_units:
                'APD counts': 'c/s'
                'Photodiode': 'V'
            output_channel_units:
                'Frequency': 'Hz'
                'Voltage': 'V'

    ni_ao_4f:
        module.Class: 'dummy.finite_sampling_output_dummy.FiniteSamplingOutputDummy'
        options:
            sample_rate_limits: [1, 1e6]
            frame_size_limits: [1, 1e9]
            output_mode: 'JUMP_LIST'
            channel_units:
                'Frequency': 'Hz'
                'Voltage': 'V'

Here's a real config file for actual hardware

gui:
    counter_normal:
        module.Class: 'time_series.time_series_gui.TimeSeriesGui'
        options:
            use_antialias: True  # optional, set to False if you encounter performance issues
        connect:
            _time_series_logic_con: time_series_reader_logic_normal

    counter_4f:
        module.Class: 'time_series.time_series_gui.TimeSeriesGui'
        options:
            use_antialias: True  # optional, set to False if you encounter performance issues
        connect:
            _time_series_logic_con: time_series_reader_logic_4f

    scanner_normal:
        module.Class: 'scanning.scannergui.ScannerGui'
        options:  
            image_axes_padding: 0.02
            default_position_unit_prefix: 'u'  # optional, use unit prefix characters, e.g. 'u' or 'n'
            optimizer_plot_dimensions: [2,1]
        connect:
            scanning_logic: scanning_probe_logic_normal
            data_logic: scanning_data_logic_normal
            optimize_logic: scanning_optimize_logic_normal

    scanner_4f:
        module.Class: 'scanning.scannergui.ScannerGui'
        options:  
            image_axes_padding: 0.02
            default_position_unit_prefix: 'u'  # optional, use unit prefix characters, e.g. 'u' or 'n'
            optimizer_plot_dimensions: [2,1]
        connect:
            scanning_logic: scanning_probe_logic_4f
            data_logic: scanning_data_logic_4f
            optimize_logic: scanning_optimize_logic_4f

logic:
    time_series_reader_logic_normal:
        module.Class: 'time_series_reader_logic.TimeSeriesReaderLogic'
        options:
            max_frame_rate: 20  # optional (10Hz by default)
            calc_digital_freq: True  # optional (True by default)
        connect:
            streamer: ni_instreamer_normal

    time_series_reader_logic_4f:
        module.Class: 'time_series_reader_logic.TimeSeriesReaderLogic'
        options:
            max_frame_rate: 20  # optional (10Hz by default)
            calc_digital_freq: True  # optional (True by default)
        connect:
            streamer: ni_instreamer_4f

    scanning_probe_logic_normal:
        module.Class: 'scanning_probe_logic.ScanningProbeLogic'
        options:  
            max_history_length: 20
            max_scan_update_interval: 2
            position_update_interval: 1
        connect:
            scanner: ni_scanner_normal

    scanning_probe_logic_4f:
        module.Class: 'scanning_probe_logic.ScanningProbeLogic'
        options:  
            max_history_length: 20
            max_scan_update_interval: 2
            position_update_interval: 1
        connect:
            scanner: ni_scanner_4f

    scanning_data_logic_normal:
        module.Class: 'scanning_data_logic.ScanningDataLogic'
        options:  
            max_history_length: 20
        connect:
            scan_logic: scanning_probe_logic_normal

    scanning_data_logic_4f:
        module.Class: 'scanning_data_logic.ScanningDataLogic'
        options:  
            max_history_length: 20
        connect:
            scan_logic: scanning_probe_logic_4f

    scanning_optimize_logic_normal:
        module.Class: 'scanning_optimize_logic.ScanningOptimizeLogic'
        connect:
            scan_logic: scanning_probe_logic_normal

    scanning_optimize_logic_4f:
        module.Class: 'scanning_optimize_logic.ScanningOptimizeLogic'
        connect:
            scan_logic: scanning_probe_logic_4f

hardware:
    ni_instreamer_normal:
        module.Class: 'ni_x_series.ni_x_series_in_streamer.NIXSeriesInStreamer'
        options:
            device_name: 'Dev1'
            digital_sources:  # optional
              - 'PFI8'
            adc_voltage_range: [0, 10]  # optional
            max_channel_samples_buffer: 10000000  # optional
            read_write_timeout: 10  # optional

    ni_instreamer_4f:
        module.Class: 'ni_x_series.ni_x_series_in_streamer.NIXSeriesInStreamer'
        options:
            device_name: 'Dev2'
            digital_sources:  # optional
              - 'PFI8'
            adc_voltage_range: [0, 10]  # optional
            max_channel_samples_buffer: 10000000  # optional
            read_write_timeout: 10  # optional

    ni_scanner_normal:
        module.Class: 'interfuse.ni_scanning_probe_interfuse.NiScanningProbeInterfuse'
        connect:
            scan_hardware: 'ni_io_normal'
            analog_output: 'ni_ao_normal'
        options:  
            ni_channel_mapping:
                x: 'ao0'
                y: 'ao1'
                z: 'ao2'
                APD1: 'PFI8'
            position_ranges: # in m
                x: [0, 200e-6]
                y: [0, 200e-6]
                z: [0, 200e-6]
            frequency_ranges:
                x: [1, 500]
                y: [1, 500]
                z: [1, 500]
            resolution_ranges:
                x: [1, 1000]
                y: [1, 1000]
                z: [1, 1000]
            input_channel_units:
                APD1: 'c/s'
            backwards_line_resolution: 50 # optional
            maximum_move_velocity: 400e-6 #m/s

    ni_scanner_4f:
        module.Class: 'interfuse.ni_scanning_probe_interfuse.NiScanningProbeInterfuse'
        connect:
            scan_hardware: 'ni_io_4f'
            analog_output: 'ni_ao_4f'
        options:  
            ni_channel_mapping:
                x: 'ao0'
                y: 'ao1'
                z: 'ao2'
                APD2: 'PFI8'
            position_ranges: # in m
                x: [0, 201e-6]
                y: [0, 201e-6]
                z: [0, 201e-6]
            frequency_ranges:
                x: [1, 500]
                y: [1, 500]
                z: [1, 500]
            resolution_ranges:
                x: [1, 1000]
                y: [1, 1000]
                z: [1, 1000]
            input_channel_units:
                APD2: 'c/s'
            backwards_line_resolution: 50 # optional
            maximum_move_velocity: 400e-6 #m/s
    
    ni_io_normal:
        module.Class: 'ni_x_series.ni_x_series_finite_sampling_io.NIXSeriesFiniteSamplingIO'
        options:
            device_name: 'Dev1'
            input_channel_units:  # optional
                PFI8: 'c/s'
            output_channel_units:
                'ao0': 'V'
                'ao1': 'V'
                'ao2': 'V'
            adc_voltage_ranges:
                ai0: [0, 10]  # optional
                ai1: [0, 10]  # optional
                ai2: [0, 10]  # optional
            output_voltage_ranges:
                ao0: [0, 10]
                ao1: [0, 10]
                ao2: [0, 10]
            frame_size_limits: [1, 1e9]  # optional #TODO actual HW constraint?
            output_mode: 'JUMP_LIST' #'JUMP_LIST' # optional, must be name of SamplingOutputMode
            read_write_timeout: 10  # optional

    ni_ao_normal:
        module.Class: 'ni_x_series.ni_x_series_analog_output.NIXSeriesAnalogOutput'
        options:
            device_name: 'Dev1'
            channels:
                ao0:
                    limits: [0.0, 10.0]
                    keep_value: True
                ao1:
                    limits: [0.0, 10.0]
                    keep_value: True
                ao2:
                    limits: [0.0, 10.0]
                    keep_value: True

    ni_io_4f:
        module.Class: 'ni_x_series.ni_x_series_finite_sampling_io.NIXSeriesFiniteSamplingIO'
        options:
            device_name: 'Dev2'
            input_channel_units:  # optional
                PFI8: 'c/s'
            output_channel_units:
                'ao0': 'V'
                'ao1': 'V'
                'ao2': 'V'
            adc_voltage_ranges:
                ai0: [0, 10]  # optional
                ai1: [0, 10]  # optional
                ai2: [0, 10]  # optional
            output_voltage_ranges:
                ao0: [0, 10]
                ao1: [0, 10]
                ao2: [0, 10]
            frame_size_limits: [1, 1e9]  # optional #TODO actual HW constraint?
            output_mode: 'JUMP_LIST' #'JUMP_LIST' # optional, must be name of SamplingOutputMode
            read_write_timeout: 10  # optional

    ni_ao_4f:
        module.Class: 'ni_x_series.ni_x_series_analog_output.NIXSeriesAnalogOutput'
        options:
            device_name: 'Dev2'
            channels:
                ao0:
                    limits: [0.0, 10.0]
                    keep_value: True
                ao1:
                    limits: [0.0, 10.0]
                    keep_value: True
                ao2:
                    limits: [0.0, 10.0]
                    keep_value: True

[fabi122]

Hi, thank you for the response!

The problem is that our cards each have only 2 analog outputs, named ao0 and ao1, and we have two such cards in total. That means I always run into issues when I try to configure the ni_channel_mapping, because I end up using ao0 or ao1 more than once. I need at least three channels for x, y, and z, but each device only provides two (ao0 and ao1).

If I try to emulate what you did, for example in ni_ao_normal or ni_ao_4f, I still have the same constraint: a single device with only two channels. I also tried defining something like ni_ao_normal2 for the z axis on the second device (Dev2) while handling x and y with ni_ao_normal on Dev1. However, as mentioned earlier, I run into problems with the channel mapping under ni_scanner_normal. Another issue (or maybe the critical one) is that ni_scanning_probe_interfuse seems to only accept one analog_output and one scan_hardware connector, so connecting multiple analog output modules may not be supported.

The same problems then also arise with ni_io_normal and ni_io_4f of course.

What I would really like to do is use Global Virtual Channels from NI MAX and access them in Qudi without specifying a device name, or by using something like device_name: 'Dev_V'. The issue is that I am not sure what device_name these Global Virtual Channels have in NI MAX, or how to create them using the nidaqmx package so that they have a device_name recognizable by Qudi.

So far, I haven’t figured out how to access virtual channels with Qudi. Among other uncertainties, I’m not sure what to put for device_name in that scenario. My hope is that all global virtual channels share a common device_name, which would let me reference them in my config file with something like device_name: 'Dev_V'.

Here is my current configuration file (slightly different naming) for reference which works for my setup but only considering x and y because of the issues described above:

# only xy-scan because don't know how to implement second device here yet
#
# I have NI USB-6212 (BNC) as Dev1 with analog outputs ao0 and ao1
# and NI-USB 6346 as Dev2 also with ao0 and ao1

gui:
    scanner_gui:
      module.Class: 'scanning.scannergui.ScannerGui'
      options:  
          image_axes_padding: 0.02
          default_position_unit_prefix: null  # optional, use unit prefix characters, e.g. 'u' or 'n'
          optimizer_plot_dimensions: [2,1]
      connect:
          scanning_logic: scanning_probe_logic
          data_logic: scanning_data_logic
          optimize_logic: scanning_optimize_logic


logic:
    scanning_probe_logic:
        module.Class: 'scanning_probe_logic.ScanningProbeLogic'
        options:  
            max_history_length: 20
            max_scan_update_interval: 2
            position_update_interval: 1
        connect:
            scanner: ni_scanner

    scanning_data_logic:
        module.Class: 'scanning_data_logic.ScanningDataLogic'
        options:  
            max_history_length: 20
        connect:
            scan_logic: scanning_probe_logic

    scanning_optimize_logic:
        module.Class: 'scanning_optimize_logic.ScanningOptimizeLogic'
        connect:
            scan_logic: scanning_probe_logic


hardware:
    ni_scanner:
        module.Class: 'interfuse.ni_scanning_probe_interfuse1.NiScanningProbeInterfuse' # 1 for original code from github
        # to use without tilt correction
        # module.Class: 'interfuse.ni_scanning_probe_interfuse.NiScanningProbeInterfuseBare'
        connect:
            scan_hardware: 'ni_io_xy'
            analog_output: 'ni_ao_xy'
        options:
            ni_channel_mapping:
                x: 'ao0'
                y: 'ao1'
                #z: 'ao0'
                APD1: 'PFI0'
                APD2: 'PFI1'
                #AI0: 'ai0'
            position_ranges: # in m
                x: [-100e-6, 100e-6]
                y: [0, 200e-6]
                #z: [-100e-6, 100e-6]
            frequency_ranges: #Aka values written/retrieved per second; Check with connected HW for sensible constraints.
                x: [1, 5000]
                y: [1, 5000]
                #z: [1, 1000]
            resolution_ranges:
                x: [1, 10000]
                y: [1, 10000]
                #z: [2, 1000]
            input_channel_units:
                APD1: 'c/s'
                APD2: 'c/s'
                #AI0: 'V'
            move_velocity: 400e-6 #m/s; This speed is used for scanner movements and avoids jumps from position to position.
            default_backward_resolution: 50
    
    ni_io_xy:
        module.Class: 'ni_x_series.ni_x_series_finite_sampling_io.NIXSeriesFiniteSamplingIO'
        options:
            device_name: 'Dev2'
            input_channel_units:
                PFI0: 'c/s'
                PFI1: 'c/s'
                #ai0: 'V'
                #ai1: 'V'
            output_channel_units: # Specify used output channels
                'ao0': 'V'
                'ao1': 'V'
            adc_voltage_ranges:
                #ai0: [-10, 10]  # optional
                #ai1: [-10, 10]  # optional
            output_voltage_ranges:
                ao0: [-1.5, 1.5]
                ao1: [-1.5, 1.5]
            frame_size_limits: [1, 1e9]  # optional #TODO actual HW constraint?
            default_output_mode: 'JUMP_LIST' # optional, must be name of SamplingOutputMode
            read_write_timeout: 10  # optional
            sample_clock_output: '/Dev1/PFI11' # optional: routing of sample clock to a physical connection
    
    ni_ao_xy:
        module.Class: 'ni_x_series.ni_x_series_analog_output1.NIXSeriesAnalogOutput' # 1 for original code from github
        options:
            device_name: 'Dev1'
            channels:
                ao0:
                    limits: [-10.0, 10.0]
                    keep_value: True
                ao1:
                    limits: [-10.0, 10.0]
                    keep_value: True

I hope I am still missing an easy solution.
Also if there are insights on how to properly configure global virtual channels with a suitable device name for them such that they are usable in Qudi (or something similar to that), I would greatly appreciate the help!

[timoML]

With our current solution, you need to configure two different ni_scanners (fullfilling the ScanningProbeInterface): In @prithviulm's example that's ni_scanner_normal, ni_scanner_4f. The channel mapping is referring to the physical output channels on these devices.

I think what qudi can't do right now, is using two ni_scanners in one scanning_probe_logic, and thus control two scanners from the same GUI.
To realize this, I see two options:

1. NI virtual channels. (@LukePiewalker, @Neverhorst do you have experience with these?)
2. You could write an Qudi Interfuse that's fusing two ScanningProbeInterface devices (like ni_scanner_normal, ni_scanner_4f) effectively into one. This seems possible, but for scans over two different physical hardwares, you'll need to think about how to set up the scanning position arrays properly (and synchronize with the acquisition).