def initialize(self): connected_devices = get_daq_device_inventory(InterfaceType.USB) number_of_devices = len(connected_devices) if number_of_devices == 0: raise Exception( 'OLYMPUS: RUNTIME ERROR - DAQ DEVICE NOT CONNECTED') for daqs in connected_devices: if daqs.unique_id == self.serial: self.daq_device = DaqDevice(daqs) self.ai_device = self.daq_device.get_ai_device() self.daq_device.connect() self.daq_data = create_float_buffer(self.channel_count, self.samples_per_channel) self.scan_event_parameters_daq = self.ScanParams( self.daq_data, self.high_channel, self.low_channel) return True
def main(): # Parameters for AoDevice.a_out_scan low_channel = 0 high_channel = 0 voltage_range_index = 0 # Use the first supported range samples_per_channel = 2000 # Two second buffer (sample_rate * 2) sample_rate = 1000 # Hz scan_options = ScanOption.CONTINUOUS scan_flags = AOutScanFlag.DEFAULT interface_type = InterfaceType.USB daq_device = None ao_device = None scan_status = ScanStatus.IDLE try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) # Verify at least one DAQ device is detected. if number_of_devices == 0: raise Exception('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') for i in range(number_of_devices): print(' ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='') # Create a DaqDevice object from the first descriptor. daq_device = DaqDevice(devices[0]) ao_device = daq_device.get_ao_device() # Verify the specified DAQ device supports analog output. if ao_device is None: raise Exception( 'Error: The DAQ device does not support analog output') # Verify the specified DAQ device supports hardware pacing for analog output. ao_info = ao_device.get_info() if not ao_info.has_pacer(): raise Exception( 'Error: The DAQ device does not support paced analog output') descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') # Establish a connection to the device. daq_device.connect() chan_string = str(low_channel) num_channels = high_channel - low_channel + 1 if num_channels > 1: chan_string = ' '.join((chan_string, '-', str(high_channel))) # Select the voltage range voltage_ranges = ao_info.get_ranges() if voltage_range_index < 0: voltage_range_index = 0 elif voltage_range_index >= len(voltage_ranges): voltage_range_index = len(voltage_ranges) - 1 voltage_range = ao_info.get_ranges()[voltage_range_index] # Create a buffer for output data. out_buffer = create_float_buffer(num_channels, samples_per_channel) # Fill the output buffer with data. amplitude = 1.0 # Volts offset = amplitude if voltage_range > 1000 else 0.0 # Set an offset if the range is unipolar samples_per_cycle = int(sample_rate / 10.0) # 10 Hz sine wave create_output_data(num_channels, samples_per_channel, samples_per_cycle, amplitude, offset, out_buffer) print('\n', descriptor.dev_string, 'ready') print(' Function demonstrated: AoDevice.a_out_scan') print(' Channel(s):', chan_string) print(' Range:', voltage_range.name) print(' Samples per channel:', samples_per_channel) print(' Sample Rate:', sample_rate, 'Hz') print(' Scan options:', display_scan_options(scan_options)) try: input('\nHit ENTER to continue') except (NameError, SyntaxError): pass # Start the output scan. sample_rate = ao_device.a_out_scan(low_channel, high_channel, voltage_range, samples_per_channel, sample_rate, scan_options, scan_flags, out_buffer) system('clear') print('Please enter CTRL + C to terminate the process\n') print('Active DAQ device: ', descriptor.dev_string, ' (', descriptor.unique_id, ')\n', sep='') print(' Actual scan rate: ', sample_rate, 'Hz') try: while True: # Get and display the scan status. scan_status, transfer_status = ao_device.get_scan_status() if scan_status != ScanStatus.RUNNING: break print(' Current scan count: ', transfer_status.current_scan_count) print(' Current total count:', transfer_status.current_total_count) print(' Current index: ', transfer_status.current_index) stdout.flush() sleep(0.1) # Clear the previous status before displaying the next status. for line in range(3): stdout.write(CURSOR_UP + ERASE_LINE) except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if daq_device: # Stop the scan. if scan_status == ScanStatus.RUNNING: ao_device.scan_stop() # Disconnect from the DAQ device. if daq_device.is_connected(): daq_device.disconnect() # Release the DAQ device resource. daq_device.release()
def signal_processing(channel_total, srate, stime): low_channel = min(channel_total) high_channel = max(channel_total) num_scan_channels = high_channel - low_channel + 1 srate = srate samples_per_channel = srate * stime data_buffer = create_float_buffer(num_scan_channels, samples_per_channel) range_index = 0 descriptor_index = 0 interface_type = InterfaceType.USB flags = AInScanFlag.DEFAULT input_mode = AiInputMode.SINGLE_ENDED scan_options = ScanOption.DEFAULTIO daq_device = None ai_device = None status = ScanStatus.IDLE try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) if number_of_devices == 0: raise Exception('Error: No DAQ devices found') # Create the DAQ device object associated with the specified descriptor index. daq_device = DaqDevice(devices[descriptor_index]) # Get the AiDevice object and verify that it is valid. ai_device = daq_device.get_ai_device() if ai_device is None: raise Exception( 'Error: The DAQ device does not support analog input') # Verify that the specified device supports hardware pacing for analog input. ai_info = ai_device.get_info() if not ai_info.has_pacer(): raise Exception( '\nError: The specified DAQ device does not support hardware paced analog input' ) # Establish a connection to the DAQ device. descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') daq_device.connect() ranges = ai_info.get_ranges(input_mode) if range_index >= len(ranges): range_index = len(ranges) - 1 try: print('Start sampling...') rate = ai_device.a_in_scan(low_channel, high_channel, input_mode, Range.BIP5VOLTS, samples_per_channel, rate, scan_options, flags, data_buffer) print("mem = ", daq_device.get_info().get_mem_info()) print('data scanning') datas = [] ai_device.scan_wait(WaitType.WAIT_UNTIL_DONE, -1) for channel_number in channel_total: datas.append(data_buffer[channel_number::num_scan_channels]) except (ValueError, NameError, SyntaxError): pass except Exception as e: print('\n', e) finally: # Stop the acquisition if it is still running. ai_device.scan_stop() daq_device.disconnect() daq_device.release() return datas print("get data finished")
def main(): daq_device = None daqi_device = None status = ScanStatus.IDLE samples_per_channel = 10000 rate = 1000.0 options = ScanOption.DEFAULTIO | ScanOption.CONTINUOUS flags = DaqInScanFlag.DEFAULT interface_type = InterfaceType.USB descriptor_index = 0 try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) if number_of_devices == 0: raise Exception('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') for i in range(number_of_devices): print(' ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='') # Create the DAQ device object associated with the specified descriptor index. daq_device = DaqDevice(devices[descriptor_index]) # Get the DaqiDevice object and verify that it is valid. daqi_device = daq_device.get_daqi_device() if daqi_device is None: raise Exception( 'Error: The device does not support daq input subsystem') # Establish a connection to the DAQ device. descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') daq_device.connect() # Get the channel types supported by the DAQI subsystem daqi_info = daqi_device.get_info() chan_types_list = daqi_info.get_channel_types() # Configure the analog input channels. channel_descriptors = [] if DaqInChanType.ANALOG_SE in chan_types_list: configure_analog_input_channels(daq_device, channel_descriptors) # Configure the digital input channels. if DaqInChanType.DIGITAL in chan_types_list: configure_digital_input_channels(daq_device, channel_descriptors) # Configure the counter input channels. if DaqInChanType.CTR32 in chan_types_list: configure_counter_input_channels(daq_device, channel_descriptors) number_of_scan_channels = len(channel_descriptors) # Allocate a buffer to receive the data data = create_float_buffer(number_of_scan_channels, samples_per_channel) print('\n', descriptor.dev_string, ' ready', sep='') print(' Function demonstrated: daqi_device.daq_in_scan()') print(' Number of scan channels: ', number_of_scan_channels) for i in range(number_of_scan_channels): if channel_descriptors[i].type == AiInputMode.SINGLE_ENDED or \ channel_descriptors[i].type == AiInputMode.DIFFERENTIAL: print(' ScanChannel ', i, ': type = ', DaqInChanType(channel_descriptors[i].type).name, ', channel = ', channel_descriptors[i].channel, ', range = ', Range(channel_descriptors[i].range).name) else: print(' ScanChannel ', i, ': type = ', DaqInChanType(channel_descriptors[i].type).name, ', channel = ', channel_descriptors[i].channel) print(' Samples per channel: ', samples_per_channel) print(' Rate: ', rate, ' Hz') print(' Scan options:', display_scan_options(options)) try: input('\nHit ENTER to continue\n') except (NameError, SyntaxError): pass system('clear') # Start the acquisition. rate = daqi_device.daq_in_scan(channel_descriptors, samples_per_channel, rate, options, flags, data) try: while True: try: # Get the status of the background operation status, transfer_status = daqi_device.get_scan_status() reset_cursor() print('Please enter CTRL + C to terminate the process\n') print('Active DAQ device: ', descriptor.dev_string, ' (', descriptor.unique_id, ')\n', sep='') print('actual scan rate = ', '{:.6f}'.format(rate), 'Hz\n') index = transfer_status.current_index print('currentScanCount = ', transfer_status.current_scan_count) print('currentTotalCount = ', transfer_status.current_total_count) print('currentIndex = ', index, '\n') for i in range(number_of_scan_channels): if channel_descriptors[i].type == DaqInChanType.ANALOG_SE \ or channel_descriptors[i].type == DaqInChanType.ANALOG_DIFF: clear_eol() print('(Ai', channel_descriptors[i].channel, '): ', '{:.6f}'.format(data[index + i])) elif channel_descriptors[ i].type == DaqInChanType.DIGITAL: clear_eol() print('(Di', channel_descriptors[i].channel, '): ', '{:d}'.format(int(data[index + i]))) else: clear_eol() print('(Ci', channel_descriptors[i].channel, '): ', '{:d}'.format(int(data[index + i]))) sleep(0.1) except (ValueError, NameError, SyntaxError): break except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if daq_device: # Stop the scan if it is still running. if status == ScanStatus.RUNNING: daqi_device.scan_stop() if daq_device.is_connected(): daq_device.disconnect() daq_device.release()
def main(): daq_device = None ai_device = None status = ScanStatus.IDLE descriptor_index = 0 range_index = 0 interface_type = InterfaceType.USB low_channel = 0 high_channel = 3 samples_per_channel = 10000 rate = 100 scan_options = ScanOption.DEFAULTIO | ScanOption.CONTINUOUS flags = AInScanFlag.DEFAULT try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) if number_of_devices == 0: raise Exception('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') for i in range(number_of_devices): print(' ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='') # Create the DAQ device object associated with the specified descriptor index. daq_device = DaqDevice(devices[descriptor_index]) # Get the AiDevice object and verify that it is valid. ai_device = daq_device.get_ai_device() if ai_device is None: raise Exception( 'Error: The DAQ device does not support analog input') # Verify that the specified device supports hardware pacing for analog input. ai_info = ai_device.get_info() if not ai_info.has_pacer(): raise Exception( '\nError: The specified DAQ device does not support hardware paced analog input' ) # Establish a connection to the DAQ device. descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') daq_device.connect() # The default input mode is SINGLE_ENDED. input_mode = AiInputMode.SINGLE_ENDED # If SINGLE_ENDED input mode is not supported, set to DIFFERENTIAL. if ai_info.get_num_chans_by_mode(AiInputMode.SINGLE_ENDED) <= 0: input_mode = AiInputMode.DIFFERENTIAL # Get the number of channels and validate the high channel number. number_of_channels = ai_info.get_num_chans_by_mode(input_mode) if high_channel >= number_of_channels: high_channel = number_of_channels - 1 channel_count = high_channel - low_channel + 1 # Get a list of supported ranges and validate the range index. ranges = ai_info.get_ranges(input_mode) if range_index >= len(ranges): range_index = len(ranges) - 1 # Get a list of supported queue types. queue_types = ai_info.get_queue_types() if len(queue_types) == 0: raise Exception('Error: The device does not support a gain queue') # Assign each channel in the queue an input mode (SE/DIFF) and a range. If multiple # ranges are supported, we will cycle through them and repeat ranges if the number # of channels exceeds the number of ranges. # # This block of code could be used to set other queue elements such as the input mode # and channel list. queue_list = [] for i in range(channel_count): queue_element = AiQueueElement() queue_element.channel = i queue_element.input_mode = input_mode queue_element.range = ranges[range_index] queue_list.append(queue_element) range_index += 1 if range_index >= len(ranges): range_index = 0 # Load the queue. ai_device.a_in_load_queue(queue_list) data = create_float_buffer(channel_count, samples_per_channel) print('\n', descriptor.dev_string, ' ready', sep='') print(' Function demonstrated: ai_device.a_in_load_queue()') print(' Channels: ', low_channel, '-', high_channel) for i in range(channel_count): print(' Channel:', queue_list[i].channel, ', Input mode:', AiInputMode(queue_list[i].input_mode).name, ', Range:', Range(queue_list[i].range).name) print(' Samples per channel: ', samples_per_channel) print(' Rate: ', rate, 'Hz') print(' Scan options:', display_scan_options(scan_options)) try: input('\nHit ENTER to continue\n') except (NameError, SyntaxError): pass # Start the acquisition. # # When using the queue, the low_channel, high_channel, input_mode, and range # parameters are ignored since they are specified in queue_array. rate = ai_device.a_in_scan(low_channel, high_channel, input_mode, ranges[range_index], samples_per_channel, rate, scan_options, flags, data) system('clear') try: while True: try: # Get the status of the background operation status, transfer_status = ai_device.get_scan_status() reset_cursor() print('Please enter CTRL + C to terminate the process\n') print('Active DAQ device: ', descriptor.dev_string, ' (', descriptor.unique_id, ')\n', sep='') print('actual scan rate = ', '{:.6f}'.format(rate), 'Hz\n') index = transfer_status.current_index print('currentTotalCount = ', transfer_status.current_total_count) print('currentScanCount = ', transfer_status.current_scan_count) print('currentIndex = ', index, '\n') # Display the data. for i in range(channel_count): print('chan =', i + low_channel, ': ', '{:.6f}'.format(data[index + i])) sleep(0.1) except (ValueError, NameError, SyntaxError): break except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if daq_device: # Stop the acquisition if it is still running. if status == ScanStatus.RUNNING: ai_device.scan_stop() if daq_device.is_connected(): daq_device.disconnect() daq_device.release()
def stream(low_channel, high_channel, sample_rate, data_file): """Analog input scan example.""" daq_device = None ai_device = None status = ScanStatus.IDLE device_number = 0 dt = 0.1 # how often save a chunk of data range_index = 0 buffer_margin = 20 interface_type = InterfaceType.ANY samples_per_channel = int(buffer_margin * dt * sample_rate) scan_options = ScanOption.CONTINUOUS flags = AInScanFlag.DEFAULT try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) if number_of_devices == 0: raise RuntimeError('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') print('using device', device_number) descriptor_index = device_number if descriptor_index not in range(number_of_devices): raise RuntimeError('Error: Invalid descriptor index') # Create the DAQ device from the descriptor at the specified index. daq_device = DaqDevice(devices[descriptor_index]) # Get the AiDevice object and verify that it is valid. ai_device = daq_device.get_ai_device() if ai_device is None: raise RuntimeError('Error: The DAQ device does not support analog ' 'input') # Verify the specified device supports hardware pacing for analog input. ai_info = ai_device.get_info() if not ai_info.has_pacer(): raise RuntimeError('\nError: The specified DAQ device does not ' 'support hardware paced analog input') # Establish a connection to the DAQ device. descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') # For Ethernet devices using a connection_code other than the default # value of zero, change the line below to enter the desired code. try: daq_device.connect(connection_code=0) except TypeError: daq_device.connect() # The default input mode is SINGLE_ENDED. input_mode = AiInputMode.SINGLE_ENDED # If SINGLE_ENDED input mode is not supported, set to DIFFERENTIAL. if ai_info.get_num_chans_by_mode(AiInputMode.SINGLE_ENDED) <= 0: input_mode = AiInputMode.DIFFERENTIAL # Get the number of channels and validate the high channel number. number_of_channels = ai_info.get_num_chans_by_mode(input_mode) if high_channel >= number_of_channels: high_channel = number_of_channels - 1 channel_count = high_channel - low_channel + 1 # Get a list of supported ranges and validate the range index. ranges = ai_info.get_ranges(input_mode) if range_index >= len(ranges): range_index = len(ranges) - 1 # Allocate a buffer to receive the data.0 data = create_float_buffer(channel_count, samples_per_channel) print('\n', descriptor.dev_string, ' ready', sep='') print(' Function demonstsample_rated: ai_device.a_in_scan()') print(' Channels: ', low_channel, '-', high_channel) print(' Input mode: ', input_mode.name) print(' Range: ', ranges[range_index].name) print(' Samples per channel: ', samples_per_channel) print(' Rate: ', sample_rate, 'Hz') print(' Scan options:', display_scan_options(scan_options)) # Start the acquisition. sample_rate = ai_device.a_in_scan(low_channel, high_channel, input_mode, ranges[range_index], samples_per_channel, sample_rate, scan_options, flags, data) print() print('acquiring data ..', end='') stdout.flush() with open(data_file, 'w') as f: save_count = 0 last_save_index = 0 buffer_size = samples_per_channel * channel_count while not done: # Get the status of the background operation status, transfer_status = ai_device.get_scan_status() current_index = transfer_status.current_index if current_index < 0: continue num_to_save = (current_index - last_save_index) % buffer_size + channel_count # Write data to file for i in range(num_to_save): if i % channel_count == 0: f.write('{} '.format(save_count)) save_count += 1 save_index = (last_save_index + i) % buffer_size f.write('{}'.format(data[save_index])) if i % channel_count == (channel_count - 1): f.write('\n') else: f.write(' ') last_save_index = (current_index + channel_count) % buffer_size sleep(dt) print('done') except RuntimeError as error: print('\n', error) finally: if daq_device: # Stop the acquisition if it is still running. if status == ScanStatus.RUNNING: ai_device.scan_stop() if daq_device.is_connected(): daq_device.disconnect() daq_device.release()
def daq_setup(rate=500000, samples_per_channel=500000 * 10, resistor=0.1): """Analog input scan example.""" global bench_over bench_over = False # beginning of a new cycle daq_device = None status = ScanStatus.IDLE # samples_per_channel (int): the number of A/D samples to collect from each channel in the scan. # rate (float): A/D sample rate in samples per channel per second. range_index = 0 interface_type = InterfaceType.ANY low_channel = 0 high_channel = 0 scan_options = ScanOption.CONTINUOUS flags = AInScanFlag.DEFAULT # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) if number_of_devices == 0: raise RuntimeError('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') for i in range(number_of_devices): print(' [', i, '] ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='') descriptor_index = 0 if descriptor_index not in range(number_of_devices): raise RuntimeError('Error: Invalid descriptor index') # Create the DAQ device from the descriptor at the specified index. daq_device = DaqDevice(devices[descriptor_index]) # Get the AiDevice object and verify that it is valid. ai_device = daq_device.get_ai_device() if ai_device is None: raise RuntimeError('Error: The DAQ device does not support analog ' 'input') # Verify the specified device supports hardware pacing for analog input. ai_info = ai_device.get_info() if not ai_info.has_pacer(): raise RuntimeError('\nError: The specified DAQ device does not ' 'support hardware paced analog input') # Establish a connection to the DAQ device. descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') # For Ethernet devices using a connection_code other than the default # value of zero, change the line below to enter the desired code. daq_device.connect(connection_code=0) # The default input mode is DIFFERENTIAL. input_mode = AiInputMode.DIFFERENTIAL # Get the number of channels and validate the high channel number. number_of_channels = ai_info.get_num_chans_by_mode(input_mode) if high_channel >= number_of_channels: high_channel = number_of_channels - 1 channel_count = high_channel - low_channel + 1 # Get a list of supported ranges and validate the range index. ranges = ai_info.get_ranges(input_mode) if range_index >= len(ranges): range_index = len(ranges) - 1 meas_range = ranges[1] data_dir = "data_dir" if not os.path.isdir(data_dir): os.mkdir(data_dir) # define name of a datafile and delete if it exists in the data directory data_fname = "test_data" #if os.path.isfile(os.path.join(data_dir, data_fname)): #os.remove(os.path.join(data_dir, data_fname)) # Allocate a buffer to receive the data. data = create_float_buffer(channel_count, samples_per_channel) # ranges[1] = Range.BIP5VOLTS return daq_device, low_channel, high_channel, input_mode, meas_range, samples_per_channel, rate, scan_options, flags, data, data_dir, data_fname
def main(): daq_device = None ai_device = None status = ScanStatus.IDLE descriptor_index = 0 range_index = 0 iepe_mode = IepeMode.ENABLED coupling = CouplingMode.AC sensor_sensitivity = 1.0 # volts per unit interface_type = InterfaceType.USB low_channel = 0 high_channel = 3 samples_per_channel = 10000 rate = 100 scan_options = ScanOption.CONTINUOUS flags = AInScanFlag.DEFAULT try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) # Verify at least one DAQ device is detected. if number_of_devices == 0: raise Exception('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') for i in range(number_of_devices): print(' ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='') # Create a DaqDevice object from the first descriptor. daq_device = DaqDevice(devices[descriptor_index]) # Get the AiDevice object and verify that it is valid. ai_device = daq_device.get_ai_device() if ai_device is None: raise Exception( 'Error: The DAQ device does not support analog input') # Verify the device supports hardware pacing for analog input. ai_info = ai_device.get_info() if not ai_info.has_pacer(): raise Exception('Error: The DAQ device does not support hardware ', 'paced analog input') # Verify the device supports IEPE if not ai_info.supports_iepe(): raise Exception('Error: The DAQ device does not support IEPE') # Establish a connection to the DAQ device. descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') daq_device.connect() # The default input mode is SINGLE_ENDED. input_mode = AiInputMode.SINGLE_ENDED # If SINGLE_ENDED input mode is not supported, set to DIFFERENTIAL. if ai_info.get_num_chans_by_mode(AiInputMode.SINGLE_ENDED) <= 0: input_mode = AiInputMode.DIFFERENTIAL # Get the number of channels and validate the high channel number. number_of_channels = ai_info.get_num_chans_by_mode(input_mode) if high_channel >= number_of_channels: high_channel = number_of_channels - 1 channel_count = high_channel - low_channel + 1 # Get a list of supported ranges and validate the range index. ranges = ai_info.get_ranges(input_mode) if range_index >= len(ranges): range_index = len(ranges) - 1 # Set IEPE mode, AC coupling and sensor sensitivity for each channel ai_config = ai_device.get_config() for chan in range(low_channel, high_channel + 1): ai_config.set_chan_iepe_mode(chan, iepe_mode) ai_config.set_chan_coupling_mode(chan, coupling) ai_config.set_chan_sensor_sensitivity(chan, sensor_sensitivity) data = create_float_buffer(channel_count, samples_per_channel) print('\n', descriptor.dev_string, ' ready', sep='') print(' Function demonstrated: ai_device.a_in_scan()') print(' Channels: ', low_channel, '-', high_channel) print(' Input mode: ', input_mode.name) print(' Range: ', ranges[range_index].name) print(' Samples per channel: ', samples_per_channel) print(' Rate: ', rate, 'Hz') print(' Scan options:', display_scan_options(scan_options)) print(' Sensor Sensitivity: {:.6f}'.format(sensor_sensitivity), '(V/unit)') try: input('\nHit ENTER to continue\n') except (NameError, SyntaxError): pass system('clear') rate = ai_device.a_in_scan(low_channel, high_channel, input_mode, ranges[range_index], samples_per_channel, rate, scan_options, flags, data) try: while True: try: status, transfer_status = ai_device.get_scan_status() index = transfer_status.current_index if index >= 0: system('clear') print('Please enter CTRL + C to terminate the process', '\n') print('Active DAQ device: ', descriptor.dev_string, ' (', descriptor.unique_id, ')\n', sep='') print('Actual scan rate = {:.6f}\n'.format(rate)) print('currentTotalCount = ', transfer_status.current_total_count) print('currentScanCount = ', transfer_status.current_scan_count) print('currentIndex = ', index, '\n') for i in range(channel_count): print('chan ', i + low_channel, ' = ', '{:.6f}'.format(data[index + i])) sleep(0.1) except (ValueError, NameError, SyntaxError): break except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if daq_device: # Stop the acquisition if it is still running. if status == ScanStatus.RUNNING: ai_device.scan_stop() if daq_device.is_connected(): daq_device.disconnect() daq_device.release()
def main(): global rate daq_device = None ai_device = None ai_info = None descriptor_index = 0 range_index = 0 interface_type = InterfaceType.USB low_channel = 0 high_channel = 3 samples_per_channel = 10000 rate = 100 flags = AInScanFlag.DEFAULT event_types = (DaqEventType.ON_DATA_AVAILABLE | DaqEventType.ON_END_OF_INPUT_SCAN | DaqEventType.ON_INPUT_SCAN_ERROR) ScanParams = namedtuple('ScanParams', 'buffer high_chan low_chan descriptor status') # set the scan options for a FINITE scan ... to set the scan options for # a continuous scan, uncomment the line that or's the SO_CONTINUOUS option # into to the scanOptions variable scan_options = ScanOption.DEFAULTIO # scan_options |= ScanOption.CONTINUOUS try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) if number_of_devices == 0: raise Exception('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') for i in range(number_of_devices): print(' ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='') # Create the DAQ device object from the specified descriptor index. daq_device = DaqDevice(devices[descriptor_index]) # Get the AiDevice object and verify that it is valid. ai_device = daq_device.get_ai_device() if ai_device is None: raise Exception('Error: The DAQ device does not support analog ' 'input') # Verify the device supports hardware pacing for analog input. ai_info = ai_device.get_info() if not ai_info.has_pacer(): raise Exception( '\nError: The specified DAQ device does not support' ' hardware paced analog input') # Establish a connection to the DAQ device. descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') daq_device.connect() # The default input mode is SINGLE_ENDED. input_mode = AiInputMode.SINGLE_ENDED # If SINGLE_ENDED input mode is not supported, set to DIFFERENTIAL. if ai_info.get_num_chans_by_mode(AiInputMode.SINGLE_ENDED) <= 0: input_mode = AiInputMode.DIFFERENTIAL # Get the number of channels and validate the high channel number. number_of_channels = ai_info.get_num_chans_by_mode(input_mode) if high_channel >= number_of_channels: high_channel = number_of_channels - 1 channel_count = high_channel - low_channel + 1 # Get a list of supported ranges and validate the range index. ranges = ai_info.get_ranges(input_mode) if range_index >= len(ranges): range_index = len(ranges) - 1 # Allocate a buffer to receive the data. data = create_float_buffer(channel_count, samples_per_channel) # Store the user data for use in the callback function. scan_status = {'complete': False, 'error': False} user_data = ScanParams(data, high_channel, low_channel, descriptor, scan_status) # Enable the event to be notified every time 100 samples are available. available_sample_count = 100 daq_device.enable_event(event_types, available_sample_count, event_callback_function, user_data) print('\n', descriptor.dev_string, 'ready', sep='') print(' Function demonstrated: daq_device.enable_event()') print(' Channels: ', low_channel, '-', high_channel) print(' Input mode: ', input_mode.name) print(' Range: ', ranges[range_index].name) print(' Samples per channel: ', samples_per_channel) print(' Rate: ', rate, 'Hz') print(' Scan options:', display_scan_options(scan_options)) try: input('\nHit ENTER to continue\n') except (NameError, SyntaxError): pass system('clear') # Start the finite acquisition. rate = ai_device.a_in_scan(low_channel, high_channel, input_mode, ranges[range_index], samples_per_channel, rate, scan_options, flags, data) # Wait here until the scan is done ... events will be handled in the # event handler (eventCallbackFunction). # The scan_status values are set in the event handler callback. while not scan_status['complete'] and not scan_status['error']: sleep(0.1) except KeyboardInterrupt: pass except (ValueError, NameError, SyntaxError): pass except Exception as e: print('\n', e) finally: if daq_device: if daq_device.is_connected(): # Stop the acquisition if it is still running. if ai_device and ai_info and ai_info.has_pacer(): ai_device.scan_stop() daq_device.disable_event(event_types) daq_device.disconnect() daq_device.release()
def main(data_write_mode = ''): daq_device = None ai_device = None status = ScanStatus.IDLE descriptor_index = 0 range_index = 0 interface_type = InterfaceType.USB low_channel = 0 high_channel = 0 rate = 100000 # Samples/second/channel buffer_length = 200000 f_transmit = 36000 # fundamental frequency of transmitter channel_num = high_channel-low_channel+1 samples_per_channel = int(float(buffer_length)/float(channel_num)) file_length = 2 # Seconds rows_of_data = (float(file_length)/((float(buffer_length)/2)/(float(rate)*float(channel_num))))*((float(buffer_length)/2)/float(channel_num)) scan_options = ScanOption.CONTINUOUS flags = AInScanFlag.DEFAULT #CONTROL ALGORITHM PARAMETERS: velocity = 1 #tune speed beta = 0.01 #tune turning heading = 0 past_freq = f_transmit dH = -1.0001 try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) if number_of_devices == 0: raise Exception('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') for i in range(number_of_devices): print(' ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='') # Create the DAQ device object associated with the specified descriptor index. daq_device = DaqDevice(devices[descriptor_index]) # Get the AiDevice object and verify that it is valid. ai_device = daq_device.get_ai_device() if ai_device is None: raise Exception('Error: The DAQ device does not support analog input') # Verify that the specified device supports hardware pacing for analog input. ai_info = ai_device.get_info() if not ai_info.has_pacer(): raise Exception('\nError: The specified DAQ device does not support hardware paced analog input') # Establish a connection to the DAQ device. descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') daq_device.connect() # The default input mode is SINGLE_ENDED. input_mode = AiInputMode.SINGLE_ENDED # If SINGLE_ENDED input mode is not supported, set to DIFFERENTIAL. if ai_info.get_num_chans_by_mode(AiInputMode.SINGLE_ENDED) <= 0: input_mode = AiInputMode.DIFFERENTIAL # Get the number of channels and validate the high channel number. number_of_channels = ai_info.get_num_chans_by_mode(input_mode) if high_channel >= number_of_channels: high_channel = number_of_channels - 1 channel_count = high_channel - low_channel + 1 # Get a list of supported ranges and validate the range index. ranges = ai_info.get_ranges(input_mode) if range_index >= len(ranges): range_index = len(ranges) - 1 # Allocate a buffer to receive the data. data = create_float_buffer(channel_count, samples_per_channel) print('\n', descriptor.dev_string, ' ready', sep='') print(' Function demonstrated: ai_device.a_in_scan()') print(' Channels: ', low_channel, '-', high_channel) print(' Input mode: ', input_mode.name) print(' Range: ', ranges[range_index].name) print(' Samples per channel: ', samples_per_channel) print(' Rate: ', rate, 'Hz') print(' Scan options:', display_scan_options(scan_options)) print(" Output File Rows:" +str(rows_of_data)) try: input('\nHit ENTER to continue\n') except (NameError, SyntaxError): pass system('clear') print('\nHit ^C to exit\n') #Set up threshold for where the dumps should occur in the buffer #Currently configured for dumping half of the buffer threshold = (float(len(data))/2) - (float(len(data))/2)%channel_count data_range = [range(int(threshold)),range(int(threshold),len(data))] #Setting up whether or not to write in binary mode write_mode = 'w'+data_write_mode # Start the acquisition. rate = ai_device.a_in_scan(low_channel, high_channel, input_mode, ranges[range_index], samples_per_channel, rate, scan_options, flags, data) #open first text file start=time.time() f=open('./data/'+'{:.6f}'.format(start)+".txt",write_mode) try: past_index = -1 #Initiated at -1 to because index is -1 until buffer is written to while True: #Get the status of the background operation status, transfer_status = ai_device.get_scan_status() #Make new file after fixed amount of time set by 'file_length' if time.time()-start>=file_length: f.close start=time.time() f=open('./data/'+'{:.6f}'.format(start)+".txt",write_mode) #get current index in filling the buffer to know when to clear it index = transfer_status.current_index #write half buffer to txt file, find max freq, and update heading if buffer fills past halfway point if past_index<=threshold and index>threshold: #dumps data data_fft, data_dump = dump_data(f, data, data_range[0], channel_count) #find fundamental frequency within 500Hz of f_transmit freq = fourier_analysis(data_fft,rate,f_transmit,500) #new heading past_freq, heading, dH = heading_adjust(freq, past_freq, beta, heading, dH) print('HEADING: %s FREQ: %d dH: %d' %(str(heading), past_freq,dH)) nav_solution(dH,heading) #write half buffer to txt file, find max freq, and update heading if buffer filled to end and is overwriting first half if past_index>index: #dumps data data_fft, data_dump = dump_data(f, data, data_range[1], channel_count) #find fundamental frequency within 500Hz of f_transmit freq = fourier_analysis(data_fft,rate,f_transmit,500) #new heading past_freq, heading, dH = heading_adjust(freq, past_freq, beta, heading, dH) print('HEADING: %s FREQ: %d dH: %d' %(str(heading), past_freq,dH)) nav_solution(dH,heading) past_index = index except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if daq_device: # Stop the acquisition if it is still running. if status == ScanStatus.RUNNING: ai_device.scan_stop() if daq_device.is_connected(): daq_device.disconnect() daq_device.release()
def main(): # Parameters for DaqoDevice.daq_out_scan channel_descriptors = [] samples_per_channel = 2000 # Two second buffer (sample_rate * 2) sample_rate = 1000 # Hz scan_options = ScanOption.CONTINUOUS scan_flags = DaqOutScanFlag.DEFAULT # Parameters used when creating channel_descriptors list analog_low_channel = 0 analog_high_channel = 0 analog_range_index = 0 digital_low_port_index = 0 digital_high_port_index = 0 interface_type = InterfaceType.USB daq_device = None daqo_device = None try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) # Verify at least one DAQ device is detected. if number_of_devices == 0: raise Exception('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') for i in range(number_of_devices): print(' ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='') # Create a DaqDevice object from the first descriptor. daq_device = DaqDevice(devices[0]) daqo_device = daq_device.get_daqo_device() # Verify the specified DAQ device supports DAQ output. if daqo_device is None: raise Exception( 'Error: The DAQ device does not support DAQ output') daqo_info = daqo_device.get_info() descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') # Establish a connection to the device. daq_device.connect() # Configure supported analog input and digital input channels amplitudes = [] samples_per_cycle = int(sample_rate / 10.0) # 10 Hz sine wave supported_channel_types = daqo_info.get_channel_types() if DaqOutChanType.ANALOG in supported_channel_types: configure_analog_channels(daq_device, analog_low_channel, analog_high_channel, analog_range_index, channel_descriptors, amplitudes) if DaqOutChanType.DIGITAL in supported_channel_types: configure_digital_channels(daq_device, digital_low_port_index, digital_high_port_index, channel_descriptors, amplitudes) num_channels = len(channel_descriptors) # Create a buffer for output data. out_buffer = create_float_buffer(num_channels, samples_per_channel) # Fill the output buffer with data. create_output_data(channel_descriptors, samples_per_channel, samples_per_cycle, amplitudes, out_buffer) print('\n', descriptor.dev_string, 'ready') print(' Function demonstrated: DaqoDevice.daq_out_scan') print(' Number of Scan Channels:', num_channels) for chan in range(num_channels): chan_descriptor = channel_descriptors[ chan] # type: DaqOutChanDescriptor print(' Scan Channel', chan, end='') print(': type =', DaqOutChanType(chan_descriptor.type).name, end='') if chan_descriptor.type == DaqOutChanType.ANALOG: print(', channel =', chan_descriptor.channel, end='') print(', range =', Range(chan_descriptor.range).name, end='') else: print(', port =', DigitalPortType(chan_descriptor.channel).name, end='') print('') print(' Samples per channel:', samples_per_channel) print(' Rate:', sample_rate, 'Hz') print(' Scan options:', display_scan_options(scan_options)) try: input('\nHit ENTER to continue') except (NameError, SyntaxError): pass system('clear') # Start the output scan. sample_rate = daqo_device.daq_out_scan(channel_descriptors, samples_per_channel, sample_rate, scan_options, scan_flags, out_buffer) print('Please enter CTRL + C to terminate the process\n') print('Active DAQ device: ', descriptor.dev_string, ' (', descriptor.unique_id, ')\n', sep='') print(' Actual scan rate: ', sample_rate, 'Hz') try: while True: # Get and display the scan status. scan_status, transfer_status = daqo_device.get_scan_status() if scan_status != ScanStatus.RUNNING: break print(' Current scan count: ', transfer_status.current_scan_count) print(' Current total count:', transfer_status.current_total_count) print(' Current index: ', transfer_status.current_index) stdout.flush() sleep(0.1) # Clear the previous status before displaying the next status. for line in range(3): stdout.write(CURSOR_UP + ERASE_LINE) except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if daq_device: # Stop the scan. if daqo_device: daqo_device.scan_stop() # before disconnecting, set digital ports back to input dio_device = daq_device.get_dio_device() for chan in channel_descriptors: if chan.type == DaqOutChanType.DIGITAL: dio_device.d_config_port(chan.channel, DigitalDirection.INPUT) # Disconnect from the DAQ device. if daq_device.is_connected(): daq_device.disconnect() # Release the DAQ device resource. daq_device.release()
def main(): daq_device = None ai_device = None status = ScanStatus.IDLE descriptor_index = 0 range_index = 0 trigger_type_index = 0 interface_type = InterfaceType.USB low_channel = 0 high_channel = 3 samples_per_channel = 10000 rate = 100 scan_options = ScanOption.CONTINUOUS | ScanOption.EXTTRIGGER flags = AInScanFlag.DEFAULT try: # Get descriptors for all of the available DAQ devices. devices = get_daq_device_inventory(interface_type) number_of_devices = len(devices) if number_of_devices == 0: raise Exception('Error: No DAQ devices found') print('Found', number_of_devices, 'DAQ device(s):') for i in range(number_of_devices): print(' ', devices[i].product_name, ' (', devices[i].unique_id, ')', sep='') # Create the DAQ device object associated with the specified descriptor index. daq_device = DaqDevice(devices[descriptor_index]) # Get the AiDevice object and verify that it is valid. ai_device = daq_device.get_ai_device() if ai_device is None: raise Exception('Error: The DAQ device does not support analog input') # Verify that the specified device supports hardware pacing for analog input. ai_info = ai_device.get_info() if not ai_info.has_pacer(): raise Exception('\nError: The specified DAQ device does not support hardware paced analog input') # Establish a connection to the DAQ device. descriptor = daq_device.get_descriptor() print('\nConnecting to', descriptor.dev_string, '- please wait...') daq_device.connect() # The default input mode is SINGLE_ENDED. input_mode = AiInputMode.SINGLE_ENDED # If SINGLE_ENDED input mode is not supported, set to DIFFERENTIAL. if ai_info.get_num_chans_by_mode(AiInputMode.SINGLE_ENDED) <= 0: input_mode = AiInputMode.DIFFERENTIAL # Get the number of channels and validate the high channel number. number_of_channels = ai_info.get_num_chans_by_mode(input_mode) if high_channel >= number_of_channels: high_channel = number_of_channels - 1 channel_count = high_channel - low_channel + 1 # Get a list of supported ranges and validate the range index. ranges = ai_info.get_ranges(input_mode) if range_index >= len(ranges): range_index = len(ranges) - 1 # Get a list of trigger types. trigger_types = ai_info.get_trigger_types() if len(trigger_types) == 0: raise Exception('Error: The device does not support an external trigger') # Set the trigger. # # This example uses the default values for setting the trigger so there is no need to call this function. # If you want to change the trigger type (or any other trigger parameter), uncomment this function call and # change the trigger type (or any other parameter) ai_device.set_trigger(trigger_types[trigger_type_index], 0, 0, 0, 0) data = create_float_buffer(channel_count, samples_per_channel) print('\n', descriptor.dev_string, ' ready', sep='') print(' Function demonstrated: ai_device.set_trigger()') print(' Channels: ', low_channel, '-', high_channel) print(' Input mode: ', input_mode.name) print(' Range: ', ranges[range_index].name) print(' Samples per channel: ', samples_per_channel) print(' Rate: ', rate, 'Hz') print(' Scan options:', display_scan_options(scan_options)) print(' Trigger type:', trigger_types[trigger_type_index].name) try: input('\nHit ENTER to continue\n') except (NameError, SyntaxError): pass system('clear') ai_device.a_in_scan(low_channel, high_channel, input_mode, ranges[range_index], samples_per_channel, rate, scan_options, flags, data) print('Please enter CTRL + C to quit waiting for trigger\n') print('Waiting for trigger ...\n') try: while True: try: status, transfer_status = ai_device.get_scan_status() index = transfer_status.current_index if index >= 0: system('clear') print('Please enter CTRL + C to terminate the process\n') print('Active DAQ device: ', descriptor.dev_string, ' (', descriptor.unique_id, ')\n', sep='') print('currentTotalCount = ', transfer_status.current_total_count) print('currentScanCount = ', transfer_status.current_scan_count) print('currentIndex = ', index, '\n') for i in range(channel_count): print('chan =', i + low_channel, ': ', '{:.6f}'.format(data[index + i])) sleep(0.1) except (ValueError, NameError, SyntaxError): break except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if daq_device: # Stop the acquisition if it is still running. if status == ScanStatus.RUNNING: ai_device.scan_stop() if daq_device.is_connected(): daq_device.disconnect() daq_device.release()