def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(298, 702)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(Form.sizePolicy().hasHeightForWidth())
Form.setSizePolicy(sizePolicy)
Form.setMinimumSize(QtCore.QSize(0, 0))
Form.setBaseSize(QtCore.QSize(200, 300))
self.gridLayout_3 = QtWidgets.QGridLayout(Form)
self.gridLayout_3.setContentsMargins(0, 0, 0, 0)
self.gridLayout_3.setSpacing(6)
self.gridLayout_3.setObjectName("gridLayout_3")
self.splitter = QtWidgets.QSplitter(Form)
self.splitter.setOrientation(QtCore.Qt.Horizontal)
self.splitter.setObjectName("splitter")
self.verticalLayoutWidget = QtWidgets.QWidget(self.splitter)
self.verticalLayoutWidget.setObjectName("verticalLayoutWidget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.verticalLayoutWidget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setObjectName("verticalLayout")
self.horizontalLayout = QtWidgets.QHBoxLayout()
self.horizontalLayout.setSizeConstraint(
QtWidgets.QLayout.SetDefaultConstraint)
self.horizontalLayout.setSpacing(0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.groupBox_main = QtWidgets.QGroupBox(self.verticalLayoutWidget)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.groupBox_main.sizePolicy().hasHeightForWidth())
self.groupBox_main.setSizePolicy(sizePolicy)
self.groupBox_main.setMinimumSize(QtCore.QSize(0, 0))
self.groupBox_main.setMaximumSize(QtCore.QSize(16777215, 16777215))
self.groupBox_main.setBaseSize(QtCore.QSize(0, 0))
self.groupBox_main.setTitle("")
self.groupBox_main.setFlat(False)
self.groupBox_main.setObjectName("groupBox_main")
self.gridLayout_9 = QtWidgets.QGridLayout(self.groupBox_main)
self.gridLayout_9.setContentsMargins(0, 0, 0, 0)
self.gridLayout_9.setObjectName("gridLayout_9")
self.gridLayout_2 = QtWidgets.QGridLayout()
self.gridLayout_2.setSizeConstraint(
QtWidgets.QLayout.SetDefaultConstraint)
self.gridLayout_2.setObjectName("gridLayout_2")
self.label_2 = QtWidgets.QLabel(self.groupBox_main)
self.label_2.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignTrailing
| QtCore.Qt.AlignVCenter)
self.label_2.setObjectName("label_2")
self.gridLayout_2.addWidget(self.label_2, 2, 0, 1, 1)
self.Move_Done_LED = QLED(self.groupBox_main)
self.Move_Done_LED.setObjectName("Move_Done_LED")
self.gridLayout_2.addWidget(self.Move_Done_LED, 6, 1, 1, 1)
self.IniStage_pb = QtWidgets.QPushButton(self.groupBox_main)
self.IniStage_pb.setCheckable(True)
self.IniStage_pb.setChecked(False)
self.IniStage_pb.setObjectName("IniStage_pb")
self.gridLayout_2.addWidget(self.IniStage_pb, 4, 0, 1, 1)
self.Ini_state_LED = QLED(self.groupBox_main)
self.Ini_state_LED.setObjectName("Ini_state_LED")
self.gridLayout_2.addWidget(self.Ini_state_LED, 4, 1, 1, 1)
self.Current_position_sb = QtWidgets.QDoubleSpinBox(self.groupBox_main)
font = QtGui.QFont()
font.setPointSize(20)
self.Current_position_sb.setFont(font)
self.Current_position_sb.setLocale(
QtCore.QLocale(QtCore.QLocale.English,
QtCore.QLocale.UnitedStates))
self.Current_position_sb.setReadOnly(True)
self.Current_position_sb.setButtonSymbols(
QtWidgets.QAbstractSpinBox.NoButtons)
self.Current_position_sb.setDecimals(6)
self.Current_position_sb.setMinimum(-1000000.0)
self.Current_position_sb.setMaximum(1000000.0)
self.Current_position_sb.setObjectName("Current_position_sb")
self.gridLayout_2.addWidget(self.Current_position_sb, 7, 0, 1, 2)
self.Stage_type_combo = QtWidgets.QComboBox(self.groupBox_main)
self.Stage_type_combo.setObjectName("Stage_type_combo")
self.gridLayout_2.addWidget(self.Stage_type_combo, 2, 1, 1, 1)
self.title_label = QtWidgets.QLabel(self.groupBox_main)
font = QtGui.QFont()
font.setFamily("Tahoma")
font.setPointSize(14)
font.setBold(True)
font.setItalic(True)
font.setWeight(75)
self.title_label.setFont(font)
self.title_label.setAlignment(QtCore.Qt.AlignCenter)
self.title_label.setObjectName("title_label")
self.gridLayout_2.addWidget(self.title_label, 0, 0, 1, 2)
self.Quit_pb = QtWidgets.QPushButton(self.groupBox_main)
icon = QtGui.QIcon()
icon.addPixmap(
QtGui.QPixmap(":/Labview_icons/Icon_Library/close2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Quit_pb.setIcon(icon)
self.Quit_pb.setObjectName("Quit_pb")
self.gridLayout_2.addWidget(self.Quit_pb, 5, 0, 1, 2)
self.label_4 = QtWidgets.QLabel(self.groupBox_main)
self.label_4.setObjectName("label_4")
self.gridLayout_2.addWidget(self.label_4, 6, 0, 1, 1)
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setSpacing(0)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.Abs_position_sb_bis = SpinBox(self.groupBox_main)
self.Abs_position_sb_bis.setLocale(
QtCore.QLocale(QtCore.QLocale.English,
QtCore.QLocale.UnitedStates))
self.Abs_position_sb_bis.setDecimals(6)
self.Abs_position_sb_bis.setMaximum(1000000.0)
self.Abs_position_sb_bis.setObjectName("Abs_position_sb_bis")
self.horizontalLayout_2.addWidget(self.Abs_position_sb_bis)
self.Moveto_pb_bis = QtWidgets.QPushButton(self.groupBox_main)
self.Moveto_pb_bis.setText("")
icon1 = QtGui.QIcon()
icon1.addPixmap(
QtGui.QPixmap(":/Labview_icons/Icon_Library/go_to_1.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Moveto_pb_bis.setIcon(icon1)
self.Moveto_pb_bis.setObjectName("Moveto_pb_bis")
self.horizontalLayout_2.addWidget(self.Moveto_pb_bis)
self.Moveto_pb_bis_2 = QtWidgets.QPushButton(self.groupBox_main)
self.Moveto_pb_bis_2.setText("")
icon2 = QtGui.QIcon()
icon2.addPixmap(
QtGui.QPixmap(":/Labview_icons/Icon_Library/go_to_2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Moveto_pb_bis_2.setIcon(icon2)
self.Moveto_pb_bis_2.setObjectName("Moveto_pb_bis_2")
self.horizontalLayout_2.addWidget(self.Moveto_pb_bis_2)
self.fine_tuning_pb = QtWidgets.QPushButton(self.groupBox_main)
self.fine_tuning_pb.setText("")
icon3 = QtGui.QIcon()
icon3.addPixmap(
QtGui.QPixmap(":/Labview_icons/Icon_Library/Add_Step.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.fine_tuning_pb.setIcon(icon3)
self.fine_tuning_pb.setCheckable(True)
self.fine_tuning_pb.setObjectName("fine_tuning_pb")
self.horizontalLayout_2.addWidget(self.fine_tuning_pb)
self.parameters_pb = QtWidgets.QPushButton(self.groupBox_main)
self.parameters_pb.setText("")
icon4 = QtGui.QIcon()
icon4.addPixmap(
QtGui.QPixmap(":/Labview_icons/Icon_Library/Settings.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.parameters_pb.setIcon(icon4)
self.parameters_pb.setCheckable(True)
self.parameters_pb.setObjectName("parameters_pb")
self.horizontalLayout_2.addWidget(self.parameters_pb)
self.gridLayout_2.addLayout(self.horizontalLayout_2, 1, 0, 1, 2)
self.gridLayout_9.addLayout(self.gridLayout_2, 0, 0, 1, 1)
self.horizontalLayout.addWidget(self.groupBox_main)
spacerItem = QtWidgets.QSpacerItem(40, 20,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.verticalLayout.addLayout(self.horizontalLayout)
self.horizontalLayout_3 = QtWidgets.QHBoxLayout()
self.horizontalLayout_3.setObjectName("horizontalLayout_3")
self.groupBox = QtWidgets.QGroupBox(self.verticalLayoutWidget)
self.groupBox.setTitle("")
self.groupBox.setFlat(False)
self.groupBox.setObjectName("groupBox")
self.gridLayout = QtWidgets.QGridLayout(self.groupBox)
self.gridLayout.setContentsMargins(0, 0, 0, 0)
self.gridLayout.setObjectName("gridLayout")
self.gridLayout_buttons = QtWidgets.QGridLayout()
self.gridLayout_buttons.setContentsMargins(-1, 0, -1, -1)
self.gridLayout_buttons.setObjectName("gridLayout_buttons")
self.Move_Abs_pb = QtWidgets.QPushButton(self.groupBox)
icon5 = QtGui.QIcon()
icon5.addPixmap(QtGui.QPixmap(":/Labview_icons/Icon_Library/Move.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Move_Abs_pb.setIcon(icon5)
self.Move_Abs_pb.setObjectName("Move_Abs_pb")
self.gridLayout_buttons.addWidget(self.Move_Abs_pb, 4, 1, 2, 1)
self.label_3 = QtWidgets.QLabel(self.groupBox)
self.label_3.setObjectName("label_3")
self.gridLayout_buttons.addWidget(self.label_3, 7, 0, 1, 1)
self.Move_Rel_minus_pb = QtWidgets.QPushButton(self.groupBox)
icon6 = QtGui.QIcon()
icon6.addPixmap(
QtGui.QPixmap(":/Labview_icons/Icon_Library/MoveDown.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Move_Rel_minus_pb.setIcon(icon6)
self.Move_Rel_minus_pb.setObjectName("Move_Rel_minus_pb")
self.gridLayout_buttons.addWidget(self.Move_Rel_minus_pb, 8, 1, 1, 1)
self.Move_Rel_plus_pb = QtWidgets.QPushButton(self.groupBox)
icon7 = QtGui.QIcon()
icon7.addPixmap(
QtGui.QPixmap(":/Labview_icons/Icon_Library/MoveUp.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Move_Rel_plus_pb.setIcon(icon7)
self.Move_Rel_plus_pb.setObjectName("Move_Rel_plus_pb")
self.gridLayout_buttons.addWidget(self.Move_Rel_plus_pb, 7, 1, 1, 1)
self.Stop_pb = QtWidgets.QPushButton(self.groupBox)
icon8 = QtGui.QIcon()
icon8.addPixmap(
QtGui.QPixmap(":/Labview_icons/Icon_Library/status_cancelled.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Stop_pb.setIcon(icon8)
self.Stop_pb.setObjectName("Stop_pb")
self.gridLayout_buttons.addWidget(self.Stop_pb, 11, 0, 1, 1)
self.Abs_position_sb = SpinBox(self.groupBox)
self.Abs_position_sb.setLocale(
QtCore.QLocale(QtCore.QLocale.English,
QtCore.QLocale.UnitedStates))
self.Abs_position_sb.setDecimals(6)
self.Abs_position_sb.setMinimum(-1000000.0)
self.Abs_position_sb.setMaximum(1000000.0)
self.Abs_position_sb.setObjectName("Abs_position_sb")
self.gridLayout_buttons.addWidget(self.Abs_position_sb, 5, 0, 1, 1)
self.Rel_position_sb = SpinBox(self.groupBox)
self.Rel_position_sb.setLocale(
QtCore.QLocale(QtCore.QLocale.English,
QtCore.QLocale.UnitedStates))
self.Rel_position_sb.setDecimals(6)
self.Rel_position_sb.setMinimum(-1000000.0)
self.Rel_position_sb.setMaximum(1000000.0)
self.Rel_position_sb.setObjectName("Rel_position_sb")
self.gridLayout_buttons.addWidget(self.Rel_position_sb, 8, 0, 1, 1)
self.Get_position_pb = QtWidgets.QPushButton(self.groupBox)
icon9 = QtGui.QIcon()
icon9.addPixmap(
QtGui.QPixmap(":/Labview_icons/Icon_Library/home2_32.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Get_position_pb.setIcon(icon9)
self.Get_position_pb.setObjectName("Get_position_pb")
self.gridLayout_buttons.addWidget(self.Get_position_pb, 11, 1, 1, 1)
self.Find_Home_pb = QtWidgets.QPushButton(self.groupBox)
self.Find_Home_pb.setIcon(icon9)
self.Find_Home_pb.setObjectName("Find_Home_pb")
self.gridLayout_buttons.addWidget(self.Find_Home_pb, 3, 1, 1, 1)
self.label_5 = QtWidgets.QLabel(self.groupBox)
self.label_5.setObjectName("label_5")
self.gridLayout_buttons.addWidget(self.label_5, 3, 0, 1, 1)
self.gridLayout.addLayout(self.gridLayout_buttons, 0, 0, 1, 1)
spacerItem1 = QtWidgets.QSpacerItem(40, 20,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.gridLayout.addItem(spacerItem1, 0, 1, 1, 1)
self.horizontalLayout_3.addWidget(self.groupBox)
self.verticalLayout.addLayout(self.horizontalLayout_3)
spacerItem2 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem2)
self.StatusBarLayout = QtWidgets.QHBoxLayout()
self.StatusBarLayout.setSizeConstraint(
QtWidgets.QLayout.SetMinimumSize)
self.StatusBarLayout.setObjectName("StatusBarLayout")
self.verticalLayout.addLayout(self.StatusBarLayout)
self.verticalLayoutWidget_2 = QtWidgets.QWidget(self.splitter)
self.verticalLayoutWidget_2.setObjectName("verticalLayoutWidget_2")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(
self.verticalLayoutWidget_2)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.gridLayout_3.addWidget(self.splitter, 0, 0, 1, 1)
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def setupUI(self):
self.dock_pid = Dock('PID controller', self.dock_area)
self.dock_area.addDock(self.dock_pid)
#%% create logger dock
self.logger_dock=Dock("Logger")
self.logger_list=QtWidgets.QListWidget()
self.logger_list.setMinimumWidth(300)
self.logger_dock.addWidget(self.logger_list)
self.dock_area.addDock(self.logger_dock,'right')
self.logger_dock.setVisible(True)
widget = QtWidgets.QWidget()
widget_toolbar = QtWidgets.QWidget()
verlayout = QtWidgets.QVBoxLayout()
widget.setLayout(verlayout)
toolbar_layout = QtWidgets.QGridLayout()
widget_toolbar.setLayout(toolbar_layout)
iconquit = QtGui.QIcon()
iconquit.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/close2.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.quit_action = QtWidgets.QPushButton(iconquit, "Quit")
self.quit_action.setToolTip('Quit the application')
toolbar_layout.addWidget(self.quit_action,0,0,1,2)
self.quit_action.clicked.connect(self.quit_fun)
iconini = QtGui.QIcon()
iconini.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/ini.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.ini_model_action = QtWidgets.QPushButton(iconini, "Init Model")
self.ini_model_action.setToolTip('Initialize the chosen model')
toolbar_layout.addWidget(self.ini_model_action,2,0)
self.ini_model_action.clicked.connect(self.ini_model)
self.model_led = QLED()
toolbar_layout.addWidget(self.model_led, 2,1)
self.ini_PID_action = QtWidgets.QPushButton(iconini, "Init PID")
self.ini_PID_action.setToolTip('Initialize the PID loop')
toolbar_layout.addWidget(self.ini_PID_action,2,2)
self.ini_PID_action.setCheckable(True)
self.ini_PID_action.clicked.connect(self.ini_PID)
self.pid_led = QLED()
toolbar_layout.addWidget(self.pid_led, 2,3)
self.iconrun = QtGui.QIcon()
self.iconrun.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/run2.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.icon_stop = QtGui.QIcon()
self.icon_stop.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/stop.png"))
self.run_action = QtWidgets.QPushButton(self.iconrun, "", None)
self.run_action.setToolTip('Start PID loop')
self.run_action.setCheckable(True)
toolbar_layout.addWidget(self.run_action,0,2)
self.run_action.clicked.connect(self.run_PID)
iconpause = QtGui.QIcon()
iconpause.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/pause.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.pause_action = QtWidgets.QPushButton(iconpause, "", None)
self.pause_action.setToolTip('Pause PID')
self.pause_action.setCheckable(True)
toolbar_layout.addWidget(self.pause_action,0,3)
self.pause_action.setChecked(True)
self.pause_action.clicked.connect(self.pause_PID)
lab = QtWidgets.QLabel('Set Point:')
toolbar_layout.addWidget(lab, 3,0,1,2)
self.setpoint_sb = custom_tree.SpinBoxCustom()
self.setpoint_sb.setMinimumHeight(40)
font = self.setpoint_sb.font()
font.setPointSizeF(20)
self.setpoint_sb.setFont(font)
self.setpoint_sb.setDecimals(6)
toolbar_layout.addWidget(self.setpoint_sb,3,2,1,2)
self.setpoint_sb.valueChanged.connect(self.settings.child('main_settings', 'pid_controls', 'set_point').setValue)
lab1 = QtWidgets.QLabel('Current Point:')
toolbar_layout.addWidget(lab1, 4,0,1,2)
self.currpoint_sb = custom_tree.SpinBoxCustom()
self.currpoint_sb.setMinimumHeight(40)
self.currpoint_sb.setReadOnly(True)
self.currpoint_sb.setDecimals(6)
self.currpoint_sb.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
font = self.currpoint_sb.font()
font.setPointSizeF(20)
self.currpoint_sb.setFont(font)
toolbar_layout.addWidget(self.currpoint_sb,4,2,1,2)
#create main parameter tree
self.settings_tree = ParameterTree()
self.settings_tree.setParameters(self.settings, showTop=False)
verlayout.addWidget(widget_toolbar)
verlayout.addWidget(self.settings_tree)
self.dock_output = Dock('PID output')
widget_output = QtWidgets.QWidget()
self.output_viewer = Viewer0D(widget_output)
self.dock_output.addWidget(widget_output)
self.dock_area.addDock(self.dock_output, 'right')
self.dock_input = Dock('PID input')
widget_input = QtWidgets.QWidget()
self.input_viewer = Viewer0D(widget_input)
self.dock_input.addWidget(widget_input)
self.dock_area.addDock(self.dock_input, 'bottom',self.dock_output)
if len(self.models) != 0:
self.get_set_model_params(self.models[0])
#connecting from tree
self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)#any changes on the settings will update accordingly the detector
self.dock_pid.addWidget(widget)
class DAQ_PID(QObject):
"""
"""
log_signal = pyqtSignal(str)
#look for eventual model files
command_pid = pyqtSignal(ThreadCommand)
command_stage = pyqtSignal(ThreadCommand)
move_done_signal = pyqtSignal(str, float)
models = []
try:
model_mod = importlib.import_module('pymodaq_pid_models')
for ind_file, entry in enumerate(os.scandir(os.path.join(model_mod.__path__[0], 'models'))):
if not entry.is_dir() and entry.name != '__init__.py':
try:
file, ext = os.path.splitext(entry.name)
importlib.import_module('.'+file, model_mod.__name__+'.models')
models.append(file)
except Exception as e:
print(e)
if 'PIDModelMock' in models:
mods = models
mods.pop(models.index('PIDModelMock'))
models = ['PIDModelMock']
models.extend(mods)
except Exception as e:
print(e)
if len(models) == 0:
logger.warning('No valid installed models')
def __init__(self,area, detector_modules = [], actuator_modules =[]):
QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedStates))
super(DAQ_PID,self).__init__()
self.settings = Parameter.create(title='PID settings', name='pid_settings', type='group', children=params)
self.title = 'PyMoDAQ PID'
self.Initialized_state = False
self.model_class = None
self.detector_modules = detector_modules
self.actuator_modules = actuator_modules
self.dock_area = area
self.overshoot = None
self.check_moving = False
self.preset_manager = PresetManager()
self.setupUI()
self.command_stage.connect(self.move_Abs) #to be compatible with actuator modules within daq scan
self.enable_controls_pid(False)
self.enable_controls_pid_run(False)
def ini_PID(self):
if self.ini_PID_action.isChecked():
output_limits =[None,None]
if self.settings.child('main_settings', 'pid_controls', 'output_limits', 'output_limit_min_enabled').value():
output_limits[0] = self.settings.child('main_settings', 'pid_controls', 'output_limits', 'output_limit_min').value()
if self.settings.child('main_settings', 'pid_controls', 'output_limits', 'output_limit_max_enabled').value():
output_limits[1] = self.settings.child('main_settings', 'pid_controls', 'output_limits', 'output_limit_max').value()
self.PIDThread = QThread()
pid_runner = PIDRunner(self.model_class,
[mod.move_done_signal for mod in self.actuator_modules],
[mod.grab_done_signal for mod in self.detector_modules],
[mod.command_stage for mod in self.actuator_modules],
[mod.command_detector for mod in self.detector_modules],
dict(Kp=self.settings.child('main_settings', 'pid_controls', 'pid_constants', 'kp').value(),
Ki=self.settings.child('main_settings', 'pid_controls', 'pid_constants', 'ki').value(),
Kd=self.settings.child('main_settings', 'pid_controls', 'pid_constants', 'kd').value(),
setpoint=self.settings.child('main_settings', 'pid_controls', 'set_point').value(),
sample_time=self.settings.child('main_settings', 'pid_controls', 'sample_time').value()/1000,
output_limits=output_limits,
auto_mode=False),
filter=dict(enable=self.settings.child('main_settings', 'pid_controls', 'filter', 'filter_enable').value(),
value=self.settings.child('main_settings', 'pid_controls', 'filter', 'filter_step').value()),
det_averaging=[mod.settings.child('main_settings', 'Naverage').value() for mod in self.detector_modules],
)
self.PIDThread.pid_runner = pid_runner
pid_runner.pid_output_signal.connect(self.process_output)
pid_runner.status_sig.connect(self.thread_status)
self.command_pid.connect(pid_runner.queue_command)
pid_runner.moveToThread(self.PIDThread)
self.PIDThread.start()
self.pid_led.set_as_true()
self.enable_controls_pid_run(True)
else:
if hasattr(self,'PIDThread'):
if self.PIDThread.isRunning():
try:
self.PIDThread.quit()
except:
pass
self.pid_led.set_as_false()
self.enable_controls_pid_run(False)
self.Initialized_state = True
pyqtSlot(dict)
def process_output(self, datas):
self.output_viewer.show_data([[dat] for dat in datas['output']])
self.input_viewer.show_data([[dat] for dat in datas['input']])
self.currpoint_sb.setValue(np.mean(datas['input']))
if self.check_moving:
if np.abs(np.mean(datas['input'])-self.settings.child('main_settings', 'pid_controls', 'set_point').value()) < \
self.settings.child('main_settings', 'epsilon').value():
self.move_done_signal.emit(self.title, np.mean(datas['input']))
self.check_moving = False
print('Move from {:s} is done: {:f}'.format('PID', np.mean(datas['input'])))
@pyqtSlot(ThreadCommand)
def move_Abs(self, command=ThreadCommand()):
"""
"""
if command.command == "move_Abs":
self.check_moving = True
self.setpoint_sb.setValue(command.attributes[0])
QtWidgets.QApplication.processEvents()
def enable_controls_pid(self,enable = False):
self.ini_PID_action.setEnabled(enable)
self.setpoint_sb.setOpts(enabled = enable)
def enable_controls_pid_run(self,enable = False):
self.run_action.setEnabled(enable)
self.pause_action.setEnabled(enable)
def setupUI(self):
self.dock_pid = Dock('PID controller', self.dock_area)
self.dock_area.addDock(self.dock_pid)
#%% create logger dock
self.logger_dock=Dock("Logger")
self.logger_list=QtWidgets.QListWidget()
self.logger_list.setMinimumWidth(300)
self.logger_dock.addWidget(self.logger_list)
self.dock_area.addDock(self.logger_dock,'right')
self.logger_dock.setVisible(True)
widget = QtWidgets.QWidget()
widget_toolbar = QtWidgets.QWidget()
verlayout = QtWidgets.QVBoxLayout()
widget.setLayout(verlayout)
toolbar_layout = QtWidgets.QGridLayout()
widget_toolbar.setLayout(toolbar_layout)
iconquit = QtGui.QIcon()
iconquit.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/close2.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.quit_action = QtWidgets.QPushButton(iconquit, "Quit")
self.quit_action.setToolTip('Quit the application')
toolbar_layout.addWidget(self.quit_action,0,0,1,2)
self.quit_action.clicked.connect(self.quit_fun)
iconini = QtGui.QIcon()
iconini.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/ini.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.ini_model_action = QtWidgets.QPushButton(iconini, "Init Model")
self.ini_model_action.setToolTip('Initialize the chosen model')
toolbar_layout.addWidget(self.ini_model_action,2,0)
self.ini_model_action.clicked.connect(self.ini_model)
self.model_led = QLED()
toolbar_layout.addWidget(self.model_led, 2,1)
self.ini_PID_action = QtWidgets.QPushButton(iconini, "Init PID")
self.ini_PID_action.setToolTip('Initialize the PID loop')
toolbar_layout.addWidget(self.ini_PID_action,2,2)
self.ini_PID_action.setCheckable(True)
self.ini_PID_action.clicked.connect(self.ini_PID)
self.pid_led = QLED()
toolbar_layout.addWidget(self.pid_led, 2,3)
self.iconrun = QtGui.QIcon()
self.iconrun.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/run2.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.icon_stop = QtGui.QIcon()
self.icon_stop.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/stop.png"))
self.run_action = QtWidgets.QPushButton(self.iconrun, "", None)
self.run_action.setToolTip('Start PID loop')
self.run_action.setCheckable(True)
toolbar_layout.addWidget(self.run_action,0,2)
self.run_action.clicked.connect(self.run_PID)
iconpause = QtGui.QIcon()
iconpause.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/pause.png"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.pause_action = QtWidgets.QPushButton(iconpause, "", None)
self.pause_action.setToolTip('Pause PID')
self.pause_action.setCheckable(True)
toolbar_layout.addWidget(self.pause_action,0,3)
self.pause_action.setChecked(True)
self.pause_action.clicked.connect(self.pause_PID)
lab = QtWidgets.QLabel('Set Point:')
toolbar_layout.addWidget(lab, 3,0,1,2)
self.setpoint_sb = custom_tree.SpinBoxCustom()
self.setpoint_sb.setMinimumHeight(40)
font = self.setpoint_sb.font()
font.setPointSizeF(20)
self.setpoint_sb.setFont(font)
self.setpoint_sb.setDecimals(6)
toolbar_layout.addWidget(self.setpoint_sb,3,2,1,2)
self.setpoint_sb.valueChanged.connect(self.settings.child('main_settings', 'pid_controls', 'set_point').setValue)
lab1 = QtWidgets.QLabel('Current Point:')
toolbar_layout.addWidget(lab1, 4,0,1,2)
self.currpoint_sb = custom_tree.SpinBoxCustom()
self.currpoint_sb.setMinimumHeight(40)
self.currpoint_sb.setReadOnly(True)
self.currpoint_sb.setDecimals(6)
self.currpoint_sb.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
font = self.currpoint_sb.font()
font.setPointSizeF(20)
self.currpoint_sb.setFont(font)
toolbar_layout.addWidget(self.currpoint_sb,4,2,1,2)
#create main parameter tree
self.settings_tree = ParameterTree()
self.settings_tree.setParameters(self.settings, showTop=False)
verlayout.addWidget(widget_toolbar)
verlayout.addWidget(self.settings_tree)
self.dock_output = Dock('PID output')
widget_output = QtWidgets.QWidget()
self.output_viewer = Viewer0D(widget_output)
self.dock_output.addWidget(widget_output)
self.dock_area.addDock(self.dock_output, 'right')
self.dock_input = Dock('PID input')
widget_input = QtWidgets.QWidget()
self.input_viewer = Viewer0D(widget_input)
self.dock_input.addWidget(widget_input)
self.dock_area.addDock(self.dock_input, 'bottom',self.dock_output)
if len(self.models) != 0:
self.get_set_model_params(self.models[0])
#connecting from tree
self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)#any changes on the settings will update accordingly the detector
self.dock_pid.addWidget(widget)
def get_set_model_params(self, model_file):
self.settings.child('models', 'model_params').clearChildren()
model = importlib.import_module('.' + model_file, self.model_mod.__name__+'.models')
model_class = getattr(model, model_file)
params = getattr(model_class, 'params')
self.settings.child('models', 'model_params').addChildren(params)
def run_PID(self):
if self.run_action.isChecked():
self.run_action.setIcon(self.icon_stop)
self.command_pid.emit(ThreadCommand('start_PID', [self.model_class.curr_input]))
QtWidgets.QApplication.processEvents()
QtWidgets.QApplication.processEvents()
self.command_pid.emit(ThreadCommand('run_PID', [self.model_class.curr_output]))
else:
self.run_action.setIcon(self.iconrun)
self.command_pid.emit(ThreadCommand('stop_PID'))
QtWidgets.QApplication.processEvents()
def pause_PID(self):
self.command_pid.emit(ThreadCommand('pause_PID', [self.pause_action.isChecked()]))
def update_status(self,txt,log_type=None):
"""
Show the txt message in the status bar with a delay of wait_time ms.
=============== =========== =======================
**Parameters** **Type** **Description**
*txt* string The message to show
*wait_time* int the delay of showing
*log_type* string the type of the log
=============== =========== =======================
"""
try:
if log_type is not None:
self.log_signal.emit(txt)
logging.info(txt)
except Exception as e:
pass
@pyqtSlot(str)
def add_log(self,txt):
"""
Add the QListWisgetItem initialized with txt informations to the User Interface logger_list and to the save_parameters.logger array.
=============== =========== ======================
**Parameters** **Type** **Description**
*txt* string the log info to add.
=============== =========== ======================
"""
try:
now=datetime.datetime.now()
new_item=QtWidgets.QListWidgetItem(now.strftime('%Y/%m/%d %H:%M:%S')+": "+txt)
self.logger_list.addItem(new_item)
except:
pass
def set_file_preset(self,model):
"""
Set a file managers from the converted xml file given by the filename parameter.
=============== =========== ===================================================
**Parameters** **Type** **Description**
*filename* string the name of the xml file to be converted/treated
=============== =========== ===================================================
Returns
-------
(Object list, Object list) tuple
The updated (Move modules list, Detector modules list).
See Also
--------
custom_tree.XML_file_to_parameter, set_param_from_param, stop_moves, update_status,DAQ_Move_main.daq_move, DAQ_viewer_main.daq_viewer
"""
filename = os.path.join(get_set_pid_path(), model + '.xml')
self.preset_file = filename
self.preset_manager.set_file_preset(filename, show=False)
self.move_docks = []
self.det_docks_settings = []
self.det_docks_viewer = []
move_forms = []
actuator_modules = []
detector_modules = []
move_types = []
#################################################################
###### sort plugins by IDs and within the same IDs by Master and Slave status
plugins=[{'type': 'move', 'value': child} for child in self.preset_manager.preset_params.child(('Moves')).children()]+[{'type': 'det', 'value': child} for child in self.preset_manager.preset_params.child(('Detectors')).children()]
for plug in plugins:
plug['ID']=plug['value'].child('params','main_settings','controller_ID').value()
if plug["type"]=='det':
plug['status']=plug['value'].child('params','detector_settings','controller_status').value()
else:
plug['status']=plug['value'].child('params','move_settings', 'multiaxes', 'multi_status').value()
IDs=list(set([plug['ID'] for plug in plugins]))
#%%
plugins_sorted=[]
for id in IDs:
plug_Ids=[]
for plug in plugins:
if plug['ID']==id:
plug_Ids.append(plug)
plug_Ids.sort(key=lambda status: status['status'])
plugins_sorted.append(plug_Ids)
#################################################################
#######################
ind_move=-1
ind_det=-1
for plug_IDs in plugins_sorted:
for ind_plugin, plugin in enumerate(plug_IDs):
plug_name=plugin['value'].child(('name')).value()
plug_init=plugin['value'].child(('init')).value()
plug_settings=plugin['value'].child(('params'))
if plugin['type'] == 'move':
ind_move+=1
plug_type=plug_settings.child('main_settings','move_type').value()
self.move_docks.append(Dock(plug_name, size=(150,250)))
if ind_move==0:
self.dock_area.addDock(self.move_docks[-1], 'top',self.logger_dock)
else:
self.dock_area.addDock(self.move_docks[-1], 'above',self.move_docks[-2])
move_forms.append(QtWidgets.QWidget())
mov_mod_tmp=DAQ_Move(move_forms[-1],plug_name)
mov_mod_tmp.ui.Stage_type_combo.setCurrentText(plug_type)
mov_mod_tmp.ui.Quit_pb.setEnabled(False)
QtWidgets.QApplication.processEvents()
set_param_from_param(mov_mod_tmp.settings,plug_settings)
QtWidgets.QApplication.processEvents()
mov_mod_tmp.bounds_signal[bool].connect(self.stop_moves)
self.move_docks[-1].addWidget(move_forms[-1])
actuator_modules.append(mov_mod_tmp)
try:
if ind_plugin==0: #should be a master type plugin
if plugin['status']!="Master":
raise Exception('error in the master/slave type for plugin {}'.format(plug_name))
if plug_init:
actuator_modules[-1].ui.IniStage_pb.click()
QtWidgets.QApplication.processEvents()
if 'Mock' in plug_type:
QThread.msleep(500)
else:
QThread.msleep(4000) # to let enough time for real hardware to init properly
QtWidgets.QApplication.processEvents()
master_controller=actuator_modules[-1].controller
else:
if plugin['status']!="Slave":
raise Exception('error in the master/slave type for plugin {}'.format(plug_name))
if plug_init:
actuator_modules[-1].controller=master_controller
actuator_modules[-1].ui.IniStage_pb.click()
QtWidgets.QApplication.processEvents()
if 'Mock' in plug_type:
QThread.msleep(500)
else:
QThread.msleep(4000) # to let enough time for real hardware to init properly
QtWidgets.QApplication.processEvents()
except Exception as e:
self.update_status(getLineInfo()+ str(e),'log')
else:
ind_det+=1
plug_type=plug_settings.child('main_settings','DAQ_type').value()
plug_subtype=plug_settings.child('main_settings','detector_type').value()
self.det_docks_settings.append(Dock(plug_name+" settings", size=(150,250)))
self.det_docks_viewer.append(Dock(plug_name+" viewer", size=(350,350)))
if ind_det==0:
self.logger_dock.area.addDock(self.det_docks_settings[-1], 'bottom', self.dock_input) #dock_area of the logger dock
else:
self.dock_area.addDock(self.det_docks_settings[-1], 'bottom',self.det_docks_settings[-2])
self.dock_area.addDock(self.det_docks_viewer[-1],'right',self.det_docks_settings[-1])
det_mod_tmp=DAQ_Viewer(self.dock_area,dock_settings=self.det_docks_settings[-1],
dock_viewer=self.det_docks_viewer[-1],title=plug_name,
DAQ_type=plug_type, parent_scan=self)
detector_modules.append(det_mod_tmp)
detector_modules[-1].ui.Detector_type_combo.setCurrentText(plug_subtype)
detector_modules[-1].ui.Quit_pb.setEnabled(False)
set_param_from_param(det_mod_tmp.settings,plug_settings)
QtWidgets.QApplication.processEvents()
try:
if ind_plugin==0: #should be a master type plugin
if plugin['status']!="Master":
raise Exception('error in the master/slave type for plugin {}'.format(plug_name))
if plug_init:
detector_modules[-1].ui.IniDet_pb.click()
QtWidgets.QApplication.processEvents()
if 'Mock' in plug_subtype:
QThread.msleep(500)
else:
QThread.msleep(4000) # to let enough time for real hardware to init properly
QtWidgets.QApplication.processEvents()
master_controller=detector_modules[-1].controller
else:
if plugin['status']!="Slave":
raise Exception('error in the master/slave type for plugin {}'.format(plug_name))
if plug_init:
detector_modules[-1].controller=master_controller
detector_modules[-1].ui.IniDet_pb.click()
QtWidgets.QApplication.processEvents()
if 'Mock' in plug_subtype:
QThread.msleep(500)
else:
QThread.msleep(4000) # to let enough time for real hardware to init properly
QtWidgets.QApplication.processEvents()
except Exception as e:
self.update_status(getLineInfo()+ str(e),'log')
detector_modules[-1].settings.child('main_settings','overshoot').show()
detector_modules[-1].overshoot_signal[bool].connect(self.stop_moves)
QtWidgets.QApplication.processEvents()
return actuator_modules,detector_modules
pyqtSlot(bool)
def stop_moves(self,overshoot):
"""
Foreach module of the move module object list, stop motion.
See Also
--------
stop_scan, DAQ_Move_main.daq_move.stop_Motion
"""
self.overshoot = overshoot
for mod in self.actuator_modules:
mod.stop_Motion()
def set_default_preset(self):
actuators = self.model_class.actuators
actuator_names = self.model_class.actuators_name
detectors_type = self.model_class.detectors_type
detectors = self.model_class.detectors
detectors_name = self.model_class.detectors_name
detector_modules = []
for ind_det, det in enumerate(detectors):
detector_modules.append(DAQ_Viewer(area, title=detectors_name[ind_det], DAQ_type=detectors_type[ind_det]))
#self.detector_modules[-1].ui.IniDet_pb.click()
QtWidgets.QApplication.processEvents()
detector_modules[-1].ui.Detector_type_combo.setCurrentText(detectors[ind_det])
detector_modules[-1].ui.Quit_pb.setEnabled(False)
self.dock_area.addDock(self.dock_output, 'bottom')
self.dock_area.moveDock(self.dock_input, 'bottom', self.dock_output)
self.dock_area.addDock(self.dock_pid, 'left')
dock_moves = []
actuator_modules = []
for ind_act, act in enumerate(actuators):
form = QtWidgets.QWidget()
dock_moves.append(Dock(actuator_names[ind_act]))
area.addDock(dock_moves[-1], 'bottom', self.dock_pid)
dock_moves[-1].addWidget(form)
actuator_modules.append(DAQ_Move(form))
QtWidgets.QApplication.processEvents()
actuator_modules[-1].ui.Stage_type_combo.setCurrentText(actuators[ind_act])
actuator_modules[-1].ui.Quit_pb.setEnabled(False)
#self.actuator_modules[-1].ui.IniStage_pb.click()
#QThread.msleep(1000)
QtWidgets.QApplication.processEvents()
return actuator_modules, detector_modules
def ini_model(self):
try:
model_name = self.settings.child('models', 'model_class').value()
model = importlib.import_module('.' +model_name, self.model_mod.__name__+'.models')
self.model_class = getattr(model, model_name)(self)
#try to get corresponding managers file
filename = os.path.join(get_set_pid_path(), model_name + '.xml')
if os.path.isfile(filename):
self.actuator_modules, self.detector_modules = self.set_file_preset(model_name)
else:
self.actuator_modules, self.detector_modules = self.set_default_preset()
# # connecting to logger
# for mov in self.actuator_modules:
# mov.log_signal[str].connect(self.add_log)
# for det in self.detector_modules:
# det.log_signal[str].connect(self.add_log)
# self.log_signal[str].connect(self.add_log)
self.model_class.ini_model()
self.enable_controls_pid(True)
self.model_led.set_as_true()
self.ini_model_action.setEnabled(False)
except Exception as e:
self.update_status(getLineInfo() + str(e), log_type='log')
def quit_fun(self):
"""
"""
try:
try:
self.PIDThread.exit()
except Exception as e:
print(e)
for module in self.actuator_modules:
try:
module.quit_fun()
QtWidgets.QApplication.processEvents()
QThread.msleep(1000)
QtWidgets.QApplication.processEvents()
except Exception as e:
print(e)
for module in self.detector_modules:
try:
module.stop_all()
QtWidgets.QApplication.processEvents()
module.quit_fun()
QtWidgets.QApplication.processEvents()
QThread.msleep(1000)
QtWidgets.QApplication.processEvents()
except Exception as e:
print(e)
areas=self.dock_area.tempAreas[:]
for area in areas:
area.win.close()
QtWidgets.QApplication.processEvents()
QThread.msleep(1000)
QtWidgets.QApplication.processEvents()
self.dock_area.parent().close()
except Exception as e:
print(e)
def parameter_tree_changed(self,param,changes):
"""
Foreach value changed, update :
* Viewer in case of **DAQ_type** parameter name
* visibility of button in case of **show_averaging** parameter name
* visibility of naverage in case of **live_averaging** parameter name
* scale of axis **else** (in 2D pymodaq type)
Once done emit the update settings signal to link the commit.
=============== =================================== ================================================================
**Parameters** **Type** **Description**
*param* instance of ppyqtgraph parameter the parameter to be checked
*changes* tuple list Contain the (param,changes,info) list listing the changes made
=============== =================================== ================================================================
See Also
--------
change_viewer, daq_utils.custom_parameter_tree.iter_children
"""
for param, change, data in changes:
path = self.settings.childPath(param)
if change == 'childAdded':
pass
elif change == 'value':
if param.name() == 'model_class':
self.get_set_model_params(param.value())
elif param.name() == 'module_settings':
if param.value():
self.settings.sigTreeStateChanged.disconnect( self.parameter_tree_changed)
param.setValue(False)
self.settings.sigTreeStateChanged.connect( self.parameter_tree_changed)
self.preset_manager.set_PID_preset(self.settings.child('models','model_class').value())
elif param.name() == 'refresh_plot_time' or param.name() == 'timeout':
self.command_pid.emit(ThreadCommand('update_timer', [param.name(),param.value()]))
elif param.name() == 'set_point':
if self.pid_led.state:
self.command_pid.emit(ThreadCommand('update_options', dict(setpoint=param.value())))
else:
output = self.model_class.convert_output(param.value(),0, stab=False)
for ind_act, act in enumerate(self.actuator_modules):
act.move_Abs(output[ind_act])
elif param.name() == 'sample_time':
self.command_pid.emit(ThreadCommand('update_options', dict(sample_time=param.value())))
elif param.name() in custom_tree.iter_children(self.settings.child('main_settings', 'pid_controls', 'output_limits'), []):
output_limits = [None, None]
if self.settings.child('main_settings', 'pid_controls', 'output_limits', 'output_limit_min_enabled').value():
output_limits[0] = self.settings.child('main_settings', 'pid_controls', 'output_limits', 'output_limit_min').value()
if self.settings.child('main_settings', 'pid_controls', 'output_limits', 'output_limit_max_enabled').value():
output_limits[1] = self.settings.child('main_settings', 'pid_controls', 'output_limits', 'output_limit_max').value()
self.command_pid.emit(ThreadCommand('update_options', dict(output_limits=output_limits)))
elif param.name() in custom_tree.iter_children(self.settings.child('main_settings', 'pid_controls', 'filter'), []):
self.command_pid.emit(ThreadCommand('update_filter',
[dict(enable=self.settings.child('main_settings', 'pid_controls', 'filter', 'filter_enable').value(),
value=self.settings.child('main_settings', 'pid_controls', 'filter', 'filter_step').value())]))
elif param.name() in custom_tree.iter_children(self.settings.child('main_settings', 'pid_controls', 'pid_constants'), []):
Kp = self.settings.child('main_settings', 'pid_controls', 'pid_constants', 'kp').value()
Ki = self.settings.child('main_settings', 'pid_controls', 'pid_constants', 'ki').value()
Kd = self.settings.child('main_settings', 'pid_controls', 'pid_constants', 'kd').value()
self.command_pid.emit(ThreadCommand('update_options', dict(tunings= (Kp, Ki, Kd))))
elif param.name() in custom_tree.iter_children(self.settings.child('models', 'model_params'),[]):
self.model_class.update_settings(param)
elif param.name() == 'detector_modules':
self.model_class.update_detector_names()
elif change == 'parent':
pass
@pyqtSlot(list)
def thread_status(self,status): # general function to get datas/infos from all threads back to the main
"""
| General function to get datas/infos from all threads back to the main.
|
Switch the status with :
* *"Update status"* : Update the status bar with the status attribute txt message
"""
if status[0]=="Update_Status":
self.update_status(status[1],log_type=status[2])
class Spectrometer(QObject):
"""
Defines a Spectrometer object, unified interface for many spectrometers
Parameters that could be set in the selected detector plugin (should be defined there):
'laser_wl' : value of the configured laser (could eventually be changed, case of Xplora, Labram...)
'spectro_center_freq': value of the configured grating center wavelength (could eventually be changed, case of Shamrock, Xplora...)
"""
#custom signal that will be fired sometimes. Could be connected to an external object method or an internal method
log_signal = Signal(str)
#list of dicts enabling the settings tree on the user interface
params = [
{
'title':
'Configuration settings:',
'name':
'config_settings',
'type':
'group',
'children': [
{
'title': 'Laser wavelength (nm):',
'name': 'laser_wl',
'type': 'float',
'value': 515.
},
{
'title': 'Laser wavelength (nm):',
'name': 'laser_wl_list',
'type': 'list',
'limits': ['']
},
{
'title': 'Current Detector:',
'name': 'curr_det',
'type': 'str',
'value': ''
},
{
'title': 'Show detector:',
'name': 'show_det',
'type': 'bool',
'value': False
},
],
},
{
'title':
'Calibration settings:',
'name':
'calib_settings',
'type':
'group',
'children': [
{
'title': 'Use calibration:',
'name': 'use_calib',
'type': 'bool',
'value': False
},
{
'title': 'Save calibration',
'name': 'save_calib',
'type': 'bool_push',
'value': False
},
{
'title': 'Load calibration',
'name': 'load_calib',
'type': 'bool_push',
'value': False
},
{
'title':
'Calibration coeffs:',
'name':
'calib_coeffs',
'type':
'group',
'children': [
{
'title': 'Center wavelength (nm):',
'name': 'center_calib',
'type': 'float',
'value': 515.
},
{
'title': 'Slope (nm/pxl):',
'name': 'slope_calib',
'type': 'float',
'value': 1.
},
{
'title': 'Second order :',
'name': 'second_calib',
'type': 'float',
'value': 0
},
{
'title': 'third:',
'name': 'third_calib',
'type': 'float',
'value': 0
},
]
},
{
'title': 'Perform calibration:',
'name': 'do_calib',
'type': 'bool',
'value': False
},
]
},
{
'title':
'Acquisition settings:',
'name':
'acq_settings',
'type':
'group',
'children': [
{
'title': 'Spectro. Center:',
'name': 'spectro_center_freq',
'type': 'float',
'value': 800,
},
{
'title': 'Spectro. Center:',
'name': 'spectro_center_freq_txt',
'type': 'str',
'value': '????',
'readonly': True
},
{
'title': 'Units:',
'name': 'units',
'type': 'list',
'value': 'nm',
'limits': ['nm', 'cm-1', 'eV']
},
{
'title': 'Exposure (ms):',
'name': 'exposure_ms',
'type': 'float',
'value': 100,
},
]
},
]
def __init__(self, parent):
QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedStates))
super().__init__()
if not isinstance(parent, DockArea):
raise Exception('no valid parent container, expected a DockArea')
self.wait_time = 2000 #ms
self.offline = True
self.dockarea = parent
self.mainwindow = parent.parent()
self.spectro_widget = QtWidgets.QWidget()
self.data_dict = None
"""
List of the possible plugins that could be used with Spectrometer module
type : dimensionality of the detector
name: name of the plugin
calib = True means there is a builtin calibration of the frequency axis
movable : tells if the dispersion can be set (for instance by moving a grating)
unit: valid only if calib is True. Unit of the calibration axis (x_axis of the detector), most often in
nanometers. Possible values are 'nm', 'radfs' (rad/femtosecond), 'eV'
laser: if False, laser cannot be changed by the program, do it manually
laser_list: if laser is True, laser_list gives a list of selectable lasers
"""
self.current_det = None # will be after initialization
self.laser_set_manual = True
#init the object parameters
self.detector = None
self.save_file_pathname = None
self._spectro_wl = 550 # center wavelngth of the spectrum
self.viewer_freq_axis = utils.Axis(data=None,
label='Photon energy',
units='')
self.raw_data = []
#init the user interface
self.dashboard = self.set_dashboard()
self.dashboard.preset_loaded_signal.connect(
lambda: self.show_detector(False))
self.dashboard.preset_loaded_signal.connect(self.set_detector)
self.dashboard.preset_loaded_signal.connect(self.initialized)
self.set_GUI()
self.dashboard.new_preset_created.connect(
lambda: self.create_menu(self.menubar))
self.show_detector(False)
self.dockarea.setEnabled(False)
def set_dashboard(self):
params = [
{
'title':
'Spectro Settings:',
'name':
'spectro_settings',
'type':
'group',
'children': [
{
'title':
'Is calibrated?',
'name':
'iscalibrated',
'type':
'bool',
'value':
False,
'tooltip':
'Whether the selected plugin has internal frequency calibration or not.'
},
{
'title':
'Movable?',
'name':
'ismovable',
'type':
'bool',
'value':
False,
'tooltip':
'Whether the selected plugin has a functionality to change its central frequency: as a movable grating'
' for instance.'
},
{
'title':
'Laser selectable?',
'name':
'laser_selectable',
'type':
'bool',
'value':
False,
'tooltip':
'Whether the selected plugin has a functionality to change its excitation ray'
},
{
'title': 'Laser ray:',
'name': 'laser_ray',
'type': 'list',
'value': '',
'show_pb': True,
'tooltip':
'List of settable laser rays (not manual ones)'
},
]
},
]
dashboard = DashBoard(self.dockarea.addTempArea())
dashboard.set_preset_path(spectro_path)
options = [
dict(path='saving_options', options_dict=dict(visible=False)),
dict(path='use_pid', options_dict=dict(visible=False)),
dict(path='Moves', options_dict=dict(visible=False))
]
dashboard.set_extra_preset_params(params, options)
dashboard.dockarea.window().setVisible(False)
return dashboard
def set_GUI(self):
###########################################
###########################################
#init the docks containing the main widgets
#######################################################################################################################
#create a dock containing a viewer object, displaying the data for the spectrometer
self.dock_viewer = Dock('Viewer dock', size=(350, 350))
self.dockarea.addDock(self.dock_viewer, 'left')
target_widget = QtWidgets.QWidget()
self.viewer = Viewer1D(target_widget)
self.dock_viewer.addWidget(target_widget)
################################################################
#create a logger dock where to store info senf from the programm
self.dock_logger = Dock("Logger")
self.logger_list = QtWidgets.QListWidget()
self.logger_list.setMinimumWidth(300)
self.dock_logger.addWidget(self.logger_list)
self.dockarea.addDock(self.dock_logger, 'right')
self.log_signal[str].connect(self.add_log)
############################################
# creating a menubar
self.menubar = self.mainwindow.menuBar()
self.create_menu(self.menubar)
#creating a toolbar
self.toolbar = QtWidgets.QToolBar()
self.create_toolbar()
self.mainwindow.addToolBar(self.toolbar)
#creating a status bar
self.statusbar = QtWidgets.QStatusBar()
self.statusbar.setMaximumHeight(25)
self.status_laser = QtWidgets.QLabel('????')
self.status_laser.setAlignment(Qt.AlignCenter)
#self.status_laser.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
#self.status_laser.setReadOnly(True)
self.status_laser.setMaximumWidth(80)
self.status_laser.setMinimumWidth(80)
self.status_laser.setToolTip('Current laser wavelength')
self.status_laser.setStyleSheet("background-color: red")
self.status_center = QtWidgets.QLabel('????')
self.status_center.setAlignment(Qt.AlignCenter)
#self.status_center.setReadOnly(True)
#self.status_center.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
self.status_center.setMaximumWidth(80)
self.status_center.setMinimumWidth(80)
self.status_center.setToolTip(
'center frequency of the spectrum, either in nm or cm-1')
self.status_center.setStyleSheet("background-color: red")
self.status_init = QLED()
self.status_init.setToolTip('Initialization state of the detector')
self.status_init.set_as_false()
self.status_init.clickable = False
self.statusbar.addPermanentWidget(self.status_laser)
self.statusbar.addPermanentWidget(self.status_center)
self.statusbar.addPermanentWidget(self.status_init)
self.dockarea.window().setStatusBar(self.statusbar)
#############################################
self.settings = Parameter.create(name='settings',
type='group',
children=self.params)
self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
dock_config_settings = Dock('Configuration', size=(300, 350))
self.dockarea.addDock(dock_config_settings, 'above', self.dock_logger)
# create main parameter tree
self.config_settings_tree = ParameterTree()
dock_config_settings.addWidget(self.config_settings_tree, 10)
self.config_settings_tree.setMinimumWidth(300)
self.config_settings_tree.setParameters(self.settings.child(
('config_settings')),
showTop=False)
#any change to the tree on the user interface will call the parameter_tree_changed method where all actions will be applied
dock_calib_settings = Dock('Calibration', size=(300, 350))
self.dockarea.addDock(dock_calib_settings, 'above', self.dock_logger)
# create main parameter tree
self.calib_settings_tree = ParameterTree()
dock_calib_settings.addWidget(self.calib_settings_tree, 10)
self.calib_settings_tree.setMinimumWidth(300)
self.calib_settings_tree.setParameters(self.settings.child(
('calib_settings')),
showTop=False)
#any change to the tree on the user interface will call the parameter_tree_changed method where all actions will be applied
#this one for the custom application settings
dock_acq_settings = Dock('Acquisition', size=(300, 350))
self.dockarea.addDock(dock_acq_settings, 'above', dock_config_settings)
# create main parameter tree
self.acq_settings_tree = ParameterTree()
dock_acq_settings.addWidget(self.acq_settings_tree, 10)
self.acq_settings_tree.setMinimumWidth(300)
self.acq_settings_tree.setParameters(self.settings.child(
('acq_settings')),
showTop=False)
@Slot(ThreadCommand)
def cmd_from_det(self, status):
try:
if status.command == 'spectro_wl':
self.status_center.setStyleSheet("background-color: green")
self.spectro_wl_is(status.attributes[0])
elif status.command == 'laser_wl':
#self.laser_set_manual = False
self.settings.child('config_settings',
'laser_wl_list').setValue(
status.attributes[0])
self.status_laser.setText('{:}nm'.format(status.attributes[0]))
self.status_laser.setStyleSheet("background-color: green")
self.update_center_frequency(self.spectro_wl)
elif status.command == 'exposure_ms':
self.settings.child('acq_settings', 'exposure_ms').setValue(
status.attributes[0])
elif status.command == "x_axis":
x_axis = status.attributes[0]
if np.any(x_axis['data'] != self.viewer_freq_axis['data']
) and self.current_det['calib']:
self.viewer_freq_axis.update(x_axis)
self.update_axis()
except Exception as e:
logger.exception(str(e))
def update_status(self, txt, wait_time=1000, log_type=None):
"""
"""
self.statusbar.showMessage(txt, wait_time)
if log_type is not None:
self.log_signal.emit(txt)
def set_detector(self):
self.detector = self.dashboard.detector_modules[0]
self.settings.child('config_settings', 'curr_det').setValue(
f"{self.detector.settings.child('main_settings','DAQ_type').value()} / "
f"{self.detector.settings.child('main_settings','detector_type').value()} / {self.detector.title}"
)
self.detector.custom_sig[ThreadCommand].connect(self.cmd_from_det)
self.current_det = \
dict(laser=self.dashboard.preset_manager.preset_params.child('spectro_settings', 'laser_selectable').value(),
laser_list=self.dashboard.preset_manager.preset_params.child('spectro_settings', 'laser_ray').opts['limits'],
movable=self.dashboard.preset_manager.preset_params.child('spectro_settings', 'ismovable').value(),
calib=self.dashboard.preset_manager.preset_params.child('spectro_settings', 'iscalibrated').value(),
)
self.detector.grab_done_signal.connect(self.show_data)
self.settings.sigTreeStateChanged.disconnect(
self.parameter_tree_changed)
if self.current_det['laser']:
self.settings.child('config_settings', 'laser_wl_list').show()
self.settings.child('config_settings', 'laser_wl').hide()
self.settings.child(
'config_settings',
'laser_wl_list').setOpts(limits=self.current_det['laser_list'])
else:
self.settings.child('config_settings', 'laser_wl').show()
self.settings.child('config_settings', 'laser_wl_list').hide()
self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
#apply current detector particularities
#self.settings.child('acq_settings', 'spectro_center_freq').setOpts(readonly=not self.current_det['movable'])
self.get_spectro_wl()
QtWidgets.QApplication.processEvents()
self.get_laser_wl()
QtWidgets.QApplication.processEvents()
self.get_exposure_ms()
QtWidgets.QApplication.processEvents()
def get_exposure_ms(self):
self.detector.command_detector.emit(ThreadCommand('get_exposure_ms'))
def set_exposure_ms(self, data):
self.detector.command_detector.emit(
ThreadCommand('set_exposure_ms', [data]))
@Slot(bool)
def initialized(self, state, offline=False):
self.offline = offline
self.grab_action.setEnabled(state)
self.snap_action.setEnabled(state)
if state or offline:
self.status_init.set_as_true()
self.dockarea.setEnabled(True)
else:
self.status_init.set_as_false()
def update_center_frequency(self, spectro_wl):
self._spectro_wl = spectro_wl
if self.settings.child('acq_settings', 'units').value() == 'nm':
self.settings.child('acq_settings',
'spectro_center_freq').setValue(spectro_wl)
elif self.settings.child('acq_settings', 'units').value() == 'cm-1':
self.settings.child('acq_settings',
'spectro_center_freq').setValue(
Enm2cmrel(
spectro_wl,
self.settings.child(
'config_settings',
'laser_wl').value()))
elif self.settings.child('acq_settings', 'units').value() == 'eV':
self.settings.child('acq_settings',
'spectro_center_freq').setValue(
nm2eV(spectro_wl))
self.set_status_center(
self.settings.child('acq_settings', 'spectro_center_freq').value(),
self.settings.child('acq_settings', 'units').value())
def set_status_center(self, val, unit, precision=3):
self.status_center.setText(f'{val:.{precision}f} {unit}')
def spectro_wl_is(self, spectro_wl):
"""
this slot receives a signal from the detector telling it what's the current spectro_wl
Parameters
----------
spectro_wl
"""
self._spectro_wl = spectro_wl
self.update_center_frequency(spectro_wl)
def set_spectro_wl(self, spectro_wl):
try:
if self.current_det['movable']:
self.detector.command_detector.emit(
ThreadCommand('set_spectro_wl', [spectro_wl]))
except Exception as e:
logger.exception(str(e))
def get_spectro_wl(self):
if self.current_det['calib']:
self.settings.child('acq_settings', 'spectro_center_freq').show()
self.settings.child('acq_settings',
'spectro_center_freq_txt').hide()
self.detector.command_detector.emit(
ThreadCommand('get_spectro_wl'))
self.detector.command_detector.emit(ThreadCommand('get_axis'))
else:
self.settings.child('acq_settings', 'spectro_center_freq').hide()
self.settings.child('acq_settings',
'spectro_center_freq_txt').show()
self.viewer_freq_axis['units'] = 'Pxls'
def get_laser_wl(self):
if self.current_det['laser']:
self.detector.command_detector.emit(ThreadCommand('get_laser_wl'))
else:
self.settings.child('config_settings', 'laser_wl').setValue(0)
@property
def spectro_wl(self):
# try to get the param value from detector (if it has been added in the plugin)
return self._spectro_wl
@spectro_wl.setter
def spectro_wl(self, spec_wl):
# try to get the param value from detector (if it has been added in the plugin)
self.set_spectro_wl(spec_wl)
def show_detector(self, show=True):
self.dashboard.mainwindow.setVisible(show)
for area in self.dashboard.dockarea.tempAreas:
area.window().setVisible(show)
def parameter_tree_changed(self, param, changes):
for param, change, data in changes:
path = self.settings.childPath(param)
if path is not None:
childName = '.'.join(path)
else:
childName = param.name()
if change == 'childAdded':
pass
elif change == 'value':
if param.name() == 'show_det':
self.show_detector(data)
elif param.name() == 'spectro_center_freq':
unit = self.settings.child('acq_settings', 'units').value()
if unit == 'nm':
center_wavelength = data
elif unit == 'cm-1':
center_wavelength = Ecmrel2Enm(
data,
self.settings.child('config_settings',
'laser_wl').value())
elif unit == 'eV':
center_wavelength = eV2nm(data)
if int(self.spectro_wl * 100) != int(
100 * center_wavelength): #comprison at 1e-2
self.spectro_wl = center_wavelength
self.update_axis()
elif param.name() == 'units':
if self.settings.child(
'acq_settings',
'spectro_center_freq').value() > 0.000000001:
if data == 'nm':
self.settings.child(
'acq_settings',
'spectro_center_freq').setValue(
self._spectro_wl)
elif data == 'cm-1':
self.settings.child(
'acq_settings',
'spectro_center_freq').setValue(
Enm2cmrel(
self._spectro_wl,
self.settings.child(
'config_settings',
'laser_wl').value()))
elif data == 'eV':
self.settings.child(
'acq_settings',
'spectro_center_freq').setValue(
nm2eV(self._spectro_wl))
self.set_status_center(
self.settings.child('acq_settings',
'spectro_center_freq').value(),
self.settings.child('acq_settings',
'units').value())
elif param.name() == 'laser_wl_list':
if data is not None:
self.move_laser_wavelength(data)
elif param.name() == 'laser_wl':
if data is not None:
self.move_laser_wavelength(data)
if int(data) == 0:
self.settings.child('acq_settings',
'units').setValue('nm')
self.settings.child('acq_settings',
'units').setOpts(readonly=True)
else:
self.settings.child(
'acq_settings',
'units').setOpts(readonly=False)
if data != 0:
self.set_manual_laser_wl(data)
elif param.name() == 'exposure_ms':
self.set_exposure_ms(data)
elif param.name() == 'do_calib':
if len(self.raw_data) != 0:
if data:
self.calib_dock = Dock('Calibration module')
self.dockarea.addDock(self.calib_dock)
self.calibration = Calibration(self.dockarea)
self.calib_dock.addWidget(self.calibration)
self.calibration.coeffs_calib.connect(
self.update_calibration)
else:
self.calib_dock.close()
elif param.name() == 'save_calib':
filename = select_file(start_path=self.save_file_pathname,
save=True,
ext='xml')
if filename != '':
custom_tree.parameter_to_xml_file(
self.settings.child('calib_settings',
'calib_coeffs'), filename)
elif param.name() == 'load_calib':
filename = select_file(start_path=self.save_file_pathname,
save=False,
ext='xml')
if filename != '':
children = custom_tree.XML_file_to_parameter(filename)
self.settings.child(
'calib_settings', 'calib_coeffs').restoreState(
Parameter.create(
title='Calibration coeffs:',
name='calib_coeffs',
type='group',
children=children).saveState())
elif param.name() in custom_tree.iter_children(self.settings.child('calib_settings', 'calib_coeffs')) \
or param.name() == 'use_calib':
if self.settings.child('calib_settings',
'use_calib').value():
calib_coeffs = [
self.settings.child('calib_settings',
'calib_coeffs',
'third_calib').value(),
self.settings.child('calib_settings',
'calib_coeffs',
'second_calib').value(),
self.settings.child('calib_settings',
'calib_coeffs',
'slope_calib').value(),
self.settings.child('calib_settings',
'calib_coeffs',
'center_calib').value()
]
self.update_center_frequency(
self.settings.child('calib_settings',
'calib_coeffs',
'center_calib').value())
self.settings.child('acq_settings',
'spectro_center_freq').show()
self.settings.child(
'acq_settings',
'spectro_center_freq').setOpts(readonly=True)
self.status_center.setStyleSheet(
"background-color: green")
self.settings.child('acq_settings',
'spectro_center_freq_txt').hide()
x_axis_pxls = np.linspace(0, self.raw_data[0].size - 1,
self.raw_data[0].size)
self.viewer_freq_axis['data'] = np.polyval(
calib_coeffs,
x_axis_pxls - np.max(x_axis_pxls) / 2)
self.update_axis()
else:
self.settings.child('acq_settings',
'spectro_center_freq').hide()
self.settings.child('acq_settings',
'spectro_center_freq_txt').show()
self.status_center.setStyleSheet(
"background-color: red")
elif change == 'parent':
pass
@Slot(list)
def update_calibration(self, coeffs):
self.settings.child('calib_settings', 'calib_coeffs',
'center_calib').setValue(coeffs[0])
self.settings.child('calib_settings', 'calib_coeffs',
'slope_calib').setValue(coeffs[1])
if len(coeffs) > 2:
self.settings.child('calib_settings', 'calib_coeffs',
'second_calib').setValue(coeffs[2])
else:
self.settings.child('calib_settings', 'calib_coeffs',
'second_calib').setValue(0)
if len(coeffs) > 3:
self.settings.child('calib_settings', 'calib_coeffs',
'third_calib').setValue(coeffs[3])
else:
self.settings.child('calib_settings', 'calib_coeffs',
'third_calib').setValue(0)
def set_manual_laser_wl(self, laser_wl):
messg = QtWidgets.QMessageBox()
messg.setText(
'You manually changed the laser wavelength to {:}nm!'.format(
laser_wl))
messg.setInformativeText("Is that correct?")
messg.setStandardButtons(QtWidgets.QMessageBox.Yes
| QtWidgets.QMessageBox.No)
ret = messg.exec()
if ret == QtWidgets.QMessageBox.Yes:
self.status_laser.setText('{:}nm'.format(laser_wl))
self.status_laser.setStyleSheet("background-color: green")
self.settings.child('acq_settings',
'units').setOpts(readonly=False)
def move_laser_wavelength(self, laser_wavelength):
#do hardware stuff if possible (Mock, labspec...)
try:
if self.current_det['laser']:
self.detector.command_detector.emit(
ThreadCommand('set_laser_wl', [laser_wavelength]))
except Exception as e:
logger.exception(str(e))
@Slot(OrderedDict)
def show_data(self, data):
"""
do stuff with data from the detector if its grab_done_signal has been connected
Parameters
----------
data: (OrderedDict) #OrderedDict(name=self.title,x_axis=None,y_axis=None,z_axis=None,data0D=None,data1D=None,data2D=None)
"""
self.data_dict = data
if 'data1D' in data:
self.raw_data = []
for key in data['data1D']:
self.raw_data.append(data['data1D'][key]['data'])
if 'x_axis' in data['data1D'][key]:
x_axis = data['data1D'][key]['x_axis']
else:
x_axis = utils.Axis(data=np.linspace(
0,
len(data['data1D'][key]['data']) - 1,
len(data['data1D'][key]['data'])),
units='pxls',
label='')
if self.viewer_freq_axis['data'] is None:
self.viewer_freq_axis.update(x_axis)
elif np.any(x_axis['data'] != self.viewer_freq_axis['data']
) and self.current_det['calib']:
self.viewer_freq_axis.update(x_axis)
self.viewer.show_data(self.raw_data)
self.update_axis()
def update_axis(self):
axis = utils.Axis()
unit = self.settings.child('acq_settings', 'units').value()
if unit == 'nm':
axis['data'] = self.viewer_freq_axis['data']
elif unit == 'cm-1':
axis['data'] = Enm2cmrel(
self.viewer_freq_axis['data'],
self.settings.child('config_settings', 'laser_wl').value())
elif unit == 'eV':
axis['data'] = nm2eV(self.viewer_freq_axis['data'])
axis['units'] = unit
axis['label'] = 'Photon energy'
self.viewer.x_axis = axis
def create_menu(self, menubar):
"""
"""
menubar.clear()
# %% create file menu
file_menu = menubar.addMenu('File')
load_action = file_menu.addAction('Load file')
load_action.triggered.connect(self.load_file)
save_action = file_menu.addAction('Save file')
save_action.triggered.connect(self.save_data)
export_action = file_menu.addAction('Export as ascii')
export_action.triggered.connect(lambda: self.save_data(export=True))
file_menu.addSeparator()
file_menu.addAction('Show log file', self.show_log)
file_menu.addSeparator()
quit_action = file_menu.addAction('Quit')
quit_action.triggered.connect(self.quit_function)
settings_menu = menubar.addMenu('Settings')
settings_menu.addAction('Show Units Converter',
self.show_units_converter)
docked_menu = settings_menu.addMenu('Docked windows')
docked_menu.addAction('Load Layout', self.load_layout_state)
docked_menu.addAction('Save Layout', self.save_layout_state)
self.preset_menu = menubar.addMenu(self.dashboard.preset_menu)
self.preset_menu.menu().addSeparator()
self.preset_menu.menu().addAction(
'Offline Mode',
lambda: self.initialized(state=False, offline=True))
def load_layout_state(self, file=None):
"""
Load and restore a layout state from the select_file obtained pathname file.
See Also
--------
utils.select_file
"""
try:
if file is None:
file = select_file(save=False, ext='dock')
if file is not None:
with open(str(file), 'rb') as f:
dockstate = pickle.load(f)
self.dockarea.restoreState(dockstate)
file = file.name
self.settings.child('loaded_files', 'layout_file').setValue(file)
except Exception as e:
logger.exception(str(e))
def save_layout_state(self, file=None):
"""
Save the current layout state in the select_file obtained pathname file.
Once done dump the pickle.
See Also
--------
utils.select_file
"""
try:
dockstate = self.dockarea.saveState()
if 'float' in dockstate:
dockstate['float'] = []
if file is None:
file = select_file(start_path=None, save=True, ext='dock')
if file is not None:
with open(str(file), 'wb') as f:
pickle.dump(dockstate, f, pickle.HIGHEST_PROTOCOL)
except Exception as e:
logger.exception(str(e))
def show_log(self):
import webbrowser
webbrowser.open(logging.getLogger('pymodaq').handlers[0].baseFilename)
def show_units_converter(self):
self.units_converter = UnitsConverter()
dock_converter = Dock('Units Converter', size=(300, 350))
self.dockarea.addDock(dock_converter, 'bottom', self.dock_logger)
dock_converter.addWidget(self.units_converter.parent)
def load_file(self):
data, fname, node_path = browse_data(ret_all=True)
if data is not None:
h5utils = H5BrowserUtil()
h5utils.open_file(fname)
data, axes, nav_axes, is_spread = h5utils.get_h5_data(node_path)
data_node = h5utils.get_node(node_path)
if data_node.attrs['type'] == 'data':
if data_node.attrs['data_dimension'] == '1D':
data_dict = OrderedDict(data1D=dict(
raw=dict(data=data, x_axis=axes['x_axis'])))
self.show_data(data_dict)
h5utils.close_file()
def quit_function(self):
#close all stuff that need to be
if self.detector is not None:
self.detector.quit_fun()
QtWidgets.QApplication.processEvents()
self.mainwindow.close()
def create_toolbar(self):
self.toolbar.addWidget(QtWidgets.QLabel('Acquisition:'))
iconquit = QtGui.QIcon()
iconquit.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/close2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.quit_action = QtWidgets.QAction(iconquit, "Quit program", None)
self.toolbar.addAction(self.quit_action)
self.quit_action.triggered.connect(self.quit_function)
iconload = QtGui.QIcon()
iconload.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Open.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.loadaction = QtWidgets.QAction(
iconload, "Load target file (.h5, .png, .jpg) or data from camera",
None)
self.toolbar.addAction(self.loadaction)
self.loadaction.triggered.connect(self.load_file)
iconsave = QtGui.QIcon()
iconsave.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/SaveAs.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.saveaction = QtWidgets.QAction(iconsave, "Save current data",
None)
self.toolbar.addAction(self.saveaction)
self.saveaction.triggered.connect(self.save_data)
iconrun = QtGui.QIcon()
iconrun.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/run2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.grab_action = QtWidgets.QAction(iconrun, 'Grab', None)
self.grab_action.setCheckable(True)
self.toolbar.addAction(self.grab_action)
self.grab_action.triggered.connect(self.grab_detector)
iconsnap = QtGui.QIcon()
iconsnap.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/snap.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.snap_action = QtWidgets.QAction(iconsnap, 'Snap', None)
self.snap_action.triggered.connect(self.snap_detector)
self.toolbar.addAction(self.snap_action)
self.grab_action.setEnabled(False)
self.snap_action.setEnabled(False)
def grab_detector(self):
self.detector.ui.grab_pb.click()
def snap_detector(self):
self.detector.ui.single_pb.click()
def save_data(self, export=False):
try:
if export:
ext = 'dat'
else:
ext = 'h5'
path = select_file(start_path=self.save_file_pathname,
save=True,
ext=ext)
if not (not (path)):
if not export:
h5saver = H5Saver(save_type='detector')
h5saver.init_file(update_h5=True,
custom_naming=False,
addhoc_file_path=path)
settings_str = b'<All_settings>' + custom_tree.parameter_to_xml_string(
self.settings)
if self.detector is not None:
settings_str += custom_tree.parameter_to_xml_string(
self.detector.settings)
if hasattr(self.detector.ui.viewers[0], 'roi_manager'):
settings_str += custom_tree.parameter_to_xml_string(
self.detector.ui.viewers[0].roi_manager.
settings)
settings_str += custom_tree.parameter_to_xml_string(
h5saver.settings)
settings_str += b'</All_settings>'
det_group = h5saver.add_det_group(h5saver.raw_group,
"Data", settings_str)
try:
self.channel_arrays = OrderedDict([])
data_dim = 'data1D'
if not h5saver.is_node_in_group(det_group, data_dim):
self.channel_arrays['data1D'] = OrderedDict([])
data_group = h5saver.add_data_group(
det_group, data_dim)
for ind_channel, data in enumerate(
self.raw_data): # list of numpy arrays
channel = f'CH{ind_channel:03d}'
channel_group = h5saver.add_CH_group(
data_group, title=channel)
self.channel_arrays[data_dim][
'parent'] = channel_group
self.channel_arrays[data_dim][
channel] = h5saver.add_data(
channel_group,
dict(data=data,
x_axis=self.viewer_freq_axis),
scan_type='',
enlargeable=False)
h5saver.close_file()
except Exception as e:
logger.exception(str(e))
else:
data_to_save = [self.viewer_freq_axis['data']]
data_to_save.extend([dat for dat in self.raw_data])
np.savetxt(path, data_to_save, delimiter='\t')
except Exception as e:
logger.exception(str(e))
@Slot(str)
def add_log(self, txt):
"""
Add a log to the logger list from the given text log and the current time
================ ========= ======================
**Parameters** **Type** **Description**
*txt* string the log to be added
================ ========= ======================
"""
now = datetime.datetime.now()
new_item = QtWidgets.QListWidgetItem(str(now) + ": " + txt)
self.logger_list.addItem(new_item)
##to do
##self.save_parameters.logger_array.append(str(now)+": "+txt)
@Slot(str)
def emit_log(self, txt):
"""
Emit a log-signal from the given log index
=============== ======== =======================
**Parameters** **Type** **Description**
*txt* string the log to be emitted
=============== ======== =======================
"""
self.log_signal.emit(txt)
def set_GUI(self):
###########################################
###########################################
#init the docks containing the main widgets
#######################################################################################################################
#create a dock containing a viewer object, displaying the data for the spectrometer
self.dock_viewer = Dock('Viewer dock', size=(350, 350))
self.dockarea.addDock(self.dock_viewer, 'left')
target_widget = QtWidgets.QWidget()
self.viewer = Viewer1D(target_widget)
self.dock_viewer.addWidget(target_widget)
################################################################
#create a logger dock where to store info senf from the programm
self.dock_logger = Dock("Logger")
self.logger_list = QtWidgets.QListWidget()
self.logger_list.setMinimumWidth(300)
self.dock_logger.addWidget(self.logger_list)
self.dockarea.addDock(self.dock_logger, 'right')
self.log_signal[str].connect(self.add_log)
############################################
# creating a menubar
self.menubar = self.mainwindow.menuBar()
self.create_menu(self.menubar)
#creating a toolbar
self.toolbar = QtWidgets.QToolBar()
self.create_toolbar()
self.mainwindow.addToolBar(self.toolbar)
#creating a status bar
self.statusbar = QtWidgets.QStatusBar()
self.statusbar.setMaximumHeight(25)
self.status_laser = QtWidgets.QLabel('????')
self.status_laser.setAlignment(Qt.AlignCenter)
#self.status_laser.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
#self.status_laser.setReadOnly(True)
self.status_laser.setMaximumWidth(80)
self.status_laser.setMinimumWidth(80)
self.status_laser.setToolTip('Current laser wavelength')
self.status_laser.setStyleSheet("background-color: red")
self.status_center = QtWidgets.QLabel('????')
self.status_center.setAlignment(Qt.AlignCenter)
#self.status_center.setReadOnly(True)
#self.status_center.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
self.status_center.setMaximumWidth(80)
self.status_center.setMinimumWidth(80)
self.status_center.setToolTip(
'center frequency of the spectrum, either in nm or cm-1')
self.status_center.setStyleSheet("background-color: red")
self.status_init = QLED()
self.status_init.setToolTip('Initialization state of the detector')
self.status_init.set_as_false()
self.status_init.clickable = False
self.statusbar.addPermanentWidget(self.status_laser)
self.statusbar.addPermanentWidget(self.status_center)
self.statusbar.addPermanentWidget(self.status_init)
self.dockarea.window().setStatusBar(self.statusbar)
#############################################
self.settings = Parameter.create(name='settings',
type='group',
children=self.params)
self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
dock_config_settings = Dock('Configuration', size=(300, 350))
self.dockarea.addDock(dock_config_settings, 'above', self.dock_logger)
# create main parameter tree
self.config_settings_tree = ParameterTree()
dock_config_settings.addWidget(self.config_settings_tree, 10)
self.config_settings_tree.setMinimumWidth(300)
self.config_settings_tree.setParameters(self.settings.child(
('config_settings')),
showTop=False)
#any change to the tree on the user interface will call the parameter_tree_changed method where all actions will be applied
dock_calib_settings = Dock('Calibration', size=(300, 350))
self.dockarea.addDock(dock_calib_settings, 'above', self.dock_logger)
# create main parameter tree
self.calib_settings_tree = ParameterTree()
dock_calib_settings.addWidget(self.calib_settings_tree, 10)
self.calib_settings_tree.setMinimumWidth(300)
self.calib_settings_tree.setParameters(self.settings.child(
('calib_settings')),
showTop=False)
#any change to the tree on the user interface will call the parameter_tree_changed method where all actions will be applied
#this one for the custom application settings
dock_acq_settings = Dock('Acquisition', size=(300, 350))
self.dockarea.addDock(dock_acq_settings, 'above', dock_config_settings)
# create main parameter tree
self.acq_settings_tree = ParameterTree()
dock_acq_settings.addWidget(self.acq_settings_tree, 10)
self.acq_settings_tree.setMinimumWidth(300)
self.acq_settings_tree.setParameters(self.settings.child(
('acq_settings')),
showTop=False)
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(636, 590)
self.gridLayout = QtWidgets.QGridLayout(Form)
self.gridLayout.setContentsMargins(9, 9, 9, 9)
self.gridLayout.setSpacing(6)
self.gridLayout.setObjectName("gridLayout")
self.settings_layout = QtWidgets.QVBoxLayout()
self.settings_layout.setObjectName("settings_layout")
self.verticalLayout_4 = QtWidgets.QVBoxLayout()
self.verticalLayout_4.setObjectName("verticalLayout_4")
self.title_label = QtWidgets.QLabel(Form)
self.title_label.setMaximumSize(QtCore.QSize(16777215, 30))
font = QtGui.QFont()
font.setFamily("Tahoma")
font.setPointSize(14)
font.setBold(True)
font.setItalic(True)
font.setWeight(75)
self.title_label.setFont(font)
self.title_label.setAlignment(QtCore.Qt.AlignCenter)
self.title_label.setObjectName("title_label")
self.verticalLayout_4.addWidget(self.title_label)
self.command_widget = QtWidgets.QWidget(Form)
self.command_widget.setMaximumSize(QtCore.QSize(16777215, 30))
self.command_widget.setObjectName("command_widget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.command_widget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(0)
self.verticalLayout.setObjectName("verticalLayout")
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setSpacing(0)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.grab_pb = QtWidgets.QPushButton(self.command_widget)
self.grab_pb.setText("")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/run2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.grab_pb.setIcon(icon)
self.grab_pb.setCheckable(True)
self.grab_pb.setObjectName("grab_pb")
self.horizontalLayout_2.addWidget(self.grab_pb)
self.single_pb = QtWidgets.QPushButton(self.command_widget)
self.single_pb.setText("")
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/snap.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.single_pb.setIcon(icon1)
self.single_pb.setCheckable(False)
self.single_pb.setObjectName("single_pb")
self.horizontalLayout_2.addWidget(self.single_pb)
self.stop_pb = QtWidgets.QPushButton(self.command_widget)
self.stop_pb.setText("")
icon2 = QtGui.QIcon()
icon2.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/stop.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.stop_pb.setIcon(icon2)
self.stop_pb.setCheckable(False)
self.stop_pb.setObjectName("stop_pb")
self.horizontalLayout_2.addWidget(self.stop_pb)
self.save_current_pb = QtWidgets.QPushButton(self.command_widget)
self.save_current_pb.setText("")
icon3 = QtGui.QIcon()
icon3.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/SaveAs.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.save_current_pb.setIcon(icon3)
self.save_current_pb.setObjectName("save_current_pb")
self.horizontalLayout_2.addWidget(self.save_current_pb)
self.save_new_pb = QtWidgets.QPushButton(self.command_widget)
self.save_new_pb.setText("")
icon4 = QtGui.QIcon()
icon4.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Snap&Save.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.save_new_pb.setIcon(icon4)
self.save_new_pb.setObjectName("save_new_pb")
self.horizontalLayout_2.addWidget(self.save_new_pb)
self.load_data_pb = QtWidgets.QPushButton(self.command_widget)
self.load_data_pb.setText("")
icon5 = QtGui.QIcon()
icon5.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Open.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.load_data_pb.setIcon(icon5)
self.load_data_pb.setObjectName("load_data_pb")
self.horizontalLayout_2.addWidget(self.load_data_pb)
self.settings_pb = QtWidgets.QPushButton(self.command_widget)
self.settings_pb.setText("")
icon6 = QtGui.QIcon()
icon6.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/HLM.ico"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.settings_pb.setIcon(icon6)
self.settings_pb.setCheckable(True)
self.settings_pb.setObjectName("settings_pb")
self.horizontalLayout_2.addWidget(self.settings_pb)
self.update_com_pb = QtWidgets.QPushButton(self.command_widget)
self.update_com_pb.setText("")
icon7 = QtGui.QIcon()
icon7.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Refresh2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.update_com_pb.setIcon(icon7)
self.update_com_pb.setCheckable(False)
self.update_com_pb.setObjectName("update_com_pb")
self.horizontalLayout_2.addWidget(self.update_com_pb)
self.navigator_pb = QtWidgets.QPushButton(self.command_widget)
self.navigator_pb.setText("")
icon8 = QtGui.QIcon()
icon8.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Select_24.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.navigator_pb.setIcon(icon8)
self.navigator_pb.setObjectName("navigator_pb")
self.horizontalLayout_2.addWidget(self.navigator_pb)
self.log_pb = QtWidgets.QPushButton(self.command_widget)
self.log_pb.setText("")
icon9 = QtGui.QIcon()
icon9.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/information2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.log_pb.setIcon(icon9)
self.log_pb.setObjectName("log_pb")
self.horizontalLayout_2.addWidget(self.log_pb)
self.verticalLayout.addLayout(self.horizontalLayout_2)
self.verticalLayout_4.addWidget(self.command_widget)
self.settings_widget = QtWidgets.QWidget(Form)
self.settings_widget.setObjectName("settings_widget")
self.settings_layout_2 = QtWidgets.QVBoxLayout(self.settings_widget)
self.settings_layout_2.setContentsMargins(0, 0, 0, 0)
self.settings_layout_2.setSpacing(0)
self.settings_layout_2.setObjectName("settings_layout_2")
self.gridLayout_3 = QtWidgets.QGridLayout()
self.gridLayout_3.setContentsMargins(-1, 0, -1, -1)
self.gridLayout_3.setSpacing(6)
self.gridLayout_3.setObjectName("gridLayout_3")
self.label_3 = QtWidgets.QLabel(self.settings_widget)
self.label_3.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignTrailing
| QtCore.Qt.AlignVCenter)
self.label_3.setObjectName("label_3")
self.gridLayout_3.addWidget(self.label_3, 1, 0, 1, 3)
self.DAQ_type_combo = QtWidgets.QComboBox(self.settings_widget)
self.DAQ_type_combo.setObjectName("DAQ_type_combo")
self.DAQ_type_combo.addItem("")
self.DAQ_type_combo.addItem("")
self.DAQ_type_combo.addItem("")
self.DAQ_type_combo.addItem("")
self.gridLayout_3.addWidget(self.DAQ_type_combo, 0, 3, 1, 3)
self.label_4 = QtWidgets.QLabel(self.settings_widget)
self.label_4.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignTrailing
| QtCore.Qt.AlignVCenter)
self.label_4.setObjectName("label_4")
self.gridLayout_3.addWidget(self.label_4, 0, 0, 1, 3)
self.Quit_pb = QtWidgets.QPushButton(self.settings_widget)
icon10 = QtGui.QIcon()
icon10.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/close2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Quit_pb.setIcon(icon10)
self.Quit_pb.setObjectName("Quit_pb")
self.gridLayout_3.addWidget(self.Quit_pb, 4, 0, 1, 2)
self.Detector_type_combo = QtWidgets.QComboBox(self.settings_widget)
self.Detector_type_combo.setObjectName("Detector_type_combo")
self.gridLayout_3.addWidget(self.Detector_type_combo, 1, 3, 1, 3)
self.load_settings_pb = QtWidgets.QPushButton(self.settings_widget)
self.load_settings_pb.setIcon(icon5)
self.load_settings_pb.setObjectName("load_settings_pb")
self.gridLayout_3.addWidget(self.load_settings_pb, 7, 0, 3, 3)
self.save_settings_pb = QtWidgets.QPushButton(self.settings_widget)
self.save_settings_pb.setIcon(icon3)
self.save_settings_pb.setObjectName("save_settings_pb")
self.gridLayout_3.addWidget(self.save_settings_pb, 7, 3, 3, 3)
self.take_bkg_cb = QtWidgets.QCheckBox(self.settings_widget)
self.take_bkg_cb.setObjectName("take_bkg_cb")
self.gridLayout_3.addWidget(self.take_bkg_cb, 5, 3, 2, 3)
self.do_bkg_cb = QtWidgets.QCheckBox(self.settings_widget)
self.do_bkg_cb.setObjectName("do_bkg_cb")
self.gridLayout_3.addWidget(self.do_bkg_cb, 5, 0, 2, 3)
self.Ini_state_LED = QLED(self.settings_widget)
self.Ini_state_LED.setObjectName("Ini_state_LED")
self.gridLayout_3.addWidget(self.Ini_state_LED, 4, 4, 1, 1)
self.data_ready_led = QLED(self.settings_widget)
self.data_ready_led.setObjectName("data_ready_led")
self.gridLayout_3.addWidget(self.data_ready_led, 4, 5, 1, 1)
self.IniDet_pb = QtWidgets.QPushButton(self.settings_widget)
self.IniDet_pb.setCheckable(True)
self.IniDet_pb.setChecked(False)
self.IniDet_pb.setObjectName("IniDet_pb")
self.gridLayout_3.addWidget(self.IniDet_pb, 4, 2, 1, 2)
self.settings_layout_2.addLayout(self.gridLayout_3)
self.verticalLayout_4.addWidget(self.settings_widget)
self.settings_layout.addLayout(self.verticalLayout_4)
self.gridLayout.addLayout(self.settings_layout, 0, 0, 1, 1)
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
class Ui_Form(object):
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(636, 590)
self.gridLayout = QtWidgets.QGridLayout(Form)
self.gridLayout.setContentsMargins(9, 9, 9, 9)
self.gridLayout.setSpacing(6)
self.gridLayout.setObjectName("gridLayout")
self.settings_layout = QtWidgets.QVBoxLayout()
self.settings_layout.setObjectName("settings_layout")
self.verticalLayout_4 = QtWidgets.QVBoxLayout()
self.verticalLayout_4.setObjectName("verticalLayout_4")
self.title_label = QtWidgets.QLabel(Form)
self.title_label.setMaximumSize(QtCore.QSize(16777215, 30))
font = QtGui.QFont()
font.setFamily("Tahoma")
font.setPointSize(14)
font.setBold(True)
font.setItalic(True)
font.setWeight(75)
self.title_label.setFont(font)
self.title_label.setAlignment(QtCore.Qt.AlignCenter)
self.title_label.setObjectName("title_label")
self.verticalLayout_4.addWidget(self.title_label)
self.command_widget = QtWidgets.QWidget(Form)
self.command_widget.setMaximumSize(QtCore.QSize(16777215, 30))
self.command_widget.setObjectName("command_widget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.command_widget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(0)
self.verticalLayout.setObjectName("verticalLayout")
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setSpacing(0)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.grab_pb = QtWidgets.QPushButton(self.command_widget)
self.grab_pb.setText("")
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/run2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.grab_pb.setIcon(icon)
self.grab_pb.setCheckable(True)
self.grab_pb.setObjectName("grab_pb")
self.horizontalLayout_2.addWidget(self.grab_pb)
self.single_pb = QtWidgets.QPushButton(self.command_widget)
self.single_pb.setText("")
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/snap.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.single_pb.setIcon(icon1)
self.single_pb.setCheckable(False)
self.single_pb.setObjectName("single_pb")
self.horizontalLayout_2.addWidget(self.single_pb)
self.stop_pb = QtWidgets.QPushButton(self.command_widget)
self.stop_pb.setText("")
icon2 = QtGui.QIcon()
icon2.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/stop.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.stop_pb.setIcon(icon2)
self.stop_pb.setCheckable(False)
self.stop_pb.setObjectName("stop_pb")
self.horizontalLayout_2.addWidget(self.stop_pb)
self.save_current_pb = QtWidgets.QPushButton(self.command_widget)
self.save_current_pb.setText("")
icon3 = QtGui.QIcon()
icon3.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/SaveAs.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.save_current_pb.setIcon(icon3)
self.save_current_pb.setObjectName("save_current_pb")
self.horizontalLayout_2.addWidget(self.save_current_pb)
self.save_new_pb = QtWidgets.QPushButton(self.command_widget)
self.save_new_pb.setText("")
icon4 = QtGui.QIcon()
icon4.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Snap&Save.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.save_new_pb.setIcon(icon4)
self.save_new_pb.setObjectName("save_new_pb")
self.horizontalLayout_2.addWidget(self.save_new_pb)
self.load_data_pb = QtWidgets.QPushButton(self.command_widget)
self.load_data_pb.setText("")
icon5 = QtGui.QIcon()
icon5.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Open.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.load_data_pb.setIcon(icon5)
self.load_data_pb.setObjectName("load_data_pb")
self.horizontalLayout_2.addWidget(self.load_data_pb)
self.settings_pb = QtWidgets.QPushButton(self.command_widget)
self.settings_pb.setText("")
icon6 = QtGui.QIcon()
icon6.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/HLM.ico"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.settings_pb.setIcon(icon6)
self.settings_pb.setCheckable(True)
self.settings_pb.setObjectName("settings_pb")
self.horizontalLayout_2.addWidget(self.settings_pb)
self.update_com_pb = QtWidgets.QPushButton(self.command_widget)
self.update_com_pb.setText("")
icon7 = QtGui.QIcon()
icon7.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Refresh2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.update_com_pb.setIcon(icon7)
self.update_com_pb.setCheckable(False)
self.update_com_pb.setObjectName("update_com_pb")
self.horizontalLayout_2.addWidget(self.update_com_pb)
self.navigator_pb = QtWidgets.QPushButton(self.command_widget)
self.navigator_pb.setText("")
icon8 = QtGui.QIcon()
icon8.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Select_24.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.navigator_pb.setIcon(icon8)
self.navigator_pb.setObjectName("navigator_pb")
self.horizontalLayout_2.addWidget(self.navigator_pb)
self.log_pb = QtWidgets.QPushButton(self.command_widget)
self.log_pb.setText("")
icon9 = QtGui.QIcon()
icon9.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/information2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.log_pb.setIcon(icon9)
self.log_pb.setObjectName("log_pb")
self.horizontalLayout_2.addWidget(self.log_pb)
self.verticalLayout.addLayout(self.horizontalLayout_2)
self.verticalLayout_4.addWidget(self.command_widget)
self.settings_widget = QtWidgets.QWidget(Form)
self.settings_widget.setObjectName("settings_widget")
self.settings_layout_2 = QtWidgets.QVBoxLayout(self.settings_widget)
self.settings_layout_2.setContentsMargins(0, 0, 0, 0)
self.settings_layout_2.setSpacing(0)
self.settings_layout_2.setObjectName("settings_layout_2")
self.gridLayout_3 = QtWidgets.QGridLayout()
self.gridLayout_3.setContentsMargins(-1, 0, -1, -1)
self.gridLayout_3.setSpacing(6)
self.gridLayout_3.setObjectName("gridLayout_3")
self.label_3 = QtWidgets.QLabel(self.settings_widget)
self.label_3.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignTrailing
| QtCore.Qt.AlignVCenter)
self.label_3.setObjectName("label_3")
self.gridLayout_3.addWidget(self.label_3, 1, 0, 1, 3)
self.DAQ_type_combo = QtWidgets.QComboBox(self.settings_widget)
self.DAQ_type_combo.setObjectName("DAQ_type_combo")
self.DAQ_type_combo.addItem("")
self.DAQ_type_combo.addItem("")
self.DAQ_type_combo.addItem("")
self.DAQ_type_combo.addItem("")
self.gridLayout_3.addWidget(self.DAQ_type_combo, 0, 3, 1, 3)
self.label_4 = QtWidgets.QLabel(self.settings_widget)
self.label_4.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignTrailing
| QtCore.Qt.AlignVCenter)
self.label_4.setObjectName("label_4")
self.gridLayout_3.addWidget(self.label_4, 0, 0, 1, 3)
self.Quit_pb = QtWidgets.QPushButton(self.settings_widget)
icon10 = QtGui.QIcon()
icon10.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/close2.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.Quit_pb.setIcon(icon10)
self.Quit_pb.setObjectName("Quit_pb")
self.gridLayout_3.addWidget(self.Quit_pb, 4, 0, 1, 2)
self.Detector_type_combo = QtWidgets.QComboBox(self.settings_widget)
self.Detector_type_combo.setObjectName("Detector_type_combo")
self.gridLayout_3.addWidget(self.Detector_type_combo, 1, 3, 1, 3)
self.load_settings_pb = QtWidgets.QPushButton(self.settings_widget)
self.load_settings_pb.setIcon(icon5)
self.load_settings_pb.setObjectName("load_settings_pb")
self.gridLayout_3.addWidget(self.load_settings_pb, 7, 0, 3, 3)
self.save_settings_pb = QtWidgets.QPushButton(self.settings_widget)
self.save_settings_pb.setIcon(icon3)
self.save_settings_pb.setObjectName("save_settings_pb")
self.gridLayout_3.addWidget(self.save_settings_pb, 7, 3, 3, 3)
self.take_bkg_cb = QtWidgets.QCheckBox(self.settings_widget)
self.take_bkg_cb.setObjectName("take_bkg_cb")
self.gridLayout_3.addWidget(self.take_bkg_cb, 5, 3, 2, 3)
self.do_bkg_cb = QtWidgets.QCheckBox(self.settings_widget)
self.do_bkg_cb.setObjectName("do_bkg_cb")
self.gridLayout_3.addWidget(self.do_bkg_cb, 5, 0, 2, 3)
self.Ini_state_LED = QLED(self.settings_widget)
self.Ini_state_LED.setObjectName("Ini_state_LED")
self.gridLayout_3.addWidget(self.Ini_state_LED, 4, 4, 1, 1)
self.data_ready_led = QLED(self.settings_widget)
self.data_ready_led.setObjectName("data_ready_led")
self.gridLayout_3.addWidget(self.data_ready_led, 4, 5, 1, 1)
self.IniDet_pb = QtWidgets.QPushButton(self.settings_widget)
self.IniDet_pb.setCheckable(True)
self.IniDet_pb.setChecked(False)
self.IniDet_pb.setObjectName("IniDet_pb")
self.gridLayout_3.addWidget(self.IniDet_pb, 4, 2, 1, 2)
self.settings_layout_2.addLayout(self.gridLayout_3)
self.verticalLayout_4.addWidget(self.settings_widget)
self.settings_layout.addLayout(self.verticalLayout_4)
self.gridLayout.addLayout(self.settings_layout, 0, 0, 1, 1)
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
_translate = QtCore.QCoreApplication.translate
Form.setWindowTitle(_translate("Form", "Form"))
self.title_label.setText(_translate("Form", "DAQ Title"))
self.grab_pb.setToolTip(_translate("Form", "Grab"))
self.single_pb.setToolTip(_translate("Form", "Single Grab"))
self.stop_pb.setToolTip(_translate("Form", "Single Grab"))
self.save_current_pb.setToolTip(_translate("Form",
"Save Current Data"))
self.save_new_pb.setToolTip(_translate("Form", "Save New Data"))
self.settings_pb.setToolTip(_translate("Form", "Open Settings"))
self.update_com_pb.setToolTip(_translate("Form", "Refresh Hardware"))
self.navigator_pb.setToolTip(
_translate("Form", "Send current data to navigator"))
self.log_pb.setToolTip(_translate("Form", "Show Current log file"))
self.label_3.setText(_translate("Form", "Detector:"))
self.DAQ_type_combo.setToolTip(_translate("Form", "Detector Type"))
self.DAQ_type_combo.setItemText(0, _translate("Form", "DAQ0D"))
self.DAQ_type_combo.setItemText(1, _translate("Form", "DAQ1D"))
self.DAQ_type_combo.setItemText(2, _translate("Form", "DAQ2D"))
self.DAQ_type_combo.setItemText(3, _translate("Form", "DAQND"))
self.label_4.setText(_translate("Form", "DAQ type:"))
self.Quit_pb.setToolTip(_translate("Form",
"quit and close the viewer"))
self.Quit_pb.setText(_translate("Form", "Quit"))
self.Detector_type_combo.setToolTip(_translate("Form", "Stage Type"))
self.load_settings_pb.setToolTip(_translate("Form", "Load settings"))
self.load_settings_pb.setText(_translate("Form", "Sett."))
self.save_settings_pb.setToolTip(_translate("Form", "save settings"))
self.save_settings_pb.setText(_translate("Form", "Sett."))
self.take_bkg_cb.setText(_translate("Form", "Take Bkg"))
self.do_bkg_cb.setText(_translate("Form", "Do Bkg sub."))
self.Ini_state_LED.setToolTip(
_translate("Form", "Green when controller is initialized"))
self.Ini_state_LED.setText(_translate("Form", "TextLabel"))
self.data_ready_led.setToolTip(
_translate("Form", "Green when data ready"))
self.data_ready_led.setText(_translate("Form", "TextLabel"))
self.IniDet_pb.setToolTip(
_translate("Form", "To initialize the detector"))
self.IniDet_pb.setText(_translate("Form", "Ini. Det."))
def setupUI(self):
self.ui = QObject()
widget_settings = QtWidgets.QWidget()
self.ui.layout = QtWidgets.QVBoxLayout()
widget_settings.setLayout(self.ui.layout)
widget_buttons = QtWidgets.QWidget()
layout_buttons = QtWidgets.QHBoxLayout()
widget_buttons.setLayout(layout_buttons)
self.ui.layout.addWidget(widget_buttons)
iconquit = QtGui.QIcon()
iconquit.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/close2.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.ui.quit_button = QtWidgets.QPushButton(iconquit, 'Quit')
iconstart = QtGui.QIcon()
iconstart.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/run2.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.ui.start_button = QtWidgets.QPushButton(iconstart, '')
self.ui.start_button.setToolTip('Start logging into h5file or database')
iconstop = QtGui.QIcon()
iconstop.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/stop.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.ui.stop_button = QtWidgets.QPushButton(iconstop, '')
self.ui.stop_button.setToolTip('Stop/pause logging')
log_type_combo = QtWidgets.QComboBox()
log_type_combo.addItems(self.log_types)
log_type_combo.currentTextChanged.connect(self.set_log_type)
iconstartall = QtGui.QIcon()
iconstartall.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/run_all.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.ui.startall_button = QtWidgets.QPushButton(iconstartall, '')
self.ui.startall_button.setToolTip('Grab all selected detectors')
layout_buttons.addWidget(self.ui.quit_button)
layout_buttons.addStretch()
layout_buttons.addWidget(self.ui.startall_button)
layout_buttons.addWidget(log_type_combo)
layout_buttons.addWidget(self.ui.start_button)
layout_buttons.addWidget(self.ui.stop_button)
# %% create logger dock and make it a floating window
self.ui.logger_dock = Dock("Logger", size=(1, 1), autoOrientation=False)
# give this dock the minimum possible size
self.ui.logger_dock.setOrientation('vertical')
self.ui.logger_dock.addWidget(widget_settings)
self.dockarea.addDock(self.ui.logger_dock, 'left')
self.ui.logger_dock.float()
widget_hor = QtWidgets.QWidget()
layout_hor = QtWidgets.QHBoxLayout()
main_sett_widget = QtWidgets.QWidget()
main_sett_widget.setLayout(QtWidgets.QVBoxLayout())
widget_hor.setLayout(layout_hor)
self.ui.layout.addWidget(widget_hor)
self.settings_tree = ParameterTree()
self.settings_tree.setMinimumWidth(300)
layout_hor.addWidget(main_sett_widget)
main_sett_widget.layout().addWidget(self.settings_tree)
main_sett_widget.layout().addWidget(self.modules_manager.settings_tree)
self.modules_manager.settings.child('modules', 'actuators').hide()
self.modules_manager.settings.child(('data_dimensions')).hide()
self.modules_manager.settings.child(('actuators_positions')).hide()
self.h5saver.settings_tree.setMinimumWidth(300)
layout_hor.addWidget(self.h5saver.settings_tree)
if is_sql:
self.dblogger.settings_tree.setMinimumWidth(300)
layout_hor.addWidget(self.dblogger.settings_tree)
self.settings = Parameter.create(name='Settings', type='group', children=self.params)
self.settings_tree.setParameters(self.settings, showTop=False)
self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
# %% init and set the status bar
self.ui.statusbar = QtWidgets.QStatusBar(self.dockarea)
self.ui.statusbar.setMaximumHeight(25)
self.ui.layout.addWidget(self.ui.statusbar)
self.ui.log_message = QtWidgets.QLabel('Initializing')
self.ui.statusbar.addPermanentWidget(self.ui.log_message)
self.ui.start_log_time = QtWidgets.QDateTimeEdit()
self.ui.start_log_time.setReadOnly(True)
self.ui.start_log_time.setToolTip('Logging started at:')
self.ui.logging_state = QLED()
self.ui.logging_state.setToolTip('logging status: green (running), red (idle)')
self.ui.logging_state.clickable = False
self.ui.statusbar.addPermanentWidget(self.ui.start_log_time)
self.ui.statusbar.addPermanentWidget(self.ui.logging_state)
self.ui.layout.addWidget(self.ui.statusbar)
# connecting
self.status_signal[str].connect(self.dashboard.add_status)
self.ui.quit_button.clicked.connect(self.quit_fun)
self.ui.start_button.clicked.connect(self.start_logging)
self.ui.stop_button.clicked.connect(self.stop_logging)
self.ui.startall_button.clicked.connect(self.start_all)
self.create_menu()