def discover_device(self): host = self.host_entry.get() port = self.get_port() timeout_ms = 5000 try: # Release any previously created device if self.device_created: ul.release_daq_device(self.board_num) self.device_created = False descriptor = ul.get_net_device_descriptor(host, port, timeout_ms) if descriptor is not None: # Create the DAQ device from the descriptor ul.create_daq_device(self.board_num, descriptor) self.device_created = True self.status_label["text"] = "DAQ Device Discovered" self.flash_led_button["state"] = "normal" self.device_name_label["text"] = descriptor.product_name self.device_id_label["text"] = descriptor.unique_id else: self.status_label["text"] = "No Device Discovered" self.flash_led_button["state"] = "disabled" self.device_name_label["text"] = "" self.device_id_label["text"] = "" except ULError as e: self.status_label["text"] = "No Device Discovered" self.flash_led_button["state"] = "disabled" self.device_name_label["text"] = "" self.device_id_label["text"] = "" show_ul_error(e)
def start_scan(self): rate = 100 count = 1000 # Allocate a buffer for the scan self.memhandle = ul.win_buf_alloc(count) # Check if the buffer was successfully allocated if not self.memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.set_ui_idle_state() return try: # Configure the port (if necessary) if self.port.is_port_configurable: ul.d_config_port(self.board_num, self.port.type, DigitalIODirection.IN) # Run the scan ul.d_in_scan(self.board_num, self.port.type, count, rate, self.memhandle, ScanOptions.BACKGROUND) except ULError as e: show_ul_error(e) self.set_ui_idle_state() return # 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. self.ctypes_array = cast(self.memhandle, POINTER(c_ushort)) # Start updating the displayed values self.update_displayed_values()
def update_values(self): try: # Get the values from the device (optional parameters omitted) err_code, data_array = ul.t_in_scan(self.board_num, self.low_chan, self.high_chan, TempScale.CELSIUS) # Check err_code for OUTOFRANGE or OPENCONNECTION. All other # error codes will raise a ULError and are checked by the except # clause. if err_code == ErrorCode.OUTOFRANGE: self.warning_label["text"] = ( "A thermocouple input is out of range.") elif err_code == ErrorCode.OPENCONNECTION: self.warning_label["text"] = ( "A thermocouple input has an open connection.") else: self.warning_label["text"] = "" self.display_values(data_array) # Call this method again until the stop button is pressed (or an # error occurs) if self.running: self.after(100, self.update_values) except ULError as e: self.stop() show_ul_error(e)
def start_scan(self): # Build the data array points_per_channel = 1000 rate = 1000 num_points = self.num_chans * points_per_channel scan_options = ScanOptions.BACKGROUND | ScanOptions.CONTINUOUS ao_range = self.ao_info.supported_ranges[0] self.memhandle = ul.win_buf_alloc(num_points) # Check if the buffer was successfully allocated if not self.memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.start_button["state"] = tk.NORMAL return try: data_array = cast(self.memhandle, POINTER(c_ushort)) freq = self.add_example_data(data_array, ao_range, rate, points_per_channel) self.freq_label["text"] = str(freq) + "Hz" ul.daq_out_scan(self.board_num, self.chan_list, self.chan_type_list, self.gain_list, self.num_chans, rate, num_points, self.memhandle, scan_options) # Start updating the displayed values self.update_displayed_values() except ULError as e: show_ul_error(e) self.set_ui_idle_state() return
def exit(self): # Set the port to 0 at exit try: ul.d_out(self.board_num, self.port.type, 0) except ULError as e: show_ul_error(e) self.master.destroy()
def update_value(self): channel = self.get_channel_num() ai_range = self.get_range() try: # Get a value from the device if self.ai_info.resolution <= 16: # Use the v_in method for devices with a resolution <= 16 # (optional parameter omitted) value = ul.v_in(self.board_num, channel, ai_range) else: # Use the v_in_32 method for devices with a resolution > 16 # (optional parameter omitted) value = ul.v_in_32(self.board_num, channel, ai_range) # Display the raw value self.value_label["text"] = '{:.3f}'.format(value) # Call this method again until the stop button is pressed (or an # error occurs) if self.running: self.after(100, self.update_value) except ULError as e: self.stop() show_ul_error(e)
def update_value(self): channel = self.get_channel_num() ai_range = self.ai_info.supported_ranges[0] try: # Get a value from the device if self.ai_info.resolution <= 16: # Use the a_in method for devices with a resolution <= 16 value = ul.a_in(self.board_num, channel, ai_range) # Convert the raw value to engineering units eng_units_value = ul.to_eng_units(self.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(self.board_num, channel, ai_range) # Convert the raw value to engineering units eng_units_value = ul.to_eng_units_32(self.board_num, ai_range, value) # Display the raw value self.value_label["text"] = str(value) # Display the engineering value self.eng_value_label["text"] = '{:.3f}'.format(eng_units_value) # Call this method again until the stop button is pressed (or an # error occurs) if self.running: self.after(100, self.update_value) except ULError as e: self.stop() show_ul_error(e)
def data_value_changed(self, *args): try: # Get the data value data_value = self.get_data_value() # Send the value to the device ul.d_out(self.board_num, self.port.type, data_value) except ULError as e: show_ul_error(e)
def bit_checkbutton_changed(self, bit_num): try: # Get the value from the checkbutton bit_value = self.bit_checkbutton_vars[bit_num].get() # Output the value to the board ul.d_bit_out(self.board_num, self.port.type, bit_num, bit_value) except ULError as e: show_ul_error(e)
def exit(self): # Stop all the timers at exit if self.first_chan_num != -1: for chan_num in range(self.first_chan_num, self.last_chan_num + 1): try: ul.timer_out_stop(self.board_num, chan_num) except ULError as e: show_ul_error(e) self.master.destroy()
def update_value(self): channel = self.get_channel_num() ao_range = self.ao_info.supported_ranges[0] data_value = self.get_data_value() try: # Send the value to the device (optional parameter omitted) ul.v_out(self.board_num, channel, ao_range, data_value) except ULError as e: show_ul_error(e)
def start_scan(self): rate = 100 points_per_channel = 10 total_count = points_per_channel * self.num_chans # Allocate a buffer for the scan memhandle = ul.win_buf_alloc(total_count) # Check if the buffer was successfully allocated if not memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.start_button["state"] = tk.NORMAL return try: # Configure the digital port for input ul.d_config_port(self.board_num, DigitalPortType.FIRSTPORTA, DigitalIODirection.IN) # Configure the counter channel ul.c_config_scan(self.board_num, 0, CounterMode.STOP_AT_MAX, CounterDebounceTime.DEBOUNCE_NONE, 0, CounterEdgeDetection.RISING_EDGE, CounterTickSize.TICK20PT83ns, 0) # Run the scan ul.daq_in_scan(self.board_num, self.chan_list, self.chan_type_list, self.gain_list, self.num_chans, rate, 0, total_count, memhandle, 0) # Convert the TC values (optional parameter omitted) err, temp_data_array = ul.get_tc_values(self.board_num, self.chan_list, self.chan_type_list, self.num_chans, memhandle, 0, points_per_channel, TempScale.CELSIUS) if err == ErrorCode.OUTOFRANGE: messagebox.showwarning("Warning", "Temperature data is out of range") # Cast the memhandle to a ctypes pointer # Note: the ctypes array will only be valid until win_buf_free # is called. array = cast(memhandle, POINTER(c_ushort)) # Display the values self.display_values(array, temp_data_array, total_count) except ULError as e: show_ul_error(e) finally: # Free the allocated memory ul.win_buf_free(memhandle) self.start_button["state"] = tk.NORMAL
def scan_loop(self): rate = 100 points_per_channel = 10 low_chan = 0 # Ignored by a_in_scan when queue is enabled high_chan = 3 # Ignored by a_in_scan when queue is enabled num_channels = high_chan - low_chan + 1 total_count = points_per_channel * num_channels # Ignored by a_in_scan when queue is enabled range_ = self.ai_info.supported_ranges[0] # Allocate a buffer for the scan if self.ai_info.resolution <= 16: # Use the win_buf_alloc method for devices with a resolution <= 16 memhandle = ul.win_buf_alloc(total_count) else: # Use the win_buf_alloc_32 method for devices with a resolution > # 16 memhandle = ul.win_buf_alloc_32(total_count) # Check if the buffer was successfully allocated if not memhandle: messagebox.showerror("Error", "Failed to allocate memory") return try: # Run the scan ul.a_in_scan(self.board_num, low_chan, high_chan, total_count, rate, range_, memhandle, 0) # Convert the memhandle to a ctypes array # Note: the ctypes array will only be valid until 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. if self.ai_info.resolution <= 16: # Use the memhandle_as_ctypes_array method for devices with a # resolution <= 16 array = cast(memhandle, POINTER(c_ushort)) else: # Use the memhandle_as_ctypes_array_32 method for devices with # a resolution > 16 array = cast(memhandle, POINTER(c_ulong)) # Display the values self.display_values(array, total_count) self.after(1000, self.scan_loop) except ULError as e: show_ul_error(e) finally: # Free the allocated memory ul.win_buf_free(memhandle)
def update_value(self): channel = self.get_channel_num() ao_range = self.ao_info.supported_ranges[0] data_value = self.get_data_value() raw_value = ul.from_eng_units(self.board_num, ao_range, data_value) try: ul.a_out(self.board_num, channel, ao_range, raw_value) except ULError as e: show_ul_error(e)
def update_output(self): try: timer_num = self.get_channel_num() frequency = self.get_frequency() actual_freq = ul.timer_out_start(self.board_num, timer_num, frequency) self.update_actual_values(actual_freq) except ULError as e: show_ul_error(e)
def err_code_changed(self, *args): try: err_code = int(self.err_code_variable.get()) except ValueError: err_code = 0 try: message = ul.get_err_msg(err_code) self.err_msg_label["text"] = message except ULError as e: show_ul_error(e)
def update_output(self): try: timer_num = self.get_channel_num() frequency = self.get_frequency() duty_cycle = self.get_duty_cycle() # Start the pulse output (optional parameters omitted) actual_freq, actual_duty_cycle, _ = ul.pulse_out_start( self.board_num, timer_num, frequency, duty_cycle) self.update_actual_values(actual_freq, actual_duty_cycle) except ULError as e: show_ul_error(e)
def start(self): self.running = True self.start_button["command"] = self.stop self.start_button["text"] = "Stop" try: # Clear the counter ul.c_clear(self.board_num, self.get_channel_num()) # Start updating the counter values self.update_value() except ULError as e: self.stop() show_ul_error(e)
def start_output_scan(self): # Build the data array self.output_low_chan = self.get_output_low_channel_num() self.output_high_chan = self.get_output_high_channel_num() self.num_output_chans = ( self.output_high_chan - self.output_low_chan + 1) if self.output_low_chan > self.output_high_chan: messagebox.showerror( "Error", "Low Channel Number must be greater than or equal to High " "Channel Number") self.set_output_ui_idle_state() return points_per_channel = 1000 rate = 1000 num_points = self.num_output_chans * points_per_channel scan_options = (ScanOptions.BACKGROUND | ScanOptions.CONTINUOUS | ScanOptions.SCALEDATA) ao_range = self.ao_info.supported_ranges[0] self.output_memhandle = ul.scaled_win_buf_alloc(num_points) # Check if the buffer was successfully allocated if not self.output_memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.output_start_button["state"] = tk.NORMAL return try: data_array = cast(self.output_memhandle, POINTER(c_double)) frequencies = self.add_output_example_data( data_array, ao_range, self.num_output_chans, rate, points_per_channel) self.recreate_freq_frame() self.display_output_signal_info(frequencies) ul.a_out_scan( self.board_num, self.output_low_chan, self.output_high_chan, num_points, rate, ao_range, self.output_memhandle, scan_options) # Start updating the displayed values self.update_output_displayed_values() except ULError as e: show_ul_error(e) self.set_output_ui_idle_state() return
def start(self): self.running = True self.start_button["command"] = self.stop self.start_button["text"] = "Stop" try: ul.d_config_bit(self.board_num, self.port.type, self.port.first_bit, DigitalIODirection.IN) except ULError as e: self.stop() show_ul_error(e) return self.update_value()
def start_scan(self): rate = 100 points_per_channel = 100 total_count = points_per_channel * self.num_chans scan_options = (ScanOptions.BACKGROUND | ScanOptions.CONTINUOUS | ScanOptions.EXTTRIGGER) # Allocate a buffer for the scan self.memhandle = ul.win_buf_alloc(total_count) # Check if the buffer was successfully allocated if not self.memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.start_button["state"] = tk.NORMAL return try: # Set the start trigger settings ul.daq_set_trigger(self.board_num, TriggerSource.ANALOG_SW, TriggerSensitivity.RISING_EDGE, self.chan_list[0], self.chan_type_list[0], self.gain_list[0], 2, 0, TriggerEvent.START) # Set the stop trigger settings ul.daq_set_trigger(self.board_num, TriggerSource.COUNTER, TriggerSensitivity.ABOVE_LEVEL, self.chan_list[2], self.chan_type_list[2], self.gain_list[2], 2, 0, TriggerEvent.START) # Run the scan ul.daq_in_scan(self.board_num, self.chan_list, self.chan_type_list, self.gain_list, self.num_chans, rate, 0, total_count, self.memhandle, scan_options) # Cast the memhandle to a ctypes pointer # Note: the ctypes array will only be valid until 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. self.array = cast(self.memhandle, POINTER(c_ushort)) except ULError as e: # Free the allocated memory ul.win_buf_free(self.memhandle) show_ul_error(e) return # Start updating the displayed values self.update_displayed_values()
def start_scan(self): low_chan = self.get_low_channel_num() high_chan = self.get_high_channel_num() if low_chan > high_chan: messagebox.showerror( "Error", "Low Channel Number must be greater than or equal to High " "Channel Number") self.start_button["state"] = tk.NORMAL return rate = 100 points_per_channel = 10 num_channels = high_chan - low_chan + 1 total_count = points_per_channel * num_channels range_ = self.ai_info.supported_ranges[0] # Allocate a buffer for the scan memhandle = ul.scaled_win_buf_alloc(total_count) # Check if the buffer was successfully allocated if not memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.start_button["state"] = tk.NORMAL return # Convert the memhandle to a ctypes array # Note: the ctypes array will only be valid until win_buf_free # is called. # A copy of the buffer can be created using scaled_win_buf_to_array # before the memory is freed. The copy can be used at any time. array = cast(memhandle, POINTER(c_double)) try: # Run the scan ul.a_in_scan(self.board_num, low_chan, high_chan, total_count, rate, range_, memhandle, ScanOptions.SCALEDATA) # Display the values self.display_values(array, total_count, low_chan, high_chan) except ULError as e: show_ul_error(e) finally: # Free the allocated memory ul.win_buf_free(memhandle) self.start_button["state"] = tk.NORMAL
def update_value(self): try: # Get a value from the device value = ul.d_bit_in(self.board_num, self.port.type, self.port.first_bit) # Display the value self.value_label["text"] = str(value) # Call this method again until the stop button is pressed (or an # error occurs) if self.running: self.after(100, self.update_value) except ULError as e: self.stop() show_ul_error(e)
def start_scan(self): rate = 100 total_count = 10 # Allocate a buffer for the scan memhandle = ul.win_buf_alloc_32(total_count) # Check if the buffer was successfully allocated if not memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.start_button["state"] = tk.NORMAL return try: mode = CounterMode.ENCODER + CounterMode.ENCODER_MODE_X1 \ + CounterMode.ENCODER_MODE_CLEAR_ON_Z_ON debounce_time = CounterDebounceTime.DEBOUNCE_NONE debounce_mode = 0 edge_detection = CounterEdgeDetection.RISING_EDGE tick_size = CounterTickSize.TICK20PT83ns mapped_channel = 2 # Configure the first counter channel for Encoder mode ul.c_config_scan(self.board_num, self.chan_num, mode, debounce_time, debounce_mode, edge_detection, tick_size, mapped_channel) # Run the scan ul.c_in_scan(self.board_num, self.chan_num, self.chan_num, total_count, rate, memhandle, 0) # Convert the memhandle to a ctypes array # Note: the ctypes array will only be valid until win_buf_free # is called. # A copy of the buffer can be created using win_buf_to_array_32 # before the memory is freed. The copy can be used at any time. array = cast(memhandle, POINTER(c_ulong)) # Display the values self.display_values(array, total_count) except ULError as e: show_ul_error(e) finally: # Free the allocated memory ul.win_buf_free(memhandle) self.start_button["state"] = tk.NORMAL
def start_scan(self): rate = 100 points_per_channel = 100 total_count = points_per_channel * self.num_chans scan_options = ScanOptions.BACKGROUND | ScanOptions.CONTINUOUS # Allocate a buffer for the scan if self.resolution <= 16: self.memhandle = ul.win_buf_alloc(total_count) else: self.memhandle = ul.win_buf_alloc_32(total_count) # Check if the buffer was successfully allocated if not self.memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.start_button["state"] = tk.NORMAL return try: # Run the scan ul.daq_in_scan(self.board_num, self.chan_list, self.chan_type_list, self.gain_list, self.num_chans, rate, 0, total_count, self.memhandle, scan_options) # Cast the memhandle to a ctypes pointer # Note: the ctypes array will only be valid until 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. if self.resolution <= 16: # Use the memhandle_as_ctypes_array method for devices with a # resolution <= 16 self.array = cast(self.memhandle, POINTER(c_ushort)) else: # Use the memhandle_as_ctypes_array_32 method for devices with a # resolution > 16 self.array = cast(self.memhandle, POINTER(c_ulong)) except ULError as e: # Free the allocated memory ul.win_buf_free(self.memhandle) show_ul_error(e) return # Start updating the displayed values self.update_displayed_values()
def update_value(self): channel = self.get_channel_num() try: # Get a value from the device value = ul.t_in(self.board_num, channel, TempScale.CELSIUS) # Display the raw value self.value_label["text"] = '{:.3f}'.format(value) # Call this method again until the stop button is pressed (or an # error occurs) if self.running: self.after(100, self.update_value) except ULError as e: self.stop() show_ul_error(e)
def update_value(self): channel = self.get_channel_num() try: # Get a value from the device value = ul.c_in_32(self.board_num, channel) # Display the value self.value_label["text"] = str(value) # Call this method again until the stop button is pressed (or an # error occurs) if self.running: self.after(100, self.update_value) except ULError as e: self.stop() show_ul_error(e)
def update_value(self): try: # Display the bit values first_bit = self.port.first_bit for bit_num in range(first_bit, first_bit + min(self.port.num_bits, 8)): # Get a value from the device value = ul.d_bit_in(self.board_num, self.port.type, bit_num) # Display it self.bit_value_labels[bit_num]["text"] = str(value) # Call this method again until the stop button is pressed (or an # error occurs) if self.running: self.after(100, self.update_value) except ULError as e: self.stop() show_ul_error(e)
def start_scan(self): rate = 100 points_per_channel = 100 total_count = points_per_channel * self.num_chans scan_options = ScanOptions.BACKGROUND | ScanOptions.CONTINUOUS # Allocate a buffer for the scan self.memhandle = ul.win_buf_alloc(total_count) # Check if the buffer was successfully allocated if not self.memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.start_button["state"] = tk.NORMAL return try: # Configure the setpoints ul.daq_set_setpoints(self.board_num, self.limit_a_list, self.limit_b_list, self.setpoint_flags_list, self.setpoint_output_list, self.output_1_list, self.output_2_list, self.output_mask_1_list, self.output_mask_2_list, self.setpoint_count) # Run the scan ul.daq_in_scan(self.board_num, self.chan_list, self.chan_type_list, self.gain_list, self.num_chans, rate, 0, total_count, self.memhandle, scan_options) # Cast the memhandle to a ctypes pointer # Note: the ctypes array will only be valid until 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. self.array = cast(self.memhandle, POINTER(c_ushort)) except ULError as e: # Free the allocated memory ul.win_buf_free(self.memhandle) show_ul_error(e) return # Start updating the displayed values self.update_displayed_values()
def start_scan(self): rate = 390 total_count = 100 # Allocate a buffer for the scan memhandle = ul.win_buf_alloc_32(total_count) # Check if the buffer was successfully allocated if not memhandle: messagebox.showerror("Error", "Failed to allocate memory") self.start_button["state"] = tk.NORMAL return try: # Configure the counter ul.c_config_scan( self.board_num, self.chan_num, CounterMode.DECREMENT_ON, CounterDebounceTime.DEBOUNCE_NONE, 0, CounterEdgeDetection.FALLING_EDGE, CounterTickSize.TICK20PT83ns, 1) # Run the scan ul.c_in_scan( self.board_num, self.chan_num, self.chan_num, total_count, rate, memhandle, 0) # Convert the memhandle to a ctypes array # Note: the ctypes array will only be valid until win_buf_free # is called. # A copy of the buffer can be created using win_buf_to_array_32 # before the memory is freed. The copy can be used at any time. array = cast(memhandle, POINTER(c_ulong)) # Display the values self.display_values(array, total_count) except ULError as e: show_ul_error(e) finally: # Free the allocated memory ul.win_buf_free(memhandle) self.start_button["state"] = tk.NORMAL