def __init__(self, lock, instr_hub, parent=None):
print("DTT created")
super(DataTaker, self).__init__(parent)
self.instr_hub = instr_hub
self.connect(self.instr_hub, SIGNAL("changed_list()"),
self.reset_lists)
self.lock = lock
self.stopped = True
self.paused = False
self.mutex = QMutex()
self.completed = False
self.DEBUG = IOTool.get_debug_setting()
#the script which is run everytime the user call the routine "run"
self.script_file_name = ''
#a dict that can be populated by variable the user would like to change
#in real time while the script is ran
self.user_variables = {}
self.t_start = None
# scriptize the intruments and their parameters
self.reset_lists()
def __init__(self, lock, instr_hub, parent=None):
print("DTT created")
super(DataTaker, self).__init__(parent)
self.instr_hub = instr_hub
self.connect(self.instr_hub, SIGNAL("changed_list()"),
self.reset_lists)
self.lock = lock
self.stopped = True
self.paused = False
self.mutex = QMutex()
self.completed = False
self.DEBUG = IOTool.get_debug_setting()
self.script_file_name = ''
self.t_start = None
# initialize the intruments and their parameters
self.reset_lists()
def __init__(self, argv=[]):
# run the initializer of the class inherited from6
super(LabGuiMain, self).__init__()
self.settings = QSettings(self)
self.settings.setValue("state", self.saveState())
#debug parameter used to run labgui even when there is no instrument
#to connect to, used to plot past data or test the code
self.DEBUG = True
#variable to store the configfile name
self.config_file = ''
#parse the argument(s) passed inline
try:
#option c is to provide a name for config file
opts, args = getopt.getopt(argv, "c:")
#loop through the arguments on the inline command
for opt, arg in opts:
#user passed configfile
if opt == '-c':
self.config_file = arg
except getopt.GetoptError:
logging.error('configuration file : option -c argument missing')
#verify if the config file passed by the user is valid and exists
if self.config_file:
if not exists(self.config_file):
logging.error("The config file you provided ('%s') doesn't \
exist, '%s' will be used instead" % (self.config_file, CONFIG_FILE))
self.config_file = CONFIG_FILE
else:
#check whether the default config file exists or not
if exists(CONFIG_FILE) == False:
logging.warning("A '%s' file has been generated for you." %
(CONFIG_FILE))
logging.warning("Please modify it to change the default \
script, settings and data locations, or to enter debug mode.")
# creates a config.txt with basic needs
IOTool.create_config_file()
#sets default config file name
self.config_file = CONFIG_FILE
#to make sure the config file is of the right format
#ie that the user didn't specify the name of an existing file which
#isn't a configuration file
config_file_ok = False
while not config_file_ok:
try:
#try to read the DEBUG parameter from the configuration file
#as a test of the good formatting of the file
self.DEBUG = IOTool.get_debug_setting(
config_file_path=self.config_file)
#if this didn't generate errors we allow to get out of the loop
config_file_ok = True
except IOError:
logging.error("The config file you provided ('%s') doesn't \
have the right format, '%s' will be used instead" %
(self.config_file, CONFIG_FILE))
#check whether the default config file exists or not
if exists(CONFIG_FILE) == False:
logging.warning("A '%s' file has been generated for you." %
(CONFIG_FILE))
logging.warning("Please modify it to change the default \
script, settings and data locations, or to enter debug mode.")
# creates a config.txt with basic needs
IOTool.create_config_file()
#sets default config file name
self.config_file = CONFIG_FILE
print("Configuration loaded from : %s" % (self.config_file))
if self.DEBUG == True:
print("*" * 20)
print("Debug mode is set to True")
print("*" * 20)
self.option_display_debug_state()
else:
self.option_display_normal_state()
#create the central part of the application
self.zoneCentrale = QtGui.QMdiArea()
self.zoneCentrale.subWindowActivated.connect(
self.update_current_window)
self.setCentralWidget(self.zoneCentrale)
#load the parameter for the GPIB interface setting of the instruments
interface = IOTool.get_interface_setting(
config_file_path=self.config_file)
#test if the parameter is correct
if interface not in [Tool.INTF_VISA, Tool.INTF_PROLOGIX]:
msg = """The %s variable of the config file '%s' is not correct
The only two allowed values are : '%s' and '%s' """ % (
IOTool.GPIB_INTF_ID, IOTool.CONFIG_FILE, Tool.INTF_VISA,
Tool.INTF_PROLOGIX)
logging.warning(msg)
#default setting
Tool.INTF_GPIB = Tool.INTF_PROLOGIX
else:
Tool.INTF_GPIB = interface
print("*" * 20)
print("The GPIB setting for connecting instruments is %s" %
(Tool.INTF_GPIB))
print("*" * 20)
# the lock is something for multithreading... not sure if it's important in our application.
self.lock = QReadWriteLock()
# InstrumentHub is responsible for storing and managing the user
# choices about which instrument goes on which port
self.instr_hub = Tool.InstrumentHub(parent=self, debug=self.DEBUG)
# DataTaker is responsible for taking data from instruments in the
# InstrumentHub object
self.datataker = DataManagement.DataTaker(self.lock, self.instr_hub)
# handle data emitted by datataker (basically stuff it into a shared,
# central array)
self.connect(self.datataker, SIGNAL("data(PyQt_PyObject)"),
self.update_data_array)
#a signal to signify the data taking script is over
self.connect(self.datataker, SIGNAL("script_finished(bool)"),
self.finished_DTT)
#the array in which the data will be stored
self.data_array = np.array([])
# all actions related to the figure widget (mplZoomWidget.py) are
# set up in the actionmanager
self.action_manager = mplZoomWidget.ActionManager(self)
#this will contain the widget of the latest pdw created upon
#connecting the instrument Hub
self.actual_pdw = None
#this will contain windows settings (labels, checkboxes states, colors)
#of the plotdisplaw window which is created when the user click on
#the connect button
self.plot_window_settings = None
#### set up menus and toolbars
self.fileMenu = self.menuBar().addMenu("File")
self.plotMenu = self.menuBar().addMenu("&Plot")
self.instMenu = self.menuBar().addMenu("&Meas/Connect")
self.windowMenu = self.menuBar().addMenu("&Window")
self.optionMenu = self.menuBar().addMenu("&Options")
self.loggingSubMenu = self.optionMenu.addMenu("&Logger output level")
self.plotToolbar = self.addToolBar("Plot")
self.instToolbar = self.addToolBar("Instruments")
# start/stop/pause buttons
self.start_DTT_action = QtTools.create_action(
self,
"Start DTT",
slot=self.start_DTT,
shortcut=QtGui.QKeySequence("F5"),
icon="start",
tip="Start script")
self.stop_DTT_action = QtTools.create_action(
self,
"Stop DTT",
slot=self.stop_DTT,
shortcut=QtGui.QKeySequence("F6"),
icon="stop",
tip="stop script")
self.pause_DTT_action = QtTools.create_action(
self,
"Pause DTT",
slot=self.pause_DTT,
shortcut=QtGui.QKeySequence("F7"),
icon="pause",
tip="pause script")
self.pause_DTT_action.setEnabled(False)
self.stop_DTT_action.setEnabled(False)
self.instToolbar.setObjectName("InstToolBar")
self.instToolbar.addAction(self.start_DTT_action)
self.instToolbar.addAction(self.pause_DTT_action)
self.instToolbar.addAction(self.stop_DTT_action)
#this will contain the different widgets in the window
self.widgets = {}
cur_path = os.path.dirname(__file__)
#find the path to the widgets folders
widget_path = os.path.join(cur_path, 'LabTools')
#these are widgets essential to the interface
core_widget_path = os.path.join(widget_path, 'CoreWidgets')
#these are widgets which were added by users
user_widget_path = os.path.join(widget_path, 'UserWidgets')
#this is the legitimate list of core widgets
widgets_list = [
o.rstrip('.py') for o in os.listdir(core_widget_path)
if o.endswith(".py") and not "__init__" in o
]
#this is the legitimate list of user widgets
user_widgets_list = [
o.rstrip('.py') for o in os.listdir(user_widget_path)
if o.endswith(".py") and not "__init__" in o
]
#the user widgets the user would like to run, given in the config file
user_widgets = IOTool.get_user_widgets(
config_file_path=self.config_file)
if user_widgets:
for user_widget in user_widgets:
#check that the given widget is legitimate
if user_widget in user_widgets_list:
#add the given widget to the widget list which will be
#loaded
widgets_list.append(user_widget)
else:
logging.warning("The user widget '%s' is not found at %s" %
(user_widget, user_widget_path))
#add the widgets to the interface
for widget in widgets_list:
widget_name = widget
try:
widget_module = import_module("." + widget_name,
package=COREWIDGETS_PACKAGE_NAME)
except ImportError:
widget_module = import_module("." + widget_name,
package=USERWIDGETS_PACKAGE_NAME)
self.add_widget(widget_module.add_widget_into_main)
###### FILE MENU SETUP ######
self.fileSaveSettingsAction = QtTools.create_action(
self,
"Save Instrument Settings",
slot=self.file_save_settings,
shortcut=QtGui.QKeySequence.SaveAs,
icon=None,
tip="Save the current instrument settings")
self.fileLoadSettingsAction = QtTools.create_action(
self,
"Load Instrument Settings",
slot=self.file_load_settings,
shortcut=QtGui.QKeySequence.Open,
icon=None,
tip="Load instrument settings from file")
self.fileLoadDataAction = QtTools.create_action(
self,
"Load Previous Data",
slot=self.file_load_data,
shortcut=None,
icon=None,
tip="Load previous data from file")
"""this is not working I will leave it commented right now"""
# self.filePrintAction = QtTools.create_action(self, "&Print Report", slot=self.file_print, shortcut=QtGui.QKeySequence.Print,
# icon=None, tip="Print the figure along with relevant information")
self.fileSaveCongfigAction = QtTools.create_action(
self,
"Save current configuration",
slot=self.file_save_config,
shortcut=None,
icon=None,
tip="Save the setting file path, \
the script path and the data output path into the config file")
self.fileMenu.addAction(self.fileLoadSettingsAction)
self.fileMenu.addAction(self.fileSaveSettingsAction)
self.fileMenu.addAction(self.fileLoadDataAction)
# self.fileMenu.addAction(self.filePrintAction)
self.fileMenu.addAction(self.action_manager.saveFigAction)
self.fileMenu.addAction(self.fileSaveCongfigAction)
###### PLOT MENU + TOOLBAR SETUP ######
self.plotToolbar.setObjectName("PlotToolBar")
for action in self.action_manager.actions:
self.plotMenu.addAction(action)
self.plotToolbar.addAction(action)
self.clearPlotAction = QtTools.create_action(
self,
"Clear All Plots",
slot=self.clear_plot,
shortcut=None,
icon="clear_plot",
tip="Clears the live data arrays")
self.removeFitAction = QtTools.create_action(
self,
"Remove Fit",
slot=self.remove_fit,
shortcut=None,
icon="clear",
tip="Reset the fit data to an empty array")
self.plotMenu.addAction(self.clearPlotAction)
self.plotMenu.addAction(self.removeFitAction)
###### INSTRUMENT MENU SETUP ######
self.read_DTT = QtTools.create_action(
self,
"Read",
slot=self.single_measure_DTT,
shortcut=None,
icon=None,
tip="Take a one shot measure with DTT")
self.connect_hub = QtTools.create_action(
self,
"Connect Instruments",
slot=self.connect_instrument_hub,
shortcut=QtGui.QKeySequence("Ctrl+I"),
icon=None,
tip="Refresh the list of selected instruments")
self.refresh_ports_list_action = QtTools.create_action(
self,
"Refresh ports list",
slot=self.refresh_ports_list,
icon=None,
tip="Refresh the list of availiable ports")
self.instMenu.addAction(self.start_DTT_action)
self.instMenu.addAction(self.read_DTT)
self.instMenu.addAction(self.connect_hub)
self.instMenu.addAction(self.refresh_ports_list_action)
###### WINDOW MENU SETUP ######
self.add_pdw = QtTools.create_action(self,
"Add a Plot",
slot=self.create_pdw,
shortcut=None,
icon=None,
tip="Add a recordsweep window")
self.add_pqtw = QtTools.create_action(self,
"Add a PyQtplot",
slot=self.create_pqtw,
shortcut=None,
icon=None,
tip="Add a pyqt window")
self.windowMenu.addAction(self.add_pdw)
try:
import PyQTWindow
self.windowMenu.addAction(self.add_pqtw)
except:
logging.info("pyqtgraph is unable to load, \
the pyqt window option is disabled")
###### OPTION MENU SETUP ######
self.toggle_debug_state = QtTools.create_action(
self,
"Change debug mode",
slot=self.option_change_debug_state,
shortcut=None,
icon=None,
tip="Change the state of the debug mode")
# self.toggle_debug_state = QtTools.create_action(self,
# "Change debug mode", slot = self.option_change_debug_state,
# shortcut = None, icon = None,
# tip = "Change the state of the debug mode")
self.optionMenu.addAction(self.toggle_debug_state)
for log_level in ["DEBUG", "INFO", "WARNING", "ERROR"]:
action = QtTools.create_action(
self,
log_level,
slot=self.option_change_log_level,
shortcut=None,
icon=None,
tip="Change the state of the logger to %s" % log_level)
self.loggingSubMenu.addAction(action)
###############################
#Load the user settings for the instrument connectic and parameters
self.default_settings_fname = IOTool.get_settings_name(
config_file_path=self.config_file)
if not exists(self.default_settings_fname):
logging.warning(
"The filename '%s' wasn't found, using '%s'" %
(self.default_settings_fname, 'settings/default_settings.txt'))
self.default_settings_fname = 'settings/default_settings.txt'
if os.path.isfile(self.default_settings_fname):
self.widgets['CalcWidget'].load_settings(
self.default_settings_fname)
self.widgets['InstrumentWidget'].load_settings(
self.default_settings_fname)
# Create the object responsible to display information send by the
# datataker
self.data_displayer = DataManagement.DataDisplayer(self.datataker)
# platform-independent way to restore settings such as toolbar positions,
# dock widget configuration and window size from previous session.
# this doesn't seem to be working at all on my computer (win7 system)
self.settings = QSettings("Gervais Lab", "RecordSweep")
try:
self.restoreState(self.settings.value("windowState").toByteArray())
self.restoreGeometry(self.settings.value("geometry").toByteArray())
except:
logging.info(
'Using default window configuration'
) # no biggie - probably means settings haven't been saved on this machine yet