def run_example(): board_num = 0 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return channel = 0 ao_props = AnalogOutputProps(board_num) if ao_props.num_chans < 1: util.print_unsupported_example(board_num) return ao_range = ao_props.available_ranges[0] data_value = ao_range.range_max / 2 try: print("Outputting " + str(data_value) + " Volts to channel " + str(channel) + ".") # Send the value to the device (optional parameter omitted) ul.v_out(board_num, channel, ao_range, data_value) except ULError as e: util.print_ul_error(e) finally: if use_device_detection: ul.release_daq_device(board_num)
def config_first_detected_device(board_num, dev_id_list=None): """Adds the first available device to the UL. If a types_list is specified, the first available device in the types list will be add to the UL. Parameters ---------- board_num : int The board number to assign to the board when configuring the device. dev_id_list : list[int], optional A list of product IDs used to filter the results. Default is None. See UL documentation for device IDs. """ ul.ignore_instacal() devices = ul.get_daq_device_inventory(InterfaceType.ANY) if not devices: raise Exception('Error: No DAQ devices found') print('Found', len(devices), 'DAQ device(s):') for device in devices: print(' ', device.product_name, ' (', device.unique_id, ') - ', 'Device ID = ', device.product_id, sep='') device = devices[0] if dev_id_list: device = next((device for device in devices if device.product_id in dev_id_list), None) if not device: err_str = 'Error: No DAQ device found in device ID list: ' err_str += ','.join(str(dev_id) for dev_id in dev_id_list) raise Exception(err_str) # Add the first DAQ device to the UL with the specified board number ul.create_daq_device(board_num, device)
def run_example(): board_num = 0 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return ctr_props = CounterProps(board_num) if ctr_props.num_chans < 1: util.print_unsupported_example(board_num) return # Use the first counter channel on the board (some boards start channel # numbering at 1 instead of 0, CounterProps are used here to find the # first one). counter_num = ctr_props.counter_info[0].channel_num try: # Get a value from the device value = ul.c_in_32(board_num, counter_num) # Display the value print("Counter Value: " + str(value)) except ULError as e: util.print_ul_error(e) finally: if use_device_detection: ul.release_daq_device(board_num)
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 run_example(): board_num = 0 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return channel = 0 ai_props = AnalogInputProps(board_num) if ai_props.num_ti_chans < 1: util.print_unsupported_example(board_num) return try: # Get the value from the device (optional parameters omitted) value = ul.t_in(board_num, channel, TempScale.CELSIUS) # Display the value print("Channel " + str(channel) + " Value (deg C): " + str(value)) except ULError as e: util.print_ul_error(e) finally: if use_device_detection: ul.release_daq_device(board_num)
def __init__(self, master): super(DaqDevDiscovery02, self).__init__(master) ul.ignore_instacal() self.board_num = 0 self.device_created = False self.create_widgets()
def configure_first_detected_device(self): ul.ignore_instacal() devices = ul.get_daq_device_inventory(InterfaceType.ANY) if not devices: raise ULError(ErrorCode.BADBOARD) # Add the first DAQ device to the UL with the specified board number ul.create_daq_device(self.board_num, devices[0])
def __init__(self, master): super(BatteryMonitor, self).__init__(master) self.board_num = 0 ul.ignore_instacal() if self.discover_devices(): self.create_widgets() else: self.create_unsupported_widgets(self.board_num)
def __init__(self, master): super(DaqDevDiscovery01, self).__init__(master) self.board_num = 0 self.device_created = False # Tell the UL to ignore any boards configured in InstaCal ul.ignore_instacal() self.create_widgets()
def run_example(): board_num = 0 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return ctr_props = CounterProps(board_num) # Find a pulse timer channel on the board first_chan = next( (channel for channel in ctr_props.counter_info if channel.type == CounterChannelType.CTRPULSE), None) if first_chan == None: util.print_unsupported_example(board_num) return timer_num = first_chan.channel_num frequency = 100 duty_cycle = 0.5 try: # 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 " + str(actual_frequency) + " Hz with a duty cycle of " + str(actual_duty_cycle) + " to pulse timer channel " + str(timer_num) + ".") # Wait for 5 seconds time.sleep(5) # Stop the pulse timer output ul.pulse_out_stop(board_num, timer_num) print("Timer output stopped.") except ULError as e: util.print_ul_error(e) finally: if use_device_detection: ul.release_daq_device(board_num)
def run_example(): board_num = 0 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return digital_props = DigitalProps(board_num) # Find the first port that supports input, defaulting to None # if one is not found. port = next( (port for port in digital_props.port_info if port.supports_output), None) if port == None: util.print_unsupported_example(board_num) return try: # 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 " + str(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 " + str(bit_num) + " to " + str(bit_value) + ".") # Output the value to the bit ul.d_bit_out(board_num, port.type, bit_num, bit_value) except ULError as e: util.print_ul_error(e) finally: if use_device_detection: ul.release_daq_device(board_num)
def discoverBoards(self): ul.ignore_instacal() self.inventory = ul.get_daq_device_inventory(InterfaceType.ANY) if len(self.inventory)>0: for device in self.inventory: self.board_cb.addItem(device.product_name + "(" + device.unique_id + ")") else: self.board_cb.addItem("Board not found") self.board_cb.setDisabled(True) self.viswnd_cb.setDisabled(True) self.chan_le.setDisabled(True) self.range_cb.setDisabled(True) self.samrate_cb.setDisabled(True) self.resp_check.setDisabled(True) self.ok_push.setDisabled(True)
def __init__(self, use_device_detection=True): self.use_device_detection = use_device_detection self.board_num = 0 # board initially uninitalized self.Init = False if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(self.board_num): print("Could not find device.") return self.channel = 0 ai_props = AnalogInputProps(self.board_num) if ai_props.num_ti_chans < 1: util.print_unsupported_example(self.board_num) return #if we made it this far, we gucci self.isInit = True return
def __init__(self, boardnum): #number the pins #numbering on the physical board goes like this: #pins 0-7 are port A #pins 8-15 are port B #pins 16-23 are port C #for physical pin layout, see USB-DIO24/37 manual self.RW_Pin = 12 self.CS_Pin = 11 self.RESET_Pin = 10 self.Control_Pins = [8, 9] self.DB_Pins = [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19] #current values of each channel self.DB_values = [0, 0, 0, 0] #initialize the DIO board #ignore instacal because it does magic and i don't like magic ul.ignore_instacal() #see what devices are available x = ul.get_daq_device_inventory(1) #assign a board number self.board_num = boardnum #activate the DIO board ul.create_daq_device(self.board_num, x[0]) #get info that we need about the board/ports dig_props = DigitalProps(self.board_num) self.port = dig_props.port_info #activate the output pins that we'll need #there are 4 ports for this device #port 0 and 1 are 8 bits each #ports 2 and 3 are 4 bits each ul.d_config_port(self.board_num, self.port[0].type, DigitalIODirection.OUT) ul.d_config_port(self.board_num, self.port[1].type, DigitalIODirection.OUT) ul.d_config_port(self.board_num, self.port[2].type, DigitalIODirection.OUT) #set all channels to 0 upon initialization self.write(0, 0) self.write(1, 0) self.write(2, 0) self.write(3, 0)
def __init__(self, master): super(DaqDeviceScan, self).__init__(master) self.board_num = 0 self.ai_props = aiProps(self.board_num) self.device_created = False ul.ignore_instacal() self.create_widgets() self.running = False
def run_example(): board_num = 0 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return channel = 0 ai_props = AnalogInputProps(board_num) if ai_props.num_ai_chans < 1: util.print_unsupported_example(board_num) return ai_range = ai_props.available_ranges[0] try: # Get a value from the device if ai_props.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: " + str(value)) # Display the engineering value print("Engineering Value: " + '{:.3f}'.format(eng_units_value)) except ULError as e: util.print_ul_error(e) finally: if use_device_detection: ul.release_daq_device(board_num)
def run_example(): board_num = 0 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return digital_props = DigitalProps(board_num) # Find the first port that supports input, defaulting to None # if one is not found. port = next( (port for port in digital_props.port_info if port.supports_input), None) if port == None: util.print_unsupported_example(board_num) return try: # If the port is configurable, configure it for input. if port.is_port_configurable: ul.d_config_port(board_num, port.type, DigitalIODirection.IN) # Get a value from the digital port port_value = ul.d_in(board_num, port.type) # Get a value from the first digital bit bit_num = 0 bit_value = ul.d_bit_in(board_num, port.type, bit_num) # Display the port value print(port.type.name + " Value: " + str(port_value)) # Display the bit value print("Bit " + str(bit_num) + " Value: " + str(bit_value)) except ULError as e: util.print_ul_error(e) finally: if use_device_detection: ul.release_daq_device(board_num)
import serial, time, xlsxwriter from mcculw import ul from mcculw.enums import InterfaceType from mcculw.ul import ULError ser0 = serial.Serial('COM6', 115200, timeout=0) # UART0 ser1 = serial.Serial('COM3', 115200, timeout=0) # PLC UART cmd0 = 'accel_get_temp\n' cmd1 = 'adc_sm 0 2400000 0x40 0\n' board_num = 0 # for USB-TC channel0, channel1, channel2, channel3 = 0, 1, 2, 3 ul.ignore_instacal() devices = ul.get_daq_device_inventory(InterfaceType.USB, 1) print("Found device: " + devices[0].product_name) ul.create_daq_device(board_num, devices[0]) t_start, t_stop, t_step, t_soak = -40, 85, 5, 10 # start, stop temp... t_num = (t_stop - t_start) / t_step wb = xlsxwriter.Workbook('results.xlsx') sheet1 = wb.add_worksheet('results') runs = 1000 for i in range(runs): # add chamber control time.sleep(10) ser0.write(cmd0.encode()) ser1.write(cmd1.encode()) time.sleep(0.5) s0 = ser0.read(100).decode('utf-8')
def init(): # Create device object based on USB-202 ul.ignore_instacal() device = ul.get_daq_device_inventory(InterfaceType.ANY) ul.create_daq_device(BOARD_NUM, device[0])
def __init__(self, biprange, srate): super(DaqThread, self).__init__() # QObject.__init__(self) self.biprange = biprange # self.mutex = QMutex() self.rate = srate self.chunksize = 1024 # int(self.rate/1000) self.board_num = 1 self.file_ls = [] self.chunk_ls = [] self.chunk_np = np.zeros(self.chunksize) ######## # The size of the UL buffer to create, in seconds buffer_size_seconds = 15 # The number of buffers to write num_buffers_to_write = 8 # VER si eliminar o dejar para que confirme si recibe el device y # lo libere al final, esta bueno para no tener que abrir instacal self.use_device_detection = False # Cambiar a True en version final if self.use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(self.board_num): QtGui.QMessageBox.information( self, "Connect device", "Could not find device") # check message box return ai_props = AnalogInputProps(self.board_num) # In case more channels are added in the future self.low_chan = 0 self.high_chan = 0 num_chans = self.high_chan - self.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(self.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_props.continuous_requires_packet_size_multiple: packet_size = ai_props.packet_size remainder = points_per_channel % packet_size if remainder != 0: points_per_channel += packet_size - remainder # In case more channels are added in the future self.ul_buffer_count = points_per_channel * num_chans # Pick range from settings Combobox self.ai_range = ai_props.available_ranges[self.biprange] # Write the UL buffer to the file num_buffers_to_write times self.points_to_write = self.ul_buffer_count * num_buffers_to_write # # When handling the buffer, we will read 1/10 of the buffer at a time self.write_chunk_size = self.chunksize # int(self.ul_buffer_count / 10) self.scan_options = (ScanOptions.BACKGROUND | ScanOptions.CONTINUOUS) self.memhandle = ul.win_buf_alloc(self.ul_buffer_count) # Allocate an array of doubles temporary storage of the data self.write_chunk_array = (c_ushort * self.write_chunk_size)() # Check if the buffer was successfully allocated if not self.memhandle: QtGui.QMessageBox.critical(self, "No Buffer", "Failed to allocate memory.") print("No Buffer") ul.stop_background(self.board_num, FunctionType.AIFUNCTION) return
def run_example(): board_num = 0 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return ao_props = AnalogOutputProps(board_num) if ao_props.num_chans < 1: util.print_unsupported_example(board_num) return low_chan = 0 high_chan = min(3, ao_props.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_props.available_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 = util.memhandle_as_ctypes_array(memhandle) # Check if the buffer was successfully allocated if not memhandle: print("Failed to allocate memory.") return 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 " + str(ch_num) + " Output Signal Frequency: " + str(frequencies[ch_num - low_chan])) try: # 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 time.sleep(0.5) status, _, _ = ul.get_status(board_num, FunctionType.AOFUNCTION) print("") print("Scan completed successfully.") except ULError as e: util.print_ul_error(e) finally: # Free the buffer in a finally block to prevent errors from causing # a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def run_example(): board_num = 0 rate = 100 points_per_channel = 1000 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return ai_props = AnalogInputProps(board_num) if ai_props.num_ai_chans < 1: util.print_unsupported_example(board_num) return low_chan = 0 high_chan = min(3, ai_props.num_ai_chans - 1) num_chans = high_chan - low_chan + 1 total_count = points_per_channel * num_chans ai_range = ai_props.available_ranges[0] scan_options = ScanOptions.BACKGROUND if ScanOptions.SCALEDATA in ai_props.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 = util.memhandle_as_ctypes_array_scaled(memhandle) elif ai_props.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 = util.memhandle_as_ctypes_array(memhandle) 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 = util.memhandle_as_ctypes_array_32(memhandle) # 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: print("Failed to allocate memory.") return try: # Start the scan ul.a_in_scan(board_num, low_chan, high_chan, total_count, rate, ai_range, memhandle, scan_options) # Create a format string that aligns the data in columns row_format = "{:>12}" * num_chans # Print the channel name headers labels = [] for ch_num in range(low_chan, high_chan + 1): labels.append("CH" + str(ch_num)) print(row_format.format(*labels)) # Start updating the displayed values status, curr_count, curr_index = ul.get_status(board_num, FunctionType.AIFUNCTION) while status != Status.IDLE: # Make sure a data point is available for display. if curr_count > 0: # curr_index points to the start of the last completed # channel scan that was transferred between the board and # the data buffer. Display the latest value for each # channel. display_data = [] for data_index in range(curr_index, curr_index + 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]) display_data.append('{:.3f}'.format(eng_value)) print(row_format.format(*display_data)) # Wait a while before adding more values to the display. time.sleep(0.5) status, curr_count, curr_index = ul.get_status( board_num, FunctionType.AIFUNCTION) # Stop the background operation (this is required even if the # scan completes successfully) ul.stop_background(board_num, FunctionType.AIFUNCTION) print("Scan completed successfully.") except ULError as e: util.print_ul_error(e) finally: # Free the buffer in a finally block to prevent errors from causing # a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def mc_init(board_num): #detect devices ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.")
def run_example(): board_num = 0 rate = 100 points_per_channel = 10 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return ai_props = AnalogInputProps(board_num) if ai_props.num_ai_chans < 1: util.print_unsupported_example(board_num) return low_chan = 0 high_chan = min(3, ai_props.num_ai_chans - 1) num_chans = high_chan - low_chan + 1 total_count = points_per_channel * num_chans ai_range = ai_props.available_ranges[0] scan_options = ScanOptions.FOREGROUND if ScanOptions.SCALEDATA in ai_props.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 = util.memhandle_as_ctypes_array_scaled(memhandle) elif ai_props.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 = util.memhandle_as_ctypes_array(memhandle) 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 = util.memhandle_as_ctypes_array_32(memhandle) # 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: print("Failed to allocate memory.") return try: # 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 = [] labels.append("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 ULError as e: util.print_ul_error(e) finally: # Free the buffer in a finally block to prevent errors from causing # a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def run_example(): board_num = 0 rate = 100 points_per_channel = 100 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device_of_type( board_num, supported_pids): print("Could not find a supported device.") return 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 = util.memhandle_as_ctypes_array_scaled(memhandle) # 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: print("Failed to allocate memory.") return try: # 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 = [] labels.append("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 ULError as e: util.print_ul_error(e) finally: # Free the buffer in a finally block to prevent errors from causing # a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def run_example(): board_num = 0 low_chan = 0 high_chan = 3 num_chans = high_chan - low_chan + 1 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device_of_type( board_num, supported_pids): print("Could not find a supported device.") return 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 = util.memhandle_as_ctypes_array_scaled(memhandle) # 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: print("Failed to allocate memory.") return try: # 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 = [] labels.append("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): display_data.append( '{:.3f}'.format(ctypes_array[data_index])) data_index += 1 # Print this row print(row_format.format(*display_data)) except ULError as e: util.print_ul_error(e) finally: # Free the buffer in a finally block to prevent errors from causing # a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def run_example(): board_num = 0 rate = 100 file_name = 'scan_data.csv' # 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 if use_device_detection: ul.ignore_instacal() if not util.config_first_detected_device(board_num): print("Could not find device.") return ai_props = AnalogInputProps(board_num) if (ai_props.num_ai_chans < 1 or not ScanOptions.SCALEDATA in ai_props.supported_scan_options): util.print_unsupported_example(board_num) return low_chan = 0 high_chan = min(3, ai_props.num_ai_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_props.continuous_requires_packet_size_multiple: packet_size = ai_props.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_props.available_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: print("Failed to allocate memory.") return try: # 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. time.sleep(0.1) ul.stop_background(board_num, FunctionType.AIFUNCTION) except ULError as e: util.print_ul_error(e) finally: print('Done') # Free the buffer in a finally block to prevent errors from causing # a memory leak. ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)
def run(): DaqDeviceScan(master=tk.Tk()).mainloop() board_num = 0 rate = 1000 points_per_channel = 30 if use_device_detection: ul.ignore_instacal() if not configDevice(board_num): print("Gerät konnte nicht gefunden werden!") return ai_props = aiProps(board_num) low_channel = 0 high_channel = min(7, ai_props.num_ai_chans - 1) num_channels = high_channel - low_channel + 1 total_amount = points_per_channel * num_channels ai_range = ai_props.available_ranges[0] scan_opt = ScanOptions.FOREGROUND if ScanOptions.SCALEDATA in ai_props.supported_scan_options: scan_opt |= ScanOptions.SCALEDATA memhandle = ul.scaled_win_buf_alloc(total_amount) c_array = memhandle_as_ctypes_array_scaled(memhandle) elif ai_props.resolution <= 16: memhandle = ul.win_buf_alloc(total_amount) c_array = memhandle_as_ctypes_array(memhandle) else: memhandle = ul.win_buf_alloc_32(memhandle) if not memhandle: print("Speicher konnte nicht allokiert werden") restart = False try: wr = csv.writer(open("test5.csv","w"),delimiter=";") ul.a_in_scan(board_num, low_channel, high_channel, total_amount, rate, ai_range, memhandle, scan_opt) print("Scan erfolgreich!") print("Daten: ") test = ul.a_in_32(board_num, 0, ai_range, scan_opt) test = ul.to_eng_units_32(board_num, ai_range, test) print("test value:") print(test) row_format = "{:>5}" + "{:>10}" * num_channels labels = [] labels.append("Index") for ch_num in range(low_channel, high_channel + 1): labels.append("CH" + str(ch_num)) print(row_format.format(*labels)) data_index = 0 for index in range(points_per_channel): display_data = [index] for _ in range(num_channels): if ScanOptions.SCALEDATA in scan_opt: eng_value = c_array[data_index] else: eng_value = ul.to_eng_units( board_num, ai_range, c_array[data_index]) data_index += 1 display_data.append('{:.3f}'.format(eng_value)) wr.writerow(display_data) print(row_format.format(*display_data)) except ULError as e: pass finally: ul.win_buf_free(memhandle) if use_device_detection: ul.release_daq_device(board_num)