def __init__(self): devices = get_daq_device_inventory(InterfaceType.USB) 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[0] ) #if more than one device, change this to the one you want self.daq_device = daq_device # Get the DioDevice object and verify that it is valid. dio_device = daq_device.get_dio_device() self.dio_device = dio_device if dio_device is None: raise Exception( 'Error: The device does not support digital output') self.connect()
def main(): daq_device = None dio_device = None port_to_write = None port_info = None interface_type = InterfaceType.USB descriptor_index = 0 port_types_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 DioDevice object and verify that it is valid. dio_device = daq_device.get_dio_device() if dio_device is None: raise Exception( 'Error: The device does not support digital output') # 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 port types for the device(AUXPORT, FIRSTPORTA, ...) dio_info = dio_device.get_info() port_types = dio_info.get_port_types() if port_types_index >= len(port_types): port_types_index = len(port_types) - 1 port_to_write = port_types[port_types_index] # Get the port I/O type and the number of bits for the first port. port_info = dio_info.get_port_info(port_to_write) # Configure the port for output. if (port_info.port_io_type == DigitalPortIoType.IO or port_info.port_io_type == DigitalPortIoType.BITIO): dio_device.d_config_port(port_to_write, DigitalDirection.OUTPUT) print('\n', descriptor.dev_string, ' ready', sep='') print(' Function demonstrated: dio_device.d_out()') print(' Port: ', port_types[port_types_index].name) try: input('\nHit ENTER to continue\n') except (NameError, SyntaxError): pass system('clear') max_port_value = int(pow(2.0, port_info.number_of_bits) - 1) reset_cursor() print('Active DAQ device: ', descriptor.dev_string, ' (', descriptor.unique_id, ')\n', sep='') try: while True: try: data = input('Enter a value between 0 and ' + '{:.0f}'.format(max_port_value) + ' (or non-numeric character to exit): ') # write the first port dio_device.d_out(port_to_write, int(data)) sleep(0.1) cursor_up() clear_eol() except (ValueError, NameError, SyntaxError): break except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if daq_device: if dio_device and port_to_write and port_info: # before disconnecting, set the port back to input if (port_info.port_io_type == DigitalPortIoType.IO or port_info.port_io_type == DigitalPortIoType.BITIO): dio_device.d_config_port(port_to_write, DigitalDirection.INPUT) if daq_device.is_connected(): daq_device.disconnect() daq_device.release()
def main(): daq_device = None dio_device = None status = ScanStatus.IDLE samples_per_channel = 10000 rate = 1000 scan_options = ScanOption.CONTINUOUS flags = DInScanFlag.DEFAULT interface_type = InterfaceType.USB descriptor_index = 0 port_types_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 DioDevice object and verify that it is valid. dio_device = daq_device.get_dio_device() if dio_device is None: raise Exception( 'Error: The DAQ device does not support digital input') # Verify that the specified device supports hardware pacing for digital input. dio_info = dio_device.get_info() if not dio_info.has_pacer(DigitalDirection.INPUT): raise Exception( 'Error: The specified DAQ device does not support hardware paced digital input' ) # 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 port types for the device(AUXPORT, FIRSTPORTA, ...) port_types = dio_info.get_port_types() if port_types_index >= len(port_types): port_types_index = len(port_types) - 1 port_to_read = port_types[port_types_index] # Configure the port for input. port_info = dio_info.get_port_info(port_to_read) if (port_info.port_io_type == DigitalPortIoType.IO or port_info.port_io_type == DigitalPortIoType.BITIO): dio_device.d_config_port(port_to_read, DigitalDirection.INPUT) low_port = port_to_read hi_port = port_to_read number_of_ports = hi_port - low_port + 1 # Allocate a buffer to receive the data. data = create_int_buffer(number_of_ports, samples_per_channel) print('\n', descriptor.dev_string, ' ready', sep='') print(' Function demonstrated: dio_device.d_in_scan()') print(' Device name: ', descriptor.dev_string) print(' Port: ', low_port.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 acquisition. dio_device.d_in_scan(low_port, hi_port, samples_per_channel, rate, scan_options, flags, data) try: while True: try: status, transfer_status = dio_device.d_in_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') for i in range(number_of_ports): clear_eol() print('port =', port_types[i].name, ': ', '{:d}'.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: dio_device.d_in_scan_stop() if daq_device.is_connected(): daq_device.disconnect() daq_device.release()
def main(): daq_device = None interface_type = InterfaceType.USB descriptor_index = 0 port_types_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 DioDevice object and verify that it is valid. dio_device = daq_device.get_dio_device() if dio_device is None: raise Exception( 'Error: The DAQ device does not support digital input') # 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 port types for the device(AUXPORT, FIRSTPORTA, ...) dio_info = dio_device.get_info() port_types = dio_info.get_port_types() if port_types_index >= len(port_types): port_types_index = len(port_types) - 1 port_to_read = port_types[port_types_index] # Configure the port for input. port_info = dio_info.get_port_info(port_to_read) if (port_info.port_io_type == DigitalPortIoType.IO or port_info.port_io_type == DigitalPortIoType.BITIO): dio_device.d_config_port(port_to_read, DigitalDirection.INPUT) print('\n', descriptor.dev_string, ' ready', sep='') print(' Function demonstrated: dio_device.d_in()') print(' Port: ', port_to_read.name) try: input('\nHit ENTER to continue\n') except (NameError, SyntaxError): pass system('clear') try: while True: try: reset_cursor() print('Please enter CTRL + C to terminate the process\n') print('Active DAQ device: ', descriptor.dev_string, ' (', descriptor.unique_id, ')\n', sep='') # Read the first port. data = dio_device.d_in(port_to_read) clear_eol() print('Port(', port_to_read.name, ') Data: ', data) sleep(0.1) except (ValueError, NameError, SyntaxError): break except KeyboardInterrupt: pass except Exception as e: print('\n', e) finally: if daq_device: 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()