def __init__(self, board_num: int, dev_handle: ul.DaqDeviceDescriptor, sampling: params.Sampling): self.dev_info = DaqDeviceInfo(board_num) self.sampling = sampling self.ao_range = self.dev_info.get_ao_info().supported_ranges[0] self.channels = [] self.num_ao_channels: int = self.dev_info.get_ao_info().num_chans self.points_per_channel: int = 1024 self.buffer_size = self.num_ao_channels * self.points_per_channel dev.Device.__init__(self, self.board_num, self.dev_info) if MCCDAQ.__registered_board_nums.index(board_num) == -1: ul.ignore_instacal() ul.create_daq_device(board_num, dev_handle) MCCDAQ.__registered_board_nums.append(board_num) MCCDAQ.__memhandles.append(ul.win_buf_alloc(self.buffer_size)) self.memhandle = MCCDAQ.__memhandles.index(self.board_num) if not self.memhandle: raise Exception('MCCDAQChannel: Failed to allocate memory') self.cdata = cast(self.memhandle, POINTER(c_ushort)) for channel_idx in range(self.num_ao_channels): self.channels.append(MCCDAQChannel(self, channel_idx))
def __init__(self, master=None): super(CInScan02, self).__init__(master) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 self.chan_num = -1 try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) counter_info = self.device_info.get_ctr_info() chan = next( (channel for channel in counter_info.chan_info if channel.type == CounterChannelType.CTRSCAN), None) if chan: self.chan_num = chan.channel_num if self.chan_num != -1: self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def __init__(self, master=None): super(ULAI15, self).__init__(master) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) self.ai_info = self.device_info.get_ai_info() example_supported = (self.ai_info.is_supported and self.ai_info.supports_scan and ScanOptions.SCALEDATA in self.ai_info.supported_scan_options) if example_supported: self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_digital_io: raise Exception('Error: The DAQ device does not support ' 'digital I/O') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') dio_info = daq_dev_info.get_dio_info() # Find the first port that supports input, defaulting to None # if one is not found. port = next( (port for port in dio_info.port_info if port.supports_output), None) if not port: raise Exception('Error: The DAQ device does not support ' 'digital output') # If the port is configurable, configure it for output. if port.is_port_configurable: ul.d_config_port(board_num, port.type, DigitalIODirection.OUT) port_value = 0xFF print('Setting', port.type.name, 'to', port_value) # Output the value to the port ul.d_out(board_num, port.type, port_value) bit_num = 0 bit_value = 0 print('Setting', port.type.name, 'bit', bit_num, 'to', bit_value) # Output the value to the bit ul.d_bit_out(board_num, port.type, bit_num, bit_value) except Exception as e: print('\n', e) finally: if use_device_detection: ul.release_daq_device(board_num)
def __init__(self, master=None): super(DaqSetTrigger01, self).__init__(master) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 self.chan_list = [] self.chan_type_list = [] self.gain_list = [] self.num_chans = 4 try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) if self.device_info.supports_daq_input: self.init_scan_channel_info() self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def __init__(self, master=None): super(TimerOutStart01, self).__init__(master) master.protocol("WM_DELETE_WINDOW", self.exit) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 self.first_chan_num = -1 self.last_chan_num = -1 try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) counter_info = self.device_info.get_ctr_info() # Find the first pulse counter first_chan = next((channel for channel in counter_info.chan_info if channel.type == CounterChannelType.CTRTMR), None) if first_chan is not None: last_chan = next( (channel for channel in reversed(counter_info.chan_info) if channel.type == CounterChannelType.CTRTMR), None) self.first_chan_num = first_chan.channel_num self.last_chan_num = last_chan.channel_num self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def __init__(self, master=None): super(ULDI03, self).__init__(master) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) dio_info = self.device_info.get_dio_info() # Find the first port that supports input, defaulting to None # if one is not found. self.port = next( (port for port in dio_info.port_info if port.supports_input_scan), None) if self.port is not None: self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def __init__(self, master=None): super(ULAI10, self).__init__(master) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 self.num_elements = 4 self.queue_loaded = False try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) self.ai_info = self.device_info.get_ai_info() if self.ai_info.is_supported: self.create_widgets() self.scan_loop() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_counters: raise Exception('Error: The DAQ device does not support counters') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') ctr_info = daq_dev_info.get_ctr_info() # Find a pulse timer channel on the board first_chan = next((channel for channel in ctr_info.chan_info if channel.type == CounterChannelType.CTRPULSE), None) if not first_chan: raise Exception('Error: The DAQ device does not support ' 'pulse timers') timer_num = first_chan.channel_num frequency = 100 duty_cycle = 0.5 # Start the pulse timer output (optional parameters omitted) actual_frequency, actual_duty_cycle, _ = ul.pulse_out_start( board_num, timer_num, frequency, duty_cycle) # Print information about the output print('Outputting', actual_frequency, 'Hz with a duty cycle of', actual_duty_cycle, 'to pulse timer channel', timer_num) # Wait for 5 seconds sleep(5) # Stop the pulse timer output ul.pulse_out_stop(board_num, timer_num) print('Timer output stopped') except Exception as e: print('\n', e) finally: if use_device_detection: ul.release_daq_device(board_num)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_counters: raise Exception('Error: The DAQ device does not support counters') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') ctr_info = daq_dev_info.get_ctr_info() # Use the first counter channel on the board (some boards start channel # numbering at 1 instead of 0, the CtrInfo class is used here to find # the first one). counter_num = ctr_info.chan_info[0].channel_num ul.c_clear(board_num, counter_num) print('Please enter CTRL + C to terminate the process\n') try: while True: try: # Read and display the data. counter_value = ul.c_in_32(board_num, counter_num) print('\r Counter ', counter_num, ':', str(counter_value).rjust(12), sep='', end='') stdout.flush() sleep(0.1) except (ValueError, NameError, SyntaxError): break except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if use_device_detection: ul.release_daq_device(board_num)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_analog_input: raise Exception('Error: The DAQ device does not support ' 'analog input') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') ai_info = daq_dev_info.get_ai_info() ai_range = ai_info.supported_ranges[0] channel = 0 # Get a value from the device if ai_info.resolution <= 16: # Use the a_in method for devices with a resolution <= 16 value = ul.a_in(board_num, channel, ai_range) # Convert the raw value to engineering units eng_units_value = ul.to_eng_units(board_num, ai_range, value) else: # Use the a_in_32 method for devices with a resolution > 16 # (optional parameter omitted) value = ul.a_in_32(board_num, channel, ai_range) # Convert the raw value to engineering units eng_units_value = ul.to_eng_units_32(board_num, ai_range, value) # Display the raw value print('Raw Value:', value) # Display the engineering value print('Engineering Value: {:.3f}'.format(eng_units_value)) except Exception as e: print('\n', e) finally: if use_device_detection: ul.release_daq_device(board_num)
def list_installed(self): installed_text = "" for board_num in range(0, self.max_board_num): try: device_info = DaqDeviceInfo(board_num) installed_text += ("Board #" + str(board_num) + " = " + device_info.product_name + "\n") except ULError: pass self.info_groupbox["text"] = "Installed Devices" self.info_text.delete(0.0, tk.END) self.info_text.insert(0.0, installed_text[:-1])
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_analog_input: raise Exception('Error: The DAQ device does not support ' 'analog input') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') ai_info = daq_dev_info.get_ai_info() if ai_info.num_temp_chans <= 0: raise Exception('Error: The DAQ device does not support ' 'temperature input') channel = 0 # Get the value from the device (optional parameters omitted) value = ul.t_in(board_num, channel, TempScale.CELSIUS) # Display the value print('Channel', channel, 'Value (deg C):', value) except Exception as e: print('\n', e) finally: if use_device_detection: ul.release_daq_device(board_num)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_analog_output: raise Exception('Error: The DAQ device does not support ' 'analog output') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') ao_info = daq_dev_info.get_ao_info() ao_range = ao_info.supported_ranges[0] channel = 0 data_value = ao_range.range_max / 2 print('Outputting', data_value, 'Volts to channel', channel) # Send the value to the device (optional parameter omitted) ul.v_out(board_num, channel, ao_range, data_value) except Exception as e: print('\n', e) finally: if use_device_detection: ul.release_daq_device(board_num)
def __init__(self, master=None): super(DaqSetSetpoints01, self).__init__(master) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 self.chan_list = [] self.chan_type_list = [] self.gain_list = [] self.num_chans = 4 self.setpoint_flags_list = [] self.setpoint_output_list = [] self.limit_a_list = [] self.limit_b_list = [] self.output_1_list = [] self.output_2_list = [] self.output_mask_1_list = [] self.output_mask_2_list = [] self.setpoint_count = 3 try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) daqi_info = self.device_info.get_daqi_info() if (self.device_info.supports_daq_input and daqi_info.supports_setpoints): self.init_scan_channel_info() self.init_setpoints() self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def update_board_info(self): info_text = "" try: # Raises exception is board_num is not valid self.device_info = DaqDeviceInfo(self.board_num) info_text += self.get_ad_info() info_text += self.get_temperature_info() info_text += self.get_da_info() info_text += self.get_digital_info() info_text += self.get_counter_info() info_text += self.get_expansion_info() # Remove the last "newline" character info_text = info_text[:-1] except ULError: info_text = ( "No board found at board number " + str(self.board_num) + ".\nRun InstaCal to add or remove boards before running this " + "program.") finally: self.info_label["text"] = info_text
def __init__(self, master): super(ULTI02, self).__init__(master) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. # BOARD NUMBER IS DEFINED IN TKINTER AT START OF TEST use_device_detection = False self.running = False # Device Detection not used in this test try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) self.ai_info = self.device_info.get_ai_info() if self.ai_info.temp_supported: self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def __init__(self, master): super(ULAI01, self).__init__(master) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 self.running = False try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) if self.device_info.supports_analog_input: self.ai_info = self.device_info.get_ai_info() self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def __init__(self, master=None): super(ULDO02, self).__init__(master) master.protocol("WM_DELETE_WINDOW", self.exit) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) dio_info = self.device_info.get_dio_info() # Find the first port that supports output, defaulting to None # if one is not found. self.port = next((port for port in dio_info.port_info if port.supports_output), None) if self.port is not None: # If the port is configurable, configure it for output if self.port.is_port_configurable: try: ul.d_config_port(self.board_num, self.port.type, DigitalIODirection.OUT) except ULError as e: show_ul_error(e) self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [317, 318] # USB-1808 = 317, USB-1808X = 318 board_num = 0 # Supported PIDs for the USB-1808 Series rate = 100 points_per_channel = 100 memhandle = None try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') scan_options = ScanOptions.FOREGROUND | ScanOptions.SCALEDATA # Create the daq_in_scan channel configuration lists chan_list = [] chan_type_list = [] gain_list = [] # Analog channels must be first in the list chan_list.append(1) chan_type_list.append(ChannelType.ANALOG_SE) gain_list.append(ULRange.BIP10VOLTS) chan_list.append(2) chan_type_list.append(ChannelType.ANALOG_DIFF) gain_list.append(ULRange.BIP10VOLTS) chan_list.append(DigitalPortType.AUXPORT) chan_type_list.append(ChannelType.DIGITAL) gain_list.append(ULRange.NOTUSED) chan_list.append(0) chan_type_list.append(ChannelType.CTR) gain_list.append(ULRange.NOTUSED) num_chans = len(chan_list) total_count = num_chans * points_per_channel # Allocate memory for the scan and cast it to a ctypes array pointer memhandle = ul.scaled_win_buf_alloc(total_count) ctypes_array = cast(memhandle, POINTER(c_double)) # Note: the ctypes array will no longer be valid after win_buf_free is # called. # A copy of the buffer can be created using win_buf_to_array or # win_buf_to_array_32 before the memory is freed. The copy can be used # at any time. # Check if the buffer was successfully allocated if not memhandle: raise Exception('Error: Failed to allocate memory') # Start the scan ul.daq_in_scan( board_num, chan_list, chan_type_list, gain_list, num_chans, rate, 0, total_count, memhandle, scan_options) print('Scan completed successfully. Data:') # Create a format string that aligns the data in columns row_format = '{:>5}' + '{:>10}' * num_chans # Print the channel name headers labels = ['Index'] for ch_index in range(num_chans): channel_label = { ChannelType.ANALOG: lambda: 'AI' + str(chan_list[ch_index]), ChannelType.ANALOG_DIFF: lambda: 'AI' + str(chan_list[ch_index]), ChannelType.ANALOG_SE: lambda: 'AI' + str(chan_list[ch_index]), ChannelType.DIGITAL: lambda: chan_list[ch_index].name, ChannelType.CTR: lambda: 'CI' + str(chan_list[ch_index]), }[chan_type_list[ch_index]]() labels.append(channel_label) print(row_format.format(*labels)) # Print the data data_index = 0 for index in range(points_per_channel): display_data = [index] for ch_index in range(num_chans): data_label = { ChannelType.ANALOG: lambda: '{:.3f}'.format(ctypes_array[data_index]), ChannelType.ANALOG_DIFF: lambda: '{:.3f}'.format(ctypes_array[data_index]), ChannelType.ANALOG_SE: lambda: '{:.3f}'.format(ctypes_array[data_index]), ChannelType.DIGITAL: lambda: '{:d}'.format(int(ctypes_array[data_index])), ChannelType.CTR: lambda: '{:d}'.format(int(ctypes_array[data_index])), }[chan_type_list[ch_index]]() display_data.append(data_label) data_index += 1 # Print this row print(row_format.format(*display_data)) except Exception as e: print('\n', e) finally: if memhandle: # Free the buffer in a finally block to prevent a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True # Supported Device IDs for the USB-2408 and USB-2416 Series # USB-2408 = 253, USB-2408-2AO = 254, USB-2416 = 208, USB-2416-4AO = 209 dev_id_list = [253, 254, 208, 209] board_num = 0 low_chan = 0 high_chan = 3 num_chans = high_chan - low_chan + 1 memhandle = None try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') rate = 10 points_per_channel = 10 total_count = points_per_channel * num_chans scan_options = ScanOptions.FOREGROUND | ScanOptions.SCALEDATA memhandle = ul.scaled_win_buf_alloc(total_count) # Convert the memhandle to a ctypes array. # Use the memhandle_as_ctypes_array_scaled method for scaled buffers. ctypes_array = cast(memhandle, POINTER(c_double)) # Note: the ctypes array will no longer be valid after win_buf_free is # called. # A copy of the buffer can be created using win_buf_to_array or # win_buf_to_array_32 before the memory is freed. The copy can be used # at any time. # Check if the buffer was successfully allocated if not memhandle: raise Exception('Error: Failed to allocate memory') # Set channel settings set_channel_settings(board_num) # Start the scan ul.a_in_scan(board_num, low_chan, high_chan, total_count, rate, ULRange.BIP10VOLTS, memhandle, scan_options) print('Scan completed successfully. Data:') # Create a format string that aligns the data in columns row_format = '{:>5}' + '{:>10}' * num_chans # Print the channel name headers labels = ['Index'] for ch_num in range(low_chan, high_chan + 1): labels.append('CH' + str(ch_num)) print(row_format.format(*labels)) # Print the data for index in range(points_per_channel): display_data = [index] for data_index in range(num_chans): display_data.append('{:.3f}'.format(ctypes_array[data_index])) # Print this row print(row_format.format(*display_data)) except Exception as e: print('\n', e) finally: # Free the buffer in a finally block to prevent a memory leak. if memhandle: ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 rate = 100 points_per_channel = 10 memhandle = None try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_analog_input: raise Exception('Error: The DAQ device does not support ' 'analog input') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') ai_info = daq_dev_info.get_ai_info() low_chan = 0 high_chan = min(3, ai_info.num_chans - 1) num_chans = high_chan - low_chan + 1 total_count = points_per_channel * num_chans ai_range = ai_info.supported_ranges[0] scan_options = ScanOptions.FOREGROUND if ScanOptions.SCALEDATA in ai_info.supported_scan_options: # If the hardware supports the SCALEDATA option, it is easiest to # use it. scan_options |= ScanOptions.SCALEDATA memhandle = ul.scaled_win_buf_alloc(total_count) # Convert the memhandle to a ctypes array. # Use the memhandle_as_ctypes_array_scaled method for scaled # buffers. ctypes_array = cast(memhandle, POINTER(c_double)) elif ai_info.resolution <= 16: # Use the win_buf_alloc method for devices with a resolution <= 16 memhandle = ul.win_buf_alloc(total_count) # Convert the memhandle to a ctypes array. # Use the memhandle_as_ctypes_array method for devices with a # resolution <= 16. ctypes_array = cast(memhandle, POINTER(c_ushort)) else: # Use the win_buf_alloc_32 method for devices with a resolution > 16 memhandle = ul.win_buf_alloc_32(total_count) # Convert the memhandle to a ctypes array. # Use the memhandle_as_ctypes_array_32 method for devices with a # resolution > 16 ctypes_array = cast(memhandle, POINTER(c_ulong)) # Note: the ctypes array will no longer be valid after win_buf_free is # called. # A copy of the buffer can be created using win_buf_to_array or # win_buf_to_array_32 before the memory is freed. The copy can be used # at any time. # Check if the buffer was successfully allocated if not memhandle: raise Exception('Error: Failed to allocate memory') # Start the scan ul.a_in_scan(board_num, low_chan, high_chan, total_count, rate, ai_range, memhandle, scan_options) print('Scan completed successfully. Data:') # Create a format string that aligns the data in columns row_format = '{:>5}' + '{:>10}' * num_chans # Print the channel name headers labels = ['Index'] for ch_num in range(low_chan, high_chan + 1): labels.append('CH' + str(ch_num)) print(row_format.format(*labels)) # Print the data data_index = 0 for index in range(points_per_channel): display_data = [index] for _ in range(num_chans): if ScanOptions.SCALEDATA in scan_options: # If the SCALEDATA ScanOption was used, the values # in the array are already in engineering units. eng_value = ctypes_array[data_index] else: # If the SCALEDATA ScanOption was NOT used, the # values in the array must be converted to # engineering units using ul.to_eng_units(). eng_value = ul.to_eng_units(board_num, ai_range, ctypes_array[data_index]) data_index += 1 display_data.append('{:.3f}'.format(eng_value)) # Print this row print(row_format.format(*display_data)) except Exception as e: print('\n', e) finally: if memhandle: # Free the buffer in a finally block to prevent a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 rate = 100 file_name = 'scan_data.csv' memhandle = None # The size of the UL buffer to create, in seconds buffer_size_seconds = 2 # The number of buffers to write. After this number of UL buffers are # written to file, the example will be stopped. num_buffers_to_write = 5 try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_analog_input: raise Exception('Error: The DAQ device does not support ' 'analog input') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') ai_info = daq_dev_info.get_ai_info() low_chan = 0 high_chan = min(3, ai_info.num_chans - 1) num_chans = high_chan - low_chan + 1 # Create a circular buffer that can hold buffer_size_seconds worth of # data, or at least 10 points (this may need to be adjusted to prevent # a buffer overrun) points_per_channel = max(rate * buffer_size_seconds, 10) # Some hardware requires that the total_count is an integer multiple # of the packet size. For this case, calculate a points_per_channel # that is equal to or just above the points_per_channel selected # which matches that requirement. if ai_info.packet_size != 1: packet_size = ai_info.packet_size remainder = points_per_channel % packet_size if remainder != 0: points_per_channel += packet_size - remainder ul_buffer_count = points_per_channel * num_chans # Write the UL buffer to the file num_buffers_to_write times. points_to_write = ul_buffer_count * num_buffers_to_write # When handling the buffer, we will read 1/10 of the buffer at a time write_chunk_size = int(ul_buffer_count / 10) ai_range = ai_info.supported_ranges[0] scan_options = (ScanOptions.BACKGROUND | ScanOptions.CONTINUOUS | ScanOptions.SCALEDATA) memhandle = ul.scaled_win_buf_alloc(ul_buffer_count) # Allocate an array of doubles temporary storage of the data write_chunk_array = (c_double * write_chunk_size)() # Check if the buffer was successfully allocated if not memhandle: raise Exception('Failed to allocate memory') # Start the scan ul.a_in_scan( board_num, low_chan, high_chan, ul_buffer_count, rate, ai_range, memhandle, scan_options) status = Status.IDLE # Wait for the scan to start fully while status == Status.IDLE: status, _, _ = ul.get_status(board_num, FunctionType.AIFUNCTION) # Create a file for storing the data with open(file_name, 'w') as f: print('Writing data to ' + file_name, end='') # Write a header to the file for chan_num in range(low_chan, high_chan + 1): f.write('Channel ' + str(chan_num) + ',') f.write(u'\n') # Start the write loop prev_count = 0 prev_index = 0 write_ch_num = low_chan while status != Status.IDLE: # Get the latest counts status, curr_count, _ = ul.get_status(board_num, FunctionType.AIFUNCTION) new_data_count = curr_count - prev_count # Check for a buffer overrun before copying the data, so # that no attempts are made to copy more than a full buffer # of data if new_data_count > ul_buffer_count: # Print an error and stop writing ul.stop_background(board_num, FunctionType.AIFUNCTION) print('A buffer overrun occurred') break # Check if a chunk is available if new_data_count > write_chunk_size: wrote_chunk = True # Copy the current data to a new array # Check if the data wraps around the end of the UL # buffer. Multiple copy operations will be required. if prev_index + write_chunk_size > ul_buffer_count - 1: first_chunk_size = ul_buffer_count - prev_index second_chunk_size = ( write_chunk_size - first_chunk_size) # Copy the first chunk of data to the # write_chunk_array ul.scaled_win_buf_to_array( memhandle, write_chunk_array, prev_index, first_chunk_size) # Create a pointer to the location in # write_chunk_array where we want to copy the # remaining data second_chunk_pointer = cast(addressof(write_chunk_array) + first_chunk_size * sizeof(c_double), POINTER(c_double)) # Copy the second chunk of data to the # write_chunk_array ul.scaled_win_buf_to_array( memhandle, second_chunk_pointer, 0, second_chunk_size) else: # Copy the data to the write_chunk_array ul.scaled_win_buf_to_array( memhandle, write_chunk_array, prev_index, write_chunk_size) # Check for a buffer overrun just after copying the data # from the UL buffer. This will ensure that the data was # not overwritten in the UL buffer before the copy was # completed. This should be done before writing to the # file, so that corrupt data does not end up in it. status, curr_count, _ = ul.get_status( board_num, FunctionType.AIFUNCTION) if curr_count - prev_count > ul_buffer_count: # Print an error and stop writing ul.stop_background(board_num, FunctionType.AIFUNCTION) print('A buffer overrun occurred') break for i in range(write_chunk_size): f.write(str(write_chunk_array[i]) + ',') write_ch_num += 1 if write_ch_num == high_chan + 1: write_ch_num = low_chan f.write(u'\n') else: wrote_chunk = False if wrote_chunk: # Increment prev_count by the chunk size prev_count += write_chunk_size # Increment prev_index by the chunk size prev_index += write_chunk_size # Wrap prev_index to the size of the UL buffer prev_index %= ul_buffer_count if prev_count >= points_to_write: break print('.', end='') else: # Wait a short amount of time for more data to be # acquired. sleep(0.1) ul.stop_background(board_num, FunctionType.AIFUNCTION) except Exception as e: print('\n', e) finally: print('Done') if memhandle: # Free the buffer in a finally block to prevent a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 memhandle = None try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_analog_output: raise Exception('Error: The DAQ device does not support ' 'analog output') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') ao_info = daq_dev_info.get_ao_info() low_chan = 0 high_chan = min(3, ao_info.num_chans - 1) num_chans = high_chan - low_chan + 1 rate = 100 points_per_channel = 1000 total_count = points_per_channel * num_chans ao_range = ao_info.supported_ranges[0] # Allocate a buffer for the scan memhandle = ul.win_buf_alloc(total_count) # Convert the memhandle to a ctypes array # Note: the ctypes array will no longer be valid after win_buf_free # is called. # A copy of the buffer can be created using win_buf_to_array # before the memory is freed. The copy can be used at any time. ctypes_array = cast(memhandle, POINTER(c_ushort)) # Check if the buffer was successfully allocated if not memhandle: raise Exception('Error: Failed to allocate memory') frequencies = add_example_data(board_num, ctypes_array, ao_range, num_chans, rate, points_per_channel) for ch_num in range(low_chan, high_chan + 1): print('Channel', ch_num, 'Output Signal Frequency:', frequencies[ch_num - low_chan]) # Start the scan ul.a_out_scan(board_num, low_chan, high_chan, total_count, rate, ao_range, memhandle, ScanOptions.BACKGROUND) # Wait for the scan to complete print('Waiting for output scan to complete...', end='') status = Status.RUNNING while status != Status.IDLE: print('.', end='') # Slow down the status check so as not to flood the CPU sleep(0.5) status, _, _ = ul.get_status(board_num, FunctionType.AOFUNCTION) print('') print('Scan completed successfully') except Exception as e: print('\n', e) finally: if memhandle: # Free the buffer in a finally block to prevent a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)