def init_scan_channel_info(self): daqo_info = self.device_info.get_daqo_info() supported_channel_types = daqo_info.supported_channel_types # Add an analog output channel self.chan_list.append(0) self.chan_type_list.append(ChannelType.ANALOG) self.gain_list.append(self.ao_info.supported_ranges[0]) # Add a digital output channel if ChannelType.DIGITAL16 in supported_channel_types: chan_type = ChannelType.DIGITAL16 elif ChannelType.DIGITAL8 in supported_channel_types: chan_type = ChannelType.DIGITAL8 else: chan_type = ChannelType.DIGITAL dio_info = self.device_info.get_dio_info() port_info = dio_info.port_info[0] self.chan_list.append(port_info.type) self.chan_type_list.append(chan_type) self.gain_list.append(ULRange.NOTUSED) # Configure all digital ports for output for port in dio_info.port_info: if port.is_port_configurable: ul.d_config_port(self.board_num, port.type, DigitalIODirection.OUT)
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: self.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 = self.memhandle_as_ctypes_array(self.memhandle) # Start updating the displayed values self.update_displayed_values()
def init_scan_channel_info(self): self.num_chans = 2 self.chan_list = [] self.chan_type_list = [] self.gain_list = [] supported_channel_types = self.daqo_props.supported_channel_types # Add an analog output channel self.chan_list.append(0) self.chan_type_list.append(ChannelType.ANALOG) self.gain_list.append(self.ao_props.available_ranges[0]) # Add a digital output channel if ChannelType.DIGITAL16 in supported_channel_types: chan_type = ChannelType.DIGITAL16 elif ChannelType.DIGITAL8 in supported_channel_types: chan_type = ChannelType.DIGITAL8 else: chan_type = ChannelType.DIGITAL port_info = self.digital_props.port_info[0] self.chan_list.append(port_info.type) self.chan_type_list.append(chan_type) self.gain_list.append(ULRange.NOTUSED) # Configure all digital ports for output for port in self.digital_props.port_info: if port.is_port_configurable: ul.d_config_port(self.board_num, port.type, DigitalIODirection.OUT)
def mc_digital_out(board_num, bit_num, bit_value): digital_props = DigitalProps(board_num) port = next( (port for port in digital_props.port_info if port.supports_output), None) if port == None: util.print_unsupported_example(board_num) # 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 #CH0 --> normally high # bit_value = 1 ##set 5V to HIGH, power the sensor 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)
def __init__(self, master=None): super(ULDO01, self).__init__(master) master.protocol("WM_DELETE_WINDOW", self.exit) self.board_num = 0 self.digital_props = DigitalProps(self.board_num) # Find the first port that supports output, defaulting to None # if one is not found. self.port = next( (port for port in self.digital_props.port_info if port.supports_output), None) # If the port is configurable, configure it for output if self.port != None and self.port.is_port_configurable: try: ul.d_config_port(self.board_num, self.port.type, DigitalIODirection.OUT) except ULError as e: self.show_ul_error(e) self.running = False self.create_widgets()
def run_example(): # By default, the example detects and displays all available devices and # selects the first device listed. Use the dev_id_list variable to filter # detected devices by device ID (see UL documentation for device IDs). # If use_device_detection is set to False, the board_num variable needs to # match the desired board number configured with Instacal. use_device_detection = True dev_id_list = [] board_num = 0 try: if use_device_detection: config_first_detected_device(board_num, dev_id_list) daq_dev_info = DaqDeviceInfo(board_num) if not daq_dev_info.supports_digital_io: raise Exception('Error: The DAQ device does not support ' 'digital I/O') print('\nActive DAQ device: ', daq_dev_info.product_name, ' (', daq_dev_info.unique_id, ')\n', sep='') dio_info = daq_dev_info.get_dio_info() # Find the first port that supports input, defaulting to None # if one is not found. port = next( (port for port in dio_info.port_info if port.supports_output), None) if not port: raise Exception('Error: The DAQ device does not support ' 'digital output') # If the port is configurable, configure it for output. if port.is_port_configurable: ul.d_config_port(board_num, port.type, DigitalIODirection.OUT) port_value = 0xFF print('Setting', port.type.name, 'to', port_value) # Output the value to the port ul.d_out(board_num, port.type, port_value) bit_num = 0 bit_value = 0 print('Setting', port.type.name, 'bit', bit_num, 'to', bit_value) # Output the value to the bit ul.d_bit_out(board_num, port.type, bit_num, bit_value) except Exception as e: print('\n', e) finally: if use_device_detection: ul.release_daq_device(board_num)
def 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 = self.memhandle_as_ctypes_array(memhandle) # Display the values self.display_values(array, temp_data_array, total_count) except ULError as e: self.show_ul_error(e) finally: # Free the allocated memory ul.win_buf_free(memhandle) self.start_button["state"] = tk.NORMAL
def _get_is_port_configurable(self, port_type, in_mask, out_mask): if in_mask & out_mask > 0: return False # Check if d_config_port completes without error try: ul.d_config_port(self._board_num, port_type, DigitalIODirection.OUT) ul.d_config_port(self._board_num, port_type, DigitalIODirection.IN) except ULError: return False return True
def is_port_configurable(self): port_configurable = False if self.in_mask & self.out_mask == 0: # Check if d_config_port completes without error try: ul.d_config_port(self._board_num, self.type, DigitalIODirection.OUT) ul.d_config_port(self._board_num, self.type, DigitalIODirection.IN) port_configurable = True except ULError: port_configurable = False return port_configurable
def start(self): self.running = True self.start_button["command"] = self.stop self.start_button["text"] = "Stop" try: if self.port.is_port_configurable: ul.d_config_port(self.board_num, self.port.type, DigitalIODirection.IN) except ULError as e: self.stop() self.show_ul_error(e) return self.update_value()
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 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)
def __init__(self, master=None): super(ULDO02, self).__init__(master) master.protocol("WM_DELETE_WINDOW", self.exit) # By default, the example detects all available devices and selects the # first device listed. # If use_device_detection is set to False, the board_num property needs # to match the desired board number configured with Instacal. use_device_detection = True self.board_num = 0 try: if use_device_detection: self.configure_first_detected_device() self.device_info = DaqDeviceInfo(self.board_num) dio_info = self.device_info.get_dio_info() # Find the first port that supports output, defaulting to None # if one is not found. self.port = next((port for port in dio_info.port_info if port.supports_output), None) if self.port is not None: # If the port is configurable, configure it for output if self.port.is_port_configurable: try: ul.d_config_port(self.board_num, self.port.type, DigitalIODirection.OUT) except ULError as e: show_ul_error(e) self.create_widgets() else: self.create_unsupported_widgets() except ULError: self.create_unsupported_widgets(True)
def __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_scan_channel_info(self): num_channels = 0 self.chan_list = [] self.chan_type_list = [] self.gain_list = [] supported_channel_types = self.daqi_props.supported_channel_types self.resolution = 16 # Add analog input channels if available if (ChannelType.ANALOG in supported_channel_types): self.resolution = self.ai_props.resolution self.chan_list.append(0) self.chan_type_list.append(ChannelType.ANALOG) self.gain_list.append(self.ai_props.available_ranges[0]) num_channels += 1 if(self.ai_props.num_ai_chans > 1): self.chan_list.append(self.ai_props.num_ai_chans - 1) self.chan_type_list.append(ChannelType.ANALOG) self.gain_list.append(self.ai_props.available_ranges[0]) num_channels += 1 # Add a digital input channel if available if self.digital_props.num_ports > 0: chan_type = None if ChannelType.DIGITAL16 in supported_channel_types: chan_type = ChannelType.DIGITAL16 elif ChannelType.DIGITAL8 in supported_channel_types: chan_type = ChannelType.DIGITAL8 elif ChannelType.DIGITAL in supported_channel_types: chan_type = ChannelType.DIGITAL if chan_type != None: port_info = self.digital_props.port_info[0] self.chan_list.append(port_info.type) self.chan_type_list.append(chan_type) self.gain_list.append(ULRange.NOTUSED) num_channels += 1 # Configure all digital ports for input for port in self.digital_props.port_info: if port.is_port_configurable: ul.d_config_port( self.board_num, port.type, DigitalIODirection.IN) if self.counter_props.num_chans > 0: chan_type = None if ChannelType.CTR16 in supported_channel_types: chan_type = ChannelType.CTR16 elif ChannelType.CTRBANK0 in supported_channel_types: chan_type = ChannelType.CTRBANK0 elif ChannelType.CTR in supported_channel_types: chan_type = ChannelType.CTR if chan_type != None: self.chan_list.append(0) self.chan_type_list.append(chan_type) self.gain_list.append(ULRange.NOTUSED) num_channels += 1 self.num_chans = num_channels
def init_digital(): # All 8 bits in Port 1 set as input by default -> set to output ul.d_config_port(BOARD_NUM, DigitalPortType.AUXPORT, DigitalIODirection.OUT)
def switchRelay(self, state): ul.d_config_port(0, 1, DigitalIODirection.OUT) if state == False: ul.d_out(0, 1, 0) else: ul.d_out(0, 1, 0x01)
def init_scan_channel_info(self): num_channels = 0 daqi_info = self.device_info.get_daqi_info() supported_channel_types = daqi_info.supported_channel_types # Add analog input channels if available if ChannelType.ANALOG in supported_channel_types: ai_info = self.device_info.get_ai_info() self.resolution = ai_info.resolution self.chan_list.append(0) self.chan_type_list.append(ChannelType.ANALOG) self.gain_list.append(ai_info.supported_ranges[0]) num_channels += 1 if ai_info.num_chans > 1: self.chan_list.append(ai_info.num_chans - 1) self.chan_type_list.append(ChannelType.ANALOG) self.gain_list.append(ai_info.supported_ranges[0]) num_channels += 1 # Add a digital input channel if available if self.device_info.supports_digital_io: chan_type = None if ChannelType.DIGITAL16 in supported_channel_types: chan_type = ChannelType.DIGITAL16 elif ChannelType.DIGITAL8 in supported_channel_types: chan_type = ChannelType.DIGITAL8 elif ChannelType.DIGITAL in supported_channel_types: chan_type = ChannelType.DIGITAL if chan_type is not None: dio_info = self.device_info.get_dio_info() port_info = dio_info.port_info[0] self.chan_list.append(port_info.type) self.chan_type_list.append(chan_type) self.gain_list.append(ULRange.NOTUSED) num_channels += 1 # Configure all digital ports for input for port in dio_info.port_info: if port.is_port_configurable: ul.d_config_port(self.board_num, port.type, DigitalIODirection.IN) if self.device_info.supports_counters: chan_type = None if ChannelType.CTR16 in supported_channel_types: chan_type = ChannelType.CTR16 elif ChannelType.CTRBANK0 in supported_channel_types: chan_type = ChannelType.CTRBANK0 elif ChannelType.CTR in supported_channel_types: chan_type = ChannelType.CTR if chan_type is not None: self.chan_list.append(0) self.chan_type_list.append(chan_type) self.gain_list.append(ULRange.NOTUSED) num_channels += 1 self.num_chans = num_channels
from mcculw import ul from mcculw.enums import DigitalIODirection,DigitalPortType from mcculw.ul import ULError import os,sys board_num = 0 channel = int(sys.argv[3]) do =int(sys.argv[1]) try: ul.d_config_port(board_num, DigitalPortType.FIRSTPORTA, DigitalIODirection.OUT) except: pass ul.d_out(board_num, DigitalPortType.FIRSTPORTA, do)