def makeLayout(self, title, switchable): layout = QtGui.QGridLayout() #labels title = QtGui.QLabel(title) title.setFont(QtGui.QFont('MS Shell Dlg 2', pointSize=16)) title.setAlignment(QtCore.Qt.AlignCenter) freqlabel = QtGui.QLabel('Frequency (MHz)') powerlabel = QtGui.QLabel('Power (dBM)') if switchable: layout.addWidget(title, 0, 0, 1, 3) else: layout.addWidget(title, 0, 0, 1, 2) layout.addWidget(freqlabel, 1, 0, 1, 1) layout.addWidget(powerlabel, 1, 1, 1, 1) #editable fields self.spinFreq = QtGui.QDoubleSpinBox() self.spinFreq.setFont(QtGui.QFont('MS Shell Dlg 2', pointSize=16)) self.spinFreq.setDecimals(3) self.spinFreq.setSingleStep(0.1) self.spinFreq.setRange(10.0, 250.0) self.spinFreq.setKeyboardTracking(False) self.spinPower = QtGui.QDoubleSpinBox() self.spinPower.setFont(QtGui.QFont('MS Shell Dlg 2', pointSize=16)) self.spinPower.setDecimals(3) self.spinPower.setSingleStep(0.1) self.spinPower.setRange(-145.0, 30.0) self.spinPower.setKeyboardTracking(False) layout.addWidget(self.spinFreq, 2, 0) layout.addWidget(self.spinPower, 2, 1) if switchable: self.buttonSwitch = TextChangingButton(("I", "O")) layout.addWidget(self.buttonSwitch, 2, 2) self.setLayout(layout)
def initializeGUI(self): """ TODO: modify QCustomWavemeterChannel to get rid of PID button """ layout = QtGui.QGridLayout() self.setWindowTitle('Multiplexed Wavemeter') # this "group" contains all 8 channel outputs and settings qBox = QtGui.QGroupBox('Wave Length and Lock settings') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) # button to start wavemeter measurement (turn wavemeter on) self.startSwitch = TextChangingButton('Wavemeter') self.startSwitch.setMaximumHeight(50) initstartvalue = yield self.server.get_wlm_output() self.startSwitch.setChecked(initstartvalue) self.startSwitch.toggled.connect(self.setOutput) subLayout.addWidget(self.startSwitch, 0, 0) # create display box for each channel # need to modify QCustomWavemeterChannel to get rid of PID button for chan in self.chaninfo: wmChannel = self.chaninfo[chan][0] hint = self.chaninfo[chan][1] position = self.chaninfo[chan][2] stretched = self.chaninfo[chan][3] displayPID = self.chaninfo[chan][4] dacPort = self.chaninfo[chan][5] widget = QCustomWavemeterChannel(chan, wmChannel, dacPort, hint, stretched, displayPID) from common.lib.clients.qtui import RGBconverter as RGB RGB = RGB.RGBconverter() color = int(2.998e8 / (float(hint) * 1e3)) color = RGB.wav2RGB(color) color = tuple(color) widget.currentfrequency.setStyleSheet('color: rgb' + str(color)) widget.spinExp.valueChanged.connect( lambda exp=widget.spinExp.value( ), wmChannel=wmChannel: self.expChanged(exp, wmChannel)) initvalue = yield self.server.get_exposure(wmChannel) widget.spinExp.setValue(initvalue) initmeas = yield self.server.get_switcher_signal_state(wmChannel) initmeas = initmeas widget.measSwitch.setChecked(bool(initmeas)) widget.measSwitch.toggled.connect( lambda state=widget.measSwitch.isDown( ), wmChannel=wmChannel: self.changeState(state, wmChannel)) self.d[wmChannel] = widget subLayout.addWidget(self.d[wmChannel], position[1], position[0], 1, 3) self.setLayout(layout)
def makeLayout(self, title, labels): layout = QtGui.QGridLayout() title = QtGui.QLabel(title) title.setFont(QtGui.QFont('MS Shell Dlg 2', pointSize=16)) layout.addWidget(title, 0, 0, 1, 3) #editable fields self.TTLswitch = TextChangingButton(labels) self.TTLswitch.setAutoDefault(True) layout.addWidget(self.TTLswitch, 1, 0, 2, 1) self.setLayout(layout)
def makeLayout(self, title, switchable): layout = QtGui.QGridLayout() #labels title = QtGui.QLabel(title) title.setFont(QtGui.QFont('MS Shell Dlg 2',pointSize=16)) title.setAlignment(QtCore.Qt.AlignCenter) freqlabel = QtGui.QLabel('Frequency (MHz)') powerlabel = QtGui.QLabel('Power (dBM)') if switchable: layout.addWidget(title,0, 0, 1, 3) else: layout.addWidget(title,0, 0, 1, 2) layout.addWidget(freqlabel,1, 0, 1, 1) layout.addWidget(powerlabel,1, 1, 1, 1) #editable fields self.spinFreq = QtGui.QDoubleSpinBox() self.spinFreq.setFont(QtGui.QFont('MS Shell Dlg 2',pointSize=16)) self.spinFreq.setDecimals(3) self.spinFreq.setSingleStep(0.1) self.spinFreq.setRange(10.0,250.0) self.spinFreq.setKeyboardTracking(False) self.spinPower = QtGui.QDoubleSpinBox() self.spinPower.setFont(QtGui.QFont('MS Shell Dlg 2',pointSize=16)) self.spinPower.setDecimals(3) self.spinPower.setSingleStep(0.1) self.spinPower.setRange(-145.0, 30.0) self.spinPower.setKeyboardTracking(False) layout.addWidget(self.spinFreq, 2, 0) layout.addWidget(self.spinPower, 2, 1) if switchable: self.buttonSwitch = TextChangingButton(("I", "O")) layout.addWidget(self.buttonSwitch, 2, 2) self.setLayout(layout)
class QCustomSwitchChannel(QtGui.QFrame): def __init__(self, title, labels=None, parent=None): QtGui.QWidget.__init__(self, parent) self.setFrameStyle(0x0001 | 0x0030) self.makeLayout(title, labels) def makeLayout(self, title, labels): layout = QtGui.QGridLayout() title = QtGui.QLabel(title) title.setFont(QtGui.QFont('MS Shell Dlg 2', pointSize=16)) layout.addWidget(title, 0, 0, 1, 3) #editable fields self.TTLswitch = TextChangingButton(labels) self.TTLswitch.setAutoDefault(True) layout.addWidget(self.TTLswitch, 1, 0, 2, 1) self.setLayout(layout)
class QCustomSwitchChannel(QtGui.QFrame): def __init__(self, title, labels = None, parent=None): QtGui.QWidget.__init__(self, parent) self.setFrameStyle(0x0001 | 0x0030) self.makeLayout(title, labels) def makeLayout(self, title, labels): layout = QtGui.QGridLayout() title = QtGui.QLabel(title) title.setFont(QtGui.QFont('MS Shell Dlg 2',pointSize=16)) layout.addWidget(title, 0,0,1,3) #editable fields self.TTLswitch = TextChangingButton(labels) self.TTLswitch.setAutoDefault(True) layout.addWidget(self.TTLswitch, 2,0, 2,1) self.enableSwitch = QtGui.QCheckBox('Enable Shutter') layout.addWidget(self.enableSwitch, 1,0, 1,1) self.setLayout(layout)
def makeLayout(self, title, labels): layout = QtGui.QGridLayout() title = QtGui.QLabel(title) title.setFont(QtGui.QFont('MS Shell Dlg 2',pointSize=16)) layout.addWidget(title, 0,0,1,3) #editable fields self.TTLswitch = TextChangingButton(labels) self.TTLswitch.setAutoDefault(True) layout.addWidget(self.TTLswitch, 2,0, 2,1) self.enableSwitch = QtGui.QCheckBox('Enable Shutter') layout.addWidget(self.enableSwitch, 1,0, 1,1) self.setLayout(layout)
def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Wavemeter') # this "group" contains all 8 channel outputs and settings qBox = QtGui.QGroupBox('Wave Length and Lock settings') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) # button to start wavemeter measurement (turn wavemeter on) self.startSwitch = TextChangingButton('Wavemeter') self.startSwitch.setMaximumHeight(50) initstartvalue = yield self.server.get_wlm_output() self.startSwitch.setChecked(initstartvalue) self.startSwitch.toggled.connect(self.setOutput) subLayout.addWidget(self.startSwitch, 0, 0) # create display box for each channel # need to modify QCustomWavemeterChannel to get rid of PID button for chan in self.chaninfo: wmChannel = self.chaninfo[chan][0] hint = self.chaninfo[chan][1] position = self.chaninfo[chan][2] stretched = self.chaninfo[chan][3] widget = QCustomWavemeterChannel(chan, wmChannel, hint, stretched) from common.lib.clients.qtui import RGBconverter as RGB RGB = RGB.RGBconverter() color = int(2.998e8/(float(hint)*1e3)) color = RGB.wav2RGB(color) color = tuple(color) widget.currentfrequency.setStyleSheet('color: rgb' + str(color)) widget.spinExp.valueChanged.connect(lambda exp=widget.spinExp.value(), wmChannel=wmChannel : self.expChanged(exp, wmChannel)) initvalue = yield self.server.get_exposure(wmChannel) widget.spinExp.setValue(initvalue) initmeas = yield self.server.get_switcher_signal_state(wmChannel) initmeas = initmeas widget.measSwitch.setChecked(bool(initmeas)) widget.measSwitch.toggled.connect(lambda state=widget.measSwitch.isDown(), wmChannel=wmChannel : self.changeState(state, wmChannel)) self.d[wmChannel] = widget subLayout.addWidget(self.d[wmChannel], position[1], position[0], 1, 3) self.setLayout(layout)
def makeLayout(self): layout = QtGui.QGridLayout() shell_font = 'MS Shell Dlg 2' title = QtGui.QLabel('Current Controller') title.setFont(QtGui.QFont(shell_font, pointSize=16)) title.setAlignment(QtCore.Qt.AlignCenter) loadingName = QtGui.QLabel('Current (mA)') loadingName.setFont(QtGui.QFont(shell_font, pointSize=16)) loadingName.setAlignment(QtCore.Qt.AlignCenter) self.output = TextChangingButton(('On','Off')) self.output.setMaximumHeight(30) self.output.setMinimumHeight(30) self.output.setFont(QtGui.QFont(shell_font, pointSize=14)) #self.update_dc.setMinimumWidth(180) # loading time self.current_spin = QtGui.QDoubleSpinBox() self.current_spin.setFont(QtGui.QFont(shell_font, pointSize=16)) self.current_spin.setDecimals(3) self.current_spin.setSingleStep(.05) self.current_spin.setRange(0, 700) self.current_spin.setKeyboardTracking(False) #layout 1 row at a time layout.addWidget(title, 0, 0, 2, 2) layout.addWidget(loadingName, 2, 0, 1, 2) layout.addWidget(self.current_spin, 3, 0, 1, 2) layout.addWidget(self.output, 5, 0, 1, 2) layout.minimumSize() self.setLayout(layout)
def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Rigol DG1022 Control') qBox = QtGui.QGroupBox('Rigol DG1022') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) self.deviceselect = QtGui.QComboBox(self) self.updatedevices() self.offsetwidget1 = QCustomSpinBox('Offset', (-5, 5)) self.offsetwidget2 = QCustomSpinBox('Offset', (-5, 5)) self.volt1widget = QCustomSpinBox('Amplitude (Vpp)', (-10, 10)) self.freq1widget = QCustomSpinBox('Frequency (Hz)', (0, 40e6)) self.volt2widget = QCustomSpinBox('Amplitude (Vpp)', (-10, 10)) self.freq2widget = QCustomSpinBox('Frequency (Hz)', (0, 40e6)) self.waveselect1 = QtGui.QComboBox(self) self.waveselect2 = QtGui.QComboBox(self) self.output1 = TextChangingButton(('On', 'Off')) self.output2 = TextChangingButton(('On', 'Off')) self.waveselect1.addItem("sine") self.waveselect1.addItem("square") self.waveselect1.addItem("ramp") self.waveselect1.addItem("pulse") self.waveselect1.addItem("noise") self.waveselect1.addItem("DC") self.waveselect1.addItem("USER") self.waveselect2.addItem("sine") self.waveselect2.addItem("square") self.waveselect2.addItem("ramp") self.waveselect2.addItem("pulse") self.waveselect2.addItem("noise") self.waveselect2.addItem("DC") self.waveselect2.addItem("USER") self.output1.toggled.connect(lambda state=self.output1.isDown(), chan= 1, : self.setoutput(chan, state)) self.output2.toggled.connect(lambda state=self.output1.isDown(), chan= 2, : self.setoutput(chan, state)) self.volt1widget.spinLevel.valueChanged.connect( lambda value=self.volt1widget.spinLevel.value( ), chan=1: self.voltchanged(chan, value)) self.volt2widget.spinLevel.valueChanged.connect( lambda value=self.volt2widget.spinLevel.value( ), chan=2: self.voltchanged(chan, value)) self.freq1widget.spinLevel.valueChanged.connect( lambda value=self.freq1widget.spinLevel.value( ), chan=1: self.freqchanged(chan, value)) self.freq2widget.spinLevel.valueChanged.connect( lambda value=self.freq2widget.spinLevel.value( ), chan=2: self.freqchanged(chan, value)) self.offsetwidget1.spinLevel.valueChanged.connect( lambda value=self.offsetwidget1.spinLevel.value( ), chan=1: self.offsetchanged(chan, value)) self.offsetwidget2.spinLevel.valueChanged.connect( lambda value=self.offsetwidget2.spinLevel.value( ), chan=2: self.offsetchanged(chan, value)) self.waveselect1.activated[str].connect( lambda wave=self.waveselect1.currentText( ), chan=1: self.waveselect(chan, wave)) self.waveselect2.activated[str].connect( lambda wave=self.waveselect2.currentText( ), chan=2: self.waveselect(chan, wave)) self.deviceselect.activated[str].connect(self.changedevice) subLayout.addWidget(self.freq1widget, 1, 0) subLayout.addWidget(self.volt1widget, 1, 1) subLayout.addWidget(self.freq2widget, 1, 2) subLayout.addWidget(self.volt2widget, 1, 3) subLayout.addWidget(self.waveselect1, 2, 0, 1, 2) subLayout.addWidget(self.waveselect2, 2, 2, 1, 2) subLayout.addWidget(self.offsetwidget1, 3, 0) subLayout.addWidget(self.offsetwidget2, 3, 2) subLayout.addWidget(self.output1, 3, 1) subLayout.addWidget(self.output2, 3, 3) subLayout.addWidget(self.deviceselect, 0, 3) self.setLayout(layout)
class rigolclient(QtGui.QWidget): def __init__(self, reactor, parent=None): """initializels the GUI creates the reactor """ super(rigolclient, self).__init__() self.setSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed) self.reactor = reactor self.connect() @inlineCallbacks def connect(self): """Creates an Asynchronous connection """ from labrad.wrappers import connectAsync from labrad.units import WithUnit as U self.U = U self.cxn = yield connectAsync(name="rigol client") self.server = self.cxn.rigol_dg1022a_server self.devicelist = yield self.server.list_devices() if self.devicelist: yield self.server.select_device(0) self.initializeGUI() def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Rigol DG1022 Control') qBox = QtGui.QGroupBox('Rigol DG1022') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) self.deviceselect = QtGui.QComboBox(self) self.updatedevices() self.offsetwidget1 = QCustomSpinBox('Offset', (-5, 5)) self.offsetwidget2 = QCustomSpinBox('Offset', (-5, 5)) self.volt1widget = QCustomSpinBox('Amplitude (Vpp)', (-10, 10)) self.freq1widget = QCustomSpinBox('Frequency (Hz)', (0, 40e6)) self.volt2widget = QCustomSpinBox('Amplitude (Vpp)', (-10, 10)) self.freq2widget = QCustomSpinBox('Frequency (Hz)', (0, 40e6)) self.waveselect1 = QtGui.QComboBox(self) self.waveselect2 = QtGui.QComboBox(self) self.output1 = TextChangingButton(('On', 'Off')) self.output2 = TextChangingButton(('On', 'Off')) self.waveselect1.addItem("sine") self.waveselect1.addItem("square") self.waveselect1.addItem("ramp") self.waveselect1.addItem("pulse") self.waveselect1.addItem("noise") self.waveselect1.addItem("DC") self.waveselect1.addItem("USER") self.waveselect2.addItem("sine") self.waveselect2.addItem("square") self.waveselect2.addItem("ramp") self.waveselect2.addItem("pulse") self.waveselect2.addItem("noise") self.waveselect2.addItem("DC") self.waveselect2.addItem("USER") self.output1.toggled.connect(lambda state=self.output1.isDown(), chan= 1, : self.setoutput(chan, state)) self.output2.toggled.connect(lambda state=self.output1.isDown(), chan= 2, : self.setoutput(chan, state)) self.volt1widget.spinLevel.valueChanged.connect( lambda value=self.volt1widget.spinLevel.value( ), chan=1: self.voltchanged(chan, value)) self.volt2widget.spinLevel.valueChanged.connect( lambda value=self.volt2widget.spinLevel.value( ), chan=2: self.voltchanged(chan, value)) self.freq1widget.spinLevel.valueChanged.connect( lambda value=self.freq1widget.spinLevel.value( ), chan=1: self.freqchanged(chan, value)) self.freq2widget.spinLevel.valueChanged.connect( lambda value=self.freq2widget.spinLevel.value( ), chan=2: self.freqchanged(chan, value)) self.offsetwidget1.spinLevel.valueChanged.connect( lambda value=self.offsetwidget1.spinLevel.value( ), chan=1: self.offsetchanged(chan, value)) self.offsetwidget2.spinLevel.valueChanged.connect( lambda value=self.offsetwidget2.spinLevel.value( ), chan=2: self.offsetchanged(chan, value)) self.waveselect1.activated[str].connect( lambda wave=self.waveselect1.currentText( ), chan=1: self.waveselect(chan, wave)) self.waveselect2.activated[str].connect( lambda wave=self.waveselect2.currentText( ), chan=2: self.waveselect(chan, wave)) self.deviceselect.activated[str].connect(self.changedevice) subLayout.addWidget(self.freq1widget, 1, 0) subLayout.addWidget(self.volt1widget, 1, 1) subLayout.addWidget(self.freq2widget, 1, 2) subLayout.addWidget(self.volt2widget, 1, 3) subLayout.addWidget(self.waveselect1, 2, 0, 1, 2) subLayout.addWidget(self.waveselect2, 2, 2, 1, 2) subLayout.addWidget(self.offsetwidget1, 3, 0) subLayout.addWidget(self.offsetwidget2, 3, 2) subLayout.addWidget(self.output1, 3, 1) subLayout.addWidget(self.output2, 3, 3) subLayout.addWidget(self.deviceselect, 0, 3) self.setLayout(layout) @inlineCallbacks def voltchanged(self, chan, value): value = self.U(value, 'V') yield self.server.amplitude(chan, value) @inlineCallbacks def freqchanged(self, chan, value): value = self.U(value, 'Hz') yield self.server.frequency(chan, value) @inlineCallbacks def offsetchanged(self, chan, value): value = self.U(value, 'V') yield self.server.offset(chan, value) @inlineCallbacks def setoutput(self, chan, state): yield self.server.output(chan, state) @inlineCallbacks def waveselect(self, chan, wave): if wave == 'DC': if chan == 1: self.freq1widget.setEnabled(False) else: self.freq2widget.setEnabled(False) else: self.freq1widget.setEnabled(True) self.freq2widget.setEnabled(True) yield self.server.wave_function(chan, str(wave)) @inlineCallbacks def changedevice(self, deviceid): if deviceid == 'Refresh List': yield self.server.refresh() self.updatedevices() else: self.server.release_device() self.server.select_device(int(deviceid[1])) @inlineCallbacks def updatedevices(self): self.deviceselect.clear() self.devicelist = yield self.server.list_devices() for device in self.devicelist: self.deviceselect.addItem(str(device)) self.deviceselect.addItem('Refresh List') def closeEvent(self, x): self.reactor.stop()
class wavemeterclient(QtGui.QWidget): def __init__(self, reactor, parent=None): """initializels the GUI creates the reactor and empty dictionary for channel widgets to be stored for iteration. also grabs chan info from multiplexer_config """ super(wavemeterclient, self).__init__() self.password = os.environ['LABRADPASSWORD'] self.setSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed) self.reactor = reactor self.name = socket.gethostname() + ' Wave Meter Client' self.d = {} self.wmChannels = {} self.connect() self._check_window_size() def _check_window_size(self): """Checks screen size to make sure window fits in the screen. """ desktop = QtGui.QDesktopWidget() screensize = desktop.availableGeometry() width = screensize.width() height = screensize.height() min_pixel_size = 1080 if (width <= min_pixel_size or height <= min_pixel_size): self.showMaximized() @inlineCallbacks def connect(self): """Creates an Asynchronous connection to the wavemeter computer and connects incoming signals to relavent functions """ self.chaninfo = multiplexer_config.info self.wavemeterIP = multiplexer_config.ip from labrad.wrappers import connectAsync self.cxn = yield connectAsync(self.wavemeterIP, name=self.name, password=self.password) self.server = yield self.cxn.multiplexerserver yield self.server.signal__frequency_changed(SIGNALID1) yield self.server.signal__selected_channels_changed(SIGNALID2) yield self.server.signal__update_exp(SIGNALID3) yield self.server.signal__lock_changed(SIGNALID4) yield self.server.signal__output_changed(SIGNALID5) yield self.server.signal__pidvoltage_changed(SIGNALID6) yield self.server.signal__channel_lock_changed(SIGNALID7) yield self.server.signal__amplitude_changed(SIGNALID8) yield self.server.addListener(listener = self.updateFrequency, source = None, ID = SIGNALID1) yield self.server.addListener(listener = self.toggleMeas, source = None, ID = SIGNALID2) yield self.server.addListener(listener = self.updateexp, source = None, ID = SIGNALID3) yield self.server.addListener(listener = self.toggleLock, source = None, ID = SIGNALID4) yield self.server.addListener(listener = self.updateWLMOutput, source = None, ID = SIGNALID5) yield self.server.addListener(listener = self.updatePIDvoltage, source = None, ID = SIGNALID6) yield self.server.addListener(listener = self.toggleChannelLock, source = None, ID = SIGNALID7) yield self.server.addListener(listener = self.updateAmplitude, source = None, ID = SIGNALID8) self.initializeGUI() @inlineCallbacks def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Multiplexed Wavemeter') qBox = QtGui.QGroupBox('Wave Length and Lock settings') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) self.lockSwitch = TextChangingButton('Lock Wave Meter') self.lockSwitch.setMaximumHeight(50) self.startSwitch = TextChangingButton('Wavemeter') self.startSwitch.setMaximumHeight(50) initstartvalue = yield self.server.get_wlm_output() initlockvalue = yield self.server.get_lock_state() self.lockSwitch.setChecked(initlockvalue) self.startSwitch.setChecked(initstartvalue) self.lockSwitch.toggled.connect(self.setLock) self.startSwitch.toggled.connect(self.setOutput) subLayout.addWidget(self.lockSwitch, 0, 2) subLayout.addWidget(self.startSwitch, 0, 0) for chan in self.chaninfo: wmChannel = self.chaninfo[chan][0] hint = self.chaninfo[chan][1] position = self.chaninfo[chan][2] stretched = self.chaninfo[chan][3] displayPID = self.chaninfo[chan][4] dacPort = self.chaninfo[chan][5] widget = QCustomWavemeterChannel(chan, wmChannel, dacPort, hint, stretched, displayPID) if displayPID: try: rails = self.chaninfo[chan][6] widget.PIDindicator.set_rails(rails) except: rails = [-10.0,10.0] widget.PIDindicator.set_rails(rails) from common.lib.clients.qtui import RGBconverter as RGB RGB = RGB.RGBconverter() color = int(2.998e8/(float(hint)*1e3)) color = RGB.wav2RGB(color) color = tuple(color) if dacPort != 0: self.wmChannels[dacPort] = wmChannel initcourse = yield self.getPIDCourse(dacPort, hint) widget.spinFreq.setValue(initcourse) widget.spinFreq.valueChanged.connect(lambda freq = widget.spinFreq.value(), dacPort = dacPort : self.freqChanged(freq, dacPort)) widget.setPID.clicked.connect(lambda state = widget.setPID.isDown(), chan = chan, dacPort = dacPort : self.InitializePIDGUI(dacPort, chan)) initLock = yield self.server.get_channel_lock(dacPort, wmChannel) widget.lockChannel.setChecked(bool(initLock)) widget.lockChannel.toggled.connect(lambda state = widget.lockChannel.isDown(), dacPort = dacPort : self.lockSingleChannel(state, dacPort)) else: widget.spinFreq.setValue(float(hint)) widget.lockChannel.toggled.connect(lambda state = widget.lockChannel.isDown(), wmChannel = wmChannel : self.setButtonOff(wmChannel)) widget.currentfrequency.setStyleSheet('color: rgb' + str(color)) widget.spinExp.valueChanged.connect(lambda exp = widget.spinExp.value(), wmChannel = wmChannel : self.expChanged(exp, wmChannel)) initvalue = yield self.server.get_exposure(wmChannel) widget.spinExp.setValue(initvalue) initmeas = yield self.server.get_switcher_signal_state(wmChannel) initmeas = initmeas widget.measSwitch.setChecked(bool(initmeas)) widget.measSwitch.toggled.connect(lambda state = widget.measSwitch.isDown(), wmChannel = wmChannel : self.changeState(state, wmChannel)) self.d[wmChannel] = widget subLayout.addWidget(self.d[wmChannel], position[1], position[0], 1, 3) self.setLayout(layout) @inlineCallbacks def InitializePIDGUI(self,dacPort,chan): self.pid = QCustomPID(dacPort) self.pid.setWindowTitle(chan + ' PID settings') self.pid.move(self.pos()) self.index = {1:0,-1:1} pInit = yield self.server.get_pid_p(dacPort) iInit = yield self.server.get_pid_i(dacPort) dInit = yield self.server.get_pid_d(dacPort) dtInit = yield self.server.get_pid_dt(dacPort) constInit = yield self.server.get_const_dt(dacPort) sensInit = yield self.server.get_pid_sensitivity(dacPort) polInit = yield self.server.get_pid_polarity(dacPort) self.pid.spinP.setValue(pInit) self.pid.spinI.setValue(iInit) self.pid.spinD.setValue(dInit) self.pid.spinDt.setValue(dtInit) self.pid.useDTBox.setCheckState(bool(constInit)) self.pid.spinFactor.setValue(sensInit[0]) self.pid.spinExp.setValue(sensInit[1]) self.pid.polarityBox.setCurrentIndex(self.index[polInit]) self.pid.spinP.valueChanged.connect(lambda p = self.pid.spinP.value(), dacPort = dacPort : self.changeP(p, dacPort)) self.pid.spinI.valueChanged.connect(lambda i = self.pid.spinI.value(), dacPort = dacPort : self.changeI(i, dacPort)) self.pid.spinD.valueChanged.connect(lambda d = self.pid.spinD.value(), dacPort = dacPort : self.changeD(d, dacPort)) self.pid.spinDt.valueChanged.connect(lambda dt = self.pid.spinDt.value(), dacPort = dacPort : self.changeDt(dt, dacPort)) self.pid.useDTBox.stateChanged.connect(lambda state = self.pid.useDTBox.isChecked(), dacPort = dacPort : self.constDt(state, dacPort)) self.pid.spinFactor.valueChanged.connect(lambda factor = self.pid.spinFactor.value(), dacPort = dacPort : self.changeFactor(factor, dacPort)) self.pid.spinExp.valueChanged.connect(lambda exponent = self.pid.spinExp.value(), dacPort = dacPort : self.changeExponent(exponent, dacPort)) self.pid.polarityBox.currentIndexChanged.connect(lambda index = self.pid.polarityBox.currentIndex(), dacPort = dacPort : self.changePolarity(index, dacPort)) self.pid.show() @inlineCallbacks def expChanged(self, exp, chan): #these are switched, dont know why exp = int(exp) yield self.server.set_exposure_time(chan,exp) def updateFrequency(self , c , signal): chan = signal[0] if chan in self.d : freq = signal[1] if not self.d[chan].measSwitch.isChecked(): self.d[chan].currentfrequency.setText('Not Measured') elif freq == -3.0: self.d[chan].currentfrequency.setText('Under Exposed') elif freq == -4.0: self.d[chan].currentfrequency.setText('Over Exposed') else: self.d[chan].currentfrequency.setText(str(freq)[0:10]) def updatePIDvoltage(self, c, signal): dacPort = signal[0] value = signal[1] if dacPort in self.wmChannels: try: self.d[self.wmChannels[dacPort]].PIDvoltage.setText('DAC Voltage (mV) '+"{:.1f}".format(value)) self.d[self.wmChannels[dacPort]].PIDindicator.update_slider(value/1000.0) except: pass def toggleMeas(self, c, signal): chan = signal[0] value = signal[1] if chan in self.d : self.d[chan].measSwitch.setChecked(value) def toggleLock(self, c, signal): self.lockSwitch.setChecked(signal) def toggleChannelLock(self, c, signal): wmChannel = signal[1] state = signal[2] if wmChannel in self.d: self.d[wmChannel].lockChannel.setChecked(bool(state)) def updateexp(self,c, signal): chan = signal[0] value = signal[1] if chan in self.d : self.d[chan].spinExp.setValue(value) def updateWLMOutput(self, c, signal): self.startSwitch.setChecked(signal) def updateAmplitude(self, c, signal): wmChannel = signal[0] value = signal[1] if wmChannel in self.d: #self.d[wmChannel].interfAmp.setText('Interferometer Amp\n' + str(value)) self.d[wmChannel].powermeter.setValue(value)#('Interferometer Amp\n' + str(value)) def setButtonOff(self,wmChannel): self.d[wmChannel].lockChannel.setChecked(False) @inlineCallbacks def changeState(self, state, chan): yield self.server.set_switcher_signal_state(chan, state) @inlineCallbacks def lockSingleChannel(self, state, dacPort): wmChannel = self.wmChannels[dacPort] yield self.server.set_channel_lock(dacPort, wmChannel, state) @inlineCallbacks def freqChanged(self,freq, dacPort): yield self.server.set_pid_course(dacPort, freq) @inlineCallbacks def setLock(self, state): yield self.server.set_lock_state(state) @inlineCallbacks def setOutput(self, state): yield self.server.set_wlm_output(state) @inlineCallbacks def getPIDCourse(self, dacPort, hint): course = yield self.server.get_pid_course(dacPort) try: course = float(course) except: try: course = float(hint) except: course = 600 returnValue(course) @inlineCallbacks def changeP(self, p, dacPort): yield self.server.set_pid_p(dacPort,p) @inlineCallbacks def changeI(self, i, dacPort): yield self.server.set_pid_i(dacPort,i) @inlineCallbacks def changeD(self, d, dacPort): yield self.server.set_pid_d(dacPort,d) @inlineCallbacks def changeDt(self, dt, dacPort): yield self.server.set_pid_dt(dacPort,dt) @inlineCallbacks def constDt(self, state, dacPort): if state == 0: yield self.server.set_const_dt(dacPort,False) else: yield self.server.set_const_dt(dacPort,True) @inlineCallbacks def changeFactor(self, factor, dacPort): yield self.server.set_pid_sensitivity(dacPort, factor, int(self.pid.spinExp.value())) @inlineCallbacks def changeExponent(self, exponent, dacPort): yield self.server.set_pid_sensitivity(dacPort, self.pid.spinFactor.value(), int(exponent)) @inlineCallbacks def changePolarity(self, index, dacPort): if index == 0: yield self.server.set_pid_polarity(dacPort,1) else: yield self.server.set_pid_polarity(dacPort,-1) def closeEvent(self, x): self.reactor.stop()
def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Multiplexed Wavemeter') qBox = QtGui.QGroupBox('Wave Length and Lock settings') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) self.lockSwitch = TextChangingButton('Lock Wave Meter') self.lockSwitch.setMaximumHeight(50) self.startSwitch = TextChangingButton('Wavemeter') self.startSwitch.setMaximumHeight(50) initstartvalue = yield self.server.get_wlm_output() initlockvalue = yield self.server.get_lock_state() self.lockSwitch.setChecked(initlockvalue) self.startSwitch.setChecked(initstartvalue) self.lockSwitch.toggled.connect(self.setLock) self.startSwitch.toggled.connect(self.setOutput) subLayout.addWidget(self.lockSwitch, 0, 2) subLayout.addWidget(self.startSwitch, 0, 0) for chan in self.chaninfo: wmChannel = self.chaninfo[chan][0] hint = self.chaninfo[chan][1] position = self.chaninfo[chan][2] stretched = self.chaninfo[chan][3] displayPID = self.chaninfo[chan][4] dacPort = self.chaninfo[chan][5] widget = QCustomWavemeterChannel(chan, wmChannel, dacPort, hint, stretched, displayPID) if displayPID: try: rails = self.chaninfo[chan][6] widget.PIDindicator.set_rails(rails) except: rails = [-10.0,10.0] widget.PIDindicator.set_rails(rails) from common.lib.clients.qtui import RGBconverter as RGB RGB = RGB.RGBconverter() color = int(2.998e8/(float(hint)*1e3)) color = RGB.wav2RGB(color) color = tuple(color) if dacPort != 0: self.wmChannels[dacPort] = wmChannel initcourse = yield self.getPIDCourse(dacPort, hint) widget.spinFreq.setValue(initcourse) widget.spinFreq.valueChanged.connect(lambda freq = widget.spinFreq.value(), dacPort = dacPort : self.freqChanged(freq, dacPort)) widget.setPID.clicked.connect(lambda state = widget.setPID.isDown(), chan = chan, dacPort = dacPort : self.InitializePIDGUI(dacPort, chan)) initLock = yield self.server.get_channel_lock(dacPort, wmChannel) widget.lockChannel.setChecked(bool(initLock)) widget.lockChannel.toggled.connect(lambda state = widget.lockChannel.isDown(), dacPort = dacPort : self.lockSingleChannel(state, dacPort)) else: widget.spinFreq.setValue(float(hint)) widget.lockChannel.toggled.connect(lambda state = widget.lockChannel.isDown(), wmChannel = wmChannel : self.setButtonOff(wmChannel)) widget.currentfrequency.setStyleSheet('color: rgb' + str(color)) widget.spinExp.valueChanged.connect(lambda exp = widget.spinExp.value(), wmChannel = wmChannel : self.expChanged(exp, wmChannel)) initvalue = yield self.server.get_exposure(wmChannel) widget.spinExp.setValue(initvalue) initmeas = yield self.server.get_switcher_signal_state(wmChannel) initmeas = initmeas widget.measSwitch.setChecked(bool(initmeas)) widget.measSwitch.toggled.connect(lambda state = widget.measSwitch.isDown(), wmChannel = wmChannel : self.changeState(state, wmChannel)) self.d[wmChannel] = widget subLayout.addWidget(self.d[wmChannel], position[1], position[0], 1, 3) self.setLayout(layout)
class wavemeterclient(QtGui.QWidget): def __init__(self, reactor, parent=None): """initializels the GUI creates the reactor and empty dictionary for channel widgets to be stored for iteration. also grabs chan info from multiplexer_config """ super(wavemeterclient, self).__init__() self.password = os.environ['LABRADPASSWORD'] self.setSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed) self.reactor = reactor self.name = socket.gethostname() + ' Wave Meter Client' self.d = {} self.wmChannels = {} self.connect() self._check_window_size() def _check_window_size(self): """Checks screen size to make sure window fits in the screen. """ desktop = QtGui.QDesktopWidget() screensize = desktop.availableGeometry() width = screensize.width() height = screensize.height() min_pixel_size = 1080 if (width <= min_pixel_size or height <= min_pixel_size): self.showMaximized() @inlineCallbacks def connect(self): """Creates an Asynchronous connection to the wavemeter computer and connects incoming signals to relavent functions """ self.chaninfo = multiplexer_config.info self.wavemeterIP = multiplexer_config.ip from labrad.wrappers import connectAsync self.cxn = yield connectAsync(self.wavemeterIP, name=self.name, password=self.password) self.server = yield self.cxn.multiplexerserver yield self.server.signal__frequency_changed(SIGNALID1) yield self.server.signal__selected_channels_changed(SIGNALID2) yield self.server.signal__update_exp(SIGNALID3) yield self.server.signal__lock_changed(SIGNALID4) yield self.server.signal__output_changed(SIGNALID5) yield self.server.signal__pidvoltage_changed(SIGNALID6) yield self.server.signal__channel_lock_changed(SIGNALID7) yield self.server.signal__amplitude_changed(SIGNALID8) yield self.server.addListener(listener=self.updateFrequency, source=None, ID=SIGNALID1) yield self.server.addListener(listener=self.toggleMeas, source=None, ID=SIGNALID2) yield self.server.addListener(listener=self.updateexp, source=None, ID=SIGNALID3) yield self.server.addListener(listener=self.toggleLock, source=None, ID=SIGNALID4) yield self.server.addListener(listener=self.updateWLMOutput, source=None, ID=SIGNALID5) yield self.server.addListener(listener=self.updatePIDvoltage, source=None, ID=SIGNALID6) yield self.server.addListener(listener=self.toggleChannelLock, source=None, ID=SIGNALID7) yield self.server.addListener(listener=self.updateAmplitude, source=None, ID=SIGNALID8) self.initializeGUI() @inlineCallbacks def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Multiplexed Wavemeter') qBox = QtGui.QGroupBox('Wave Length and Lock settings') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) self.lockSwitch = TextChangingButton('Lock Wave Meter') self.lockSwitch.setMaximumHeight(50) self.startSwitch = TextChangingButton('Wavemeter') self.startSwitch.setMaximumHeight(50) initstartvalue = yield self.server.get_wlm_output() initlockvalue = yield self.server.get_lock_state() self.lockSwitch.setChecked(initlockvalue) self.startSwitch.setChecked(initstartvalue) self.lockSwitch.toggled.connect(self.setLock) self.startSwitch.toggled.connect(self.setOutput) subLayout.addWidget(self.lockSwitch, 0, 2) subLayout.addWidget(self.startSwitch, 0, 0) for chan in self.chaninfo: wmChannel = self.chaninfo[chan][0] hint = self.chaninfo[chan][1] position = self.chaninfo[chan][2] stretched = self.chaninfo[chan][3] displayPID = self.chaninfo[chan][4] dacPort = self.chaninfo[chan][5] widget = QCustomWavemeterChannel(chan, wmChannel, dacPort, hint, stretched, displayPID) if displayPID: try: rails = self.chaninfo[chan][6] widget.PIDindicator.set_rails(rails) except: rails = [-10.0, 10.0] widget.PIDindicator.set_rails(rails) from common.lib.clients.qtui import RGBconverter as RGB RGB = RGB.RGBconverter() color = int(2.998e8 / (float(hint) * 1e3)) color = RGB.wav2RGB(color) color = tuple(color) if dacPort != 0: self.wmChannels[dacPort] = wmChannel initcourse = yield self.getPIDCourse(dacPort, hint) widget.spinFreq.setValue(initcourse) widget.spinFreq.valueChanged.connect( lambda freq=widget.spinFreq.value( ), dacPort=dacPort: self.freqChanged(freq, dacPort)) widget.setPID.clicked.connect( lambda state=widget.setPID.isDown(), chan=chan, dacPort= dacPort: self.InitializePIDGUI(dacPort, chan)) initLock = yield self.server.get_channel_lock( dacPort, wmChannel) widget.lockChannel.setChecked(bool(initLock)) widget.lockChannel.toggled.connect( lambda state=widget.lockChannel.isDown( ), dacPort=dacPort: self.lockSingleChannel(state, dacPort)) else: widget.spinFreq.setValue(float(hint)) widget.lockChannel.toggled.connect( lambda state=widget.lockChannel.isDown( ), wmChannel=wmChannel: self.setButtonOff(wmChannel)) widget.currentfrequency.setStyleSheet('color: rgb' + str(color)) widget.spinExp.valueChanged.connect( lambda exp=widget.spinExp.value( ), wmChannel=wmChannel: self.expChanged(exp, wmChannel)) initvalue = yield self.server.get_exposure(wmChannel) widget.spinExp.setValue(initvalue) initmeas = yield self.server.get_switcher_signal_state(wmChannel) initmeas = initmeas widget.measSwitch.setChecked(bool(initmeas)) widget.measSwitch.toggled.connect( lambda state=widget.measSwitch.isDown( ), wmChannel=wmChannel: self.changeState(state, wmChannel)) self.d[wmChannel] = widget subLayout.addWidget(self.d[wmChannel], position[1], position[0], 1, 3) self.setLayout(layout) @inlineCallbacks def InitializePIDGUI(self, dacPort, chan): self.pid = QCustomPID(dacPort) self.pid.setWindowTitle(chan + ' PID settings') self.pid.move(self.pos()) self.index = {1: 0, -1: 1} pInit = yield self.server.get_pid_p(dacPort) iInit = yield self.server.get_pid_i(dacPort) dInit = yield self.server.get_pid_d(dacPort) dtInit = yield self.server.get_pid_dt(dacPort) constInit = yield self.server.get_const_dt(dacPort) sensInit = yield self.server.get_pid_sensitivity(dacPort) polInit = yield self.server.get_pid_polarity(dacPort) self.pid.spinP.setValue(pInit) self.pid.spinI.setValue(iInit) self.pid.spinD.setValue(dInit) self.pid.spinDt.setValue(dtInit) self.pid.useDTBox.setCheckState(bool(constInit)) self.pid.spinFactor.setValue(sensInit[0]) self.pid.spinExp.setValue(sensInit[1]) self.pid.polarityBox.setCurrentIndex(self.index[polInit]) self.pid.spinP.valueChanged.connect(lambda p=self.pid.spinP.value( ), dacPort=dacPort: self.changeP(p, dacPort)) self.pid.spinI.valueChanged.connect(lambda i=self.pid.spinI.value( ), dacPort=dacPort: self.changeI(i, dacPort)) self.pid.spinD.valueChanged.connect(lambda d=self.pid.spinD.value( ), dacPort=dacPort: self.changeD(d, dacPort)) self.pid.spinDt.valueChanged.connect(lambda dt=self.pid.spinDt.value( ), dacPort=dacPort: self.changeDt(dt, dacPort)) self.pid.useDTBox.stateChanged.connect( lambda state=self.pid.useDTBox.isChecked( ), dacPort=dacPort: self.constDt(state, dacPort)) self.pid.spinFactor.valueChanged.connect( lambda factor=self.pid.spinFactor.value( ), dacPort=dacPort: self.changeFactor(factor, dacPort)) self.pid.spinExp.valueChanged.connect( lambda exponent=self.pid.spinExp.value( ), dacPort=dacPort: self.changeExponent(exponent, dacPort)) self.pid.polarityBox.currentIndexChanged.connect( lambda index=self.pid.polarityBox.currentIndex( ), dacPort=dacPort: self.changePolarity(index, dacPort)) self.pid.show() @inlineCallbacks def expChanged(self, exp, chan): #these are switched, dont know why exp = int(exp) yield self.server.set_exposure_time(chan, exp) def updateFrequency(self, c, signal): chan = signal[0] if chan in self.d: freq = signal[1] if not self.d[chan].measSwitch.isChecked(): self.d[chan].currentfrequency.setText('Not Measured') elif freq == -3.0: self.d[chan].currentfrequency.setText('Under Exposed') elif freq == -4.0: self.d[chan].currentfrequency.setText('Over Exposed') else: self.d[chan].currentfrequency.setText(str(freq)[0:10]) def updatePIDvoltage(self, c, signal): dacPort = signal[0] value = signal[1] if dacPort in self.wmChannels: try: self.d[self.wmChannels[dacPort]].PIDvoltage.setText( 'DAC Voltage (mV) ' + "{:.1f}".format(value)) self.d[self.wmChannels[dacPort]].PIDindicator.update_slider( value / 1000.0) except: pass def toggleMeas(self, c, signal): chan = signal[0] value = signal[1] if chan in self.d: self.d[chan].measSwitch.setChecked(value) def toggleLock(self, c, signal): self.lockSwitch.setChecked(signal) def toggleChannelLock(self, c, signal): wmChannel = signal[1] state = signal[2] if wmChannel in self.d: self.d[wmChannel].lockChannel.setChecked(bool(state)) def updateexp(self, c, signal): chan = signal[0] value = signal[1] if chan in self.d: self.d[chan].spinExp.setValue(value) def updateWLMOutput(self, c, signal): self.startSwitch.setChecked(signal) def updateAmplitude(self, c, signal): wmChannel = signal[0] value = signal[1] if wmChannel in self.d: #self.d[wmChannel].interfAmp.setText('Interferometer Amp\n' + str(value)) self.d[wmChannel].powermeter.setValue( value) #('Interferometer Amp\n' + str(value)) def setButtonOff(self, wmChannel): self.d[wmChannel].lockChannel.setChecked(False) @inlineCallbacks def changeState(self, state, chan): yield self.server.set_switcher_signal_state(chan, state) @inlineCallbacks def lockSingleChannel(self, state, dacPort): wmChannel = self.wmChannels[dacPort] yield self.server.set_channel_lock(dacPort, wmChannel, state) @inlineCallbacks def freqChanged(self, freq, dacPort): yield self.server.set_pid_course(dacPort, freq) @inlineCallbacks def setLock(self, state): yield self.server.set_lock_state(state) @inlineCallbacks def setOutput(self, state): yield self.server.set_wlm_output(state) @inlineCallbacks def getPIDCourse(self, dacPort, hint): course = yield self.server.get_pid_course(dacPort) try: course = float(course) except: try: course = float(hint) except: course = 600 returnValue(course) @inlineCallbacks def changeP(self, p, dacPort): yield self.server.set_pid_p(dacPort, p) @inlineCallbacks def changeI(self, i, dacPort): yield self.server.set_pid_i(dacPort, i) @inlineCallbacks def changeD(self, d, dacPort): yield self.server.set_pid_d(dacPort, d) @inlineCallbacks def changeDt(self, dt, dacPort): yield self.server.set_pid_dt(dacPort, dt) @inlineCallbacks def constDt(self, state, dacPort): if state == 0: yield self.server.set_const_dt(dacPort, False) else: yield self.server.set_const_dt(dacPort, True) @inlineCallbacks def changeFactor(self, factor, dacPort): yield self.server.set_pid_sensitivity(dacPort, factor, int(self.pid.spinExp.value())) @inlineCallbacks def changeExponent(self, exponent, dacPort): yield self.server.set_pid_sensitivity(dacPort, self.pid.spinFactor.value(), int(exponent)) @inlineCallbacks def changePolarity(self, index, dacPort): if index == 0: yield self.server.set_pid_polarity(dacPort, 1) else: yield self.server.set_pid_polarity(dacPort, -1) def closeEvent(self, x): self.reactor.stop()
def initializeGUI(self): self.layout = QtGui.QGridLayout() self.qBox = QtGui.QGroupBox('Trap Settings') self.subLayout = QtGui.QGridLayout() self.qBox.setLayout(self.subLayout) self.layout.addWidget(self.qBox, 0, 0) # Define dic for storting into self.dc = {} self.endCap = {} # Get config information self.init_params = TrapControl_config.params # Load RF Map self.rf_map = np.loadtxt('C:/Users/barium133/Code/barium/lib/clients/TrapControl_client/rf_map.txt') # Get channel numbers for each electrode self.rods = TrapControl_config.rods self.endCaps = TrapControl_config.endCaps self.eLens = TrapControl_config.eLens self.setWindowTitle('Trap Control') # Create widgets and lay them out. # Create general lock button to disable all buttons self.lockSwitch = TextChangingButton(('Locked','Unlocked')) # Start Unlocked self.lockSwitch.toggled.connect(self.set_lock) self.subLayout.addWidget(self.lockSwitch, 0, 4, 1, 2) #self.lockSwitch.setChecked(False) # Create a button to initialize trap params self.init_trap = QtGui.QPushButton('Set Default Values') self.init_trap.setMaximumHeight(30) self.init_trap.setFont(QtGui.QFont('MS Shell Dlg 2', pointSize=12)) self.init_trap.clicked.connect(lambda : self.init_state()) self.subLayout.addWidget(self.init_trap, 0, 0, 1, 2) # initialize main Gui self.trap = QCustomTrapGui() init_freq1 = yield self.server.get_frequency(self.rods['1']) self.trap.spinFreq1.setValue(init_freq1) self.trap.spinFreq1.valueChanged.connect(lambda freq = self.trap.spinFreq1.value(), channel = self.rods['1'] : self.freqChanged(freq, channel)) init_freq2 = yield self.server.get_frequency(self.rods['2']) self.trap.spinFreq2.setValue(init_freq2) self.trap.spinFreq2.valueChanged.connect(lambda freq = self.trap.spinFreq2.value(), channel = self.rods['2'] : self.freqChanged(freq, channel)) init_freq3 = yield self.server.get_frequency(self.rods['3']) self.trap.spinFreq3.setValue(init_freq3) self.trap.spinFreq3.valueChanged.connect(lambda freq = self.trap.spinFreq3.value(), channel = self.rods['3'] : self.freqChanged(freq, channel)) init_freq4 = yield self.server.get_frequency(self.rods['4']) self.trap.spinFreq4.setValue(init_freq4) self.trap.spinFreq4.valueChanged.connect(lambda freq = self.trap.spinFreq4.value(), channel = self.rods['4'] : self.freqChanged(freq, channel)) init_phase1 = yield self.server.get_phase(self.rods['1']) self.trap.spinPhase1.setValue(init_phase1) self.trap.spinPhase1.valueChanged.connect(lambda phase = self.trap.spinPhase1.value(), channel = self.rods['1'] : self.phaseChanged(phase, channel)) init_phase2 = yield self.server.get_phase(self.rods['2']) self.trap.spinPhase2.setValue(init_phase2) self.trap.spinPhase2.valueChanged.connect(lambda phase = self.trap.spinPhase2.value(), channel = self.rods['2'] : self.phaseChanged(phase, channel)) init_phase3 = yield self.server.get_phase(self.rods['3']) self.trap.spinPhase3.setValue(init_phase3) self.trap.spinPhase3.valueChanged.connect(lambda phase = self.trap.spinPhase3.value(), channel = self.rods['3'] : self.phaseChanged(phase, channel)) init_phase4 = yield self.server.get_phase(self.rods['4']) self.trap.spinPhase4.setValue(init_phase4) self.trap.spinPhase4.valueChanged.connect(lambda phase = self.trap.spinPhase4.value(), channel = self.rods['4'] : self.phaseChanged(phase, channel)) init_amp1 = yield self.server.get_amplitude(self.rods['1']) self.trap.spinAmp1.setValue(init_amp1) self.trap.spinAmp1.valueChanged.connect(lambda amp = self.trap.spinAmp1.value(), channel = self.rods['1'] : self.ampChanged(amp, channel)) init_amp2 = yield self.server.get_amplitude(self.rods['2']) self.trap.spinAmp2.setValue(init_amp2) self.trap.spinAmp2.valueChanged.connect(lambda amp = self.trap.spinAmp2.value(), channel = self.rods['2'] : self.ampChanged(amp, channel)) init_amp3 = yield self.server.get_amplitude(self.rods['3']) self.trap.spinAmp3.setValue(init_amp3) self.trap.spinAmp3.valueChanged.connect(lambda amp = self.trap.spinAmp3.value(), channel = self.rods['3'] : self.ampChanged(amp, channel)) init_amp4 = yield self.server.get_amplitude(self.rods['4']) self.trap.spinAmp4.setValue(init_amp4) self.trap.spinAmp4.valueChanged.connect(lambda amp = self.trap.spinAmp4.value(), channel = self.rods['4'] : self.ampChanged(amp, channel)) init_dc1 = yield self.server.get_dc_rod(self.rods['1']) self.trap.spinDC1.setValue(init_dc1) self.trap.spinDC1.valueChanged.connect(lambda dc = self.trap.spinDC1.value(), channel = self.rods['1'] : self.dcChanged(dc, channel)) init_dc2 = yield self.server.get_dc_rod(self.rods['2']) self.trap.spinDC2.setValue(init_dc2) self.trap.spinDC2.valueChanged.connect(lambda dc = self.trap.spinDC2.value(), channel = self.rods['2'] : self.dcChanged(dc, channel)) init_dc3 = yield self.server.get_dc_rod(self.rods['3']) self.trap.spinDC3.setValue(init_dc3) self.trap.spinDC3.valueChanged.connect(lambda dc = self.trap.spinDC3.value(), channel = self.rods['3'] : self.dcChanged(dc, channel)) init_dc4 = yield self.server.get_dc_rod(self.rods['4']) self.trap.spinDC4.setValue(init_dc4) self.trap.spinDC4.valueChanged.connect(lambda dc = self.trap.spinDC4.value(), channel = self.rods['4'] : self.dcChanged(dc, channel)) init_hv1 = yield self.server.get_hv(self.rods['1']) self.trap.spinHV1.setValue(init_hv1) self.trap.spinHV1.valueChanged.connect(lambda hv = self.trap.spinHV1.value(), channel = self.rods['1'] : self.hvChanged(hv, channel)) init_hv2 = yield self.server.get_hv(self.rods['2']) self.trap.spinHV2.setValue(init_hv2) self.trap.spinHV2.valueChanged.connect(lambda hv = self.trap.spinHV2.value(), channel = self.rods['2'] : self.hvChanged(hv, channel)) init_hv3 = yield self.server.get_hv(self.rods['3']) self.trap.spinHV3.setValue(init_hv3) self.trap.spinHV3.valueChanged.connect(lambda hv = self.trap.spinHV3.value(), channel = self.rods['3'] : self.hvChanged(hv, channel)) init_hv4 = yield self.server.get_hv(self.rods['4']) self.trap.spinHV4.setValue(init_hv4) self.trap.spinHV4.valueChanged.connect(lambda hv = self.trap.spinHV4.value(), channel = self.rods['4'] : self.hvChanged(hv, channel)) init_ec1 = yield self.server.get_dc(self.endCaps['1']) self.trap.spinEndCap1.setValue(init_ec1) self.trap.spinEndCap1.valueChanged.connect(lambda voltage = self.trap.spinEndCap1.value(), channel = self.endCaps['1'] : self.endCapChanged(voltage, channel)) init_ec2 = yield self.server.get_dc(self.endCaps['2']) self.trap.spinEndCap2.setValue(init_ec2) self.trap.spinEndCap2.valueChanged.connect(lambda voltage = self.trap.spinEndCap2.value(), channel = self.endCaps['2'] : self.endCapChanged(voltage, channel)) init_eL1 = yield self.server.get_hv(self.eLens['1']) self.trap.E1Spin.setValue(init_eL1) self.trap.E1Spin.valueChanged.connect(lambda voltage = self.trap.E1Spin.value(), channel = self.eLens['1'] : self.hvChanged(voltage, channel)) init_eL2 = yield self.server.get_hv(self.eLens['2']) self.trap.E2Spin.setValue(init_eL2) self.trap.E2Spin.valueChanged.connect(lambda voltage = self.trap.E2Spin.value(), channel = self.eLens['2'] : self.hvChanged(voltage, channel)) init_rf = yield self.server.get_rf_map_state() self.trap.useRFMap.setCheckState(init_rf) self.trap.useRFMap.stateChanged.connect(lambda state = self.trap.useRFMap.isChecked() : self.rfMapChanged(state)) init_rf_en = yield self.server.get_rf_state() self.trap.enableRF.setCheckState(init_rf_en) self.trap.enableRF.stateChanged.connect(lambda state = self.trap.enableRF.isChecked() : self.enableRFChanged(state)) init_bat = yield self.server.get_battery_charging() self.trap.setCharging.setCheckState(init_bat) self.trap.setCharging.stateChanged.connect(lambda state = self.trap.setCharging.isChecked() : self.chargingChanged(state)) self.trap.update_rf.clicked.connect(lambda : self.update_rf()) self.trap.update_dc.clicked.connect(lambda : self.update_dc()) self.trap.clearPhase.clicked.connect(lambda : self.clear_phase()) # Get the current state of the trap and set the gui #self.set_current_state() self.subLayout.addWidget(self.trap, 1, 0, 1, 6) self.ablation = QCustomAblationGui() self.ablation.loading_time_spin.valueChanged.connect(lambda time = self.ablation.loading_time_spin.value() : self.delayChanged(time)) self.ablation.loading_time_spin.setValue(self.init_params['Loading Time']) self.ablation.trigger_loading.clicked.connect(lambda : self.triggerLoading()) self.subLayout.addWidget(self.ablation, 2, 0, 1, 2) # HV Gui self.hvGUI = QCustomHVPulseGui() self.hvGUI.hv_pulse.clicked.connect(lambda : self.hv_pulse()) self.hvGUI.hv_graph.clicked.connect(lambda : self.hv_graph()) self.subLayout.addWidget(self.hvGUI, 2, 5, 1, 1) # Add current controler self.HP = HP6033A_Client(self.reactor) self.HP.self_connect('bender',"HP6033A Client",0) self.subLayout.addWidget(self.HP, 2, 2, 1, 2) self.ARampGUI = QCustomARampGui() self.ARampGUI.ARamp.clicked.connect(lambda: self.a_ramp()) self.subLayout.addWidget(self.ARampGUI, 2, 4, 1, 1) self.setLayout(self.layout)
class QCustomFreqPower(QtGui.QFrame): def __init__(self, title, switchable=True, parent=None): QtGui.QWidget.__init__(self, parent) self.setFrameStyle(0x0001 | 0x0030) self.makeLayout(title, switchable) def makeLayout(self, title, switchable): layout = QtGui.QGridLayout() #labels title = QtGui.QLabel(title) title.setFont(QtGui.QFont('MS Shell Dlg 2', pointSize=16)) title.setAlignment(QtCore.Qt.AlignCenter) freqlabel = QtGui.QLabel('Frequency (MHz)') powerlabel = QtGui.QLabel('Power (dBM)') if switchable: layout.addWidget(title, 0, 0, 1, 3) else: layout.addWidget(title, 0, 0, 1, 2) layout.addWidget(freqlabel, 1, 0, 1, 1) layout.addWidget(powerlabel, 1, 1, 1, 1) #editable fields self.spinFreq = QtGui.QDoubleSpinBox() self.spinFreq.setFont(QtGui.QFont('MS Shell Dlg 2', pointSize=16)) self.spinFreq.setDecimals(3) self.spinFreq.setSingleStep(0.1) self.spinFreq.setRange(10.0, 250.0) self.spinFreq.setKeyboardTracking(False) self.spinPower = QtGui.QDoubleSpinBox() self.spinPower.setFont(QtGui.QFont('MS Shell Dlg 2', pointSize=16)) self.spinPower.setDecimals(3) self.spinPower.setSingleStep(0.1) self.spinPower.setRange(-145.0, 30.0) self.spinPower.setKeyboardTracking(False) layout.addWidget(self.spinFreq, 2, 0) layout.addWidget(self.spinPower, 2, 1) if switchable: self.buttonSwitch = TextChangingButton(("I", "O")) layout.addWidget(self.buttonSwitch, 2, 2) self.setLayout(layout) def setPowerRange(self, powerrange): self.spinPower.setRange(*powerrange) def setFreqRange(self, freqrange): self.spinFreq.setRange(*freqrange) def setPowerNoSignal(self, power): self.spinPower.blockSignals(True) self.spinPower.setValue(power) self.spinPower.blockSignals(False) def setFreqNoSignal(self, freq): self.spinFreq.blockSignals(True) self.spinFreq.setValue(freq) self.spinFreq.blockSignals(False) def setStateNoSignal(self, state): self.buttonSwitch.blockSignals(True) self.buttonSwitch.setChecked(state) self.buttonSwitch.setAppearance(state) self.buttonSwitch.blockSignals(False)
def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Multiplexed Wavemeter') qBox = QtGui.QGroupBox('Wave Length and Lock settings') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) self.lockSwitch = TextChangingButton('Lock Wave Meter') self.lockSwitch.setMaximumHeight(50) self.startSwitch = TextChangingButton('Wavemeter') self.startSwitch.setMaximumHeight(50) initstartvalue = yield self.server.get_wlm_output() initlockvalue = yield self.server.get_lock_state() self.lockSwitch.setChecked(initlockvalue) self.startSwitch.setChecked(initstartvalue) self.lockSwitch.toggled.connect(self.setLock) self.startSwitch.toggled.connect(self.setOutput) subLayout.addWidget(self.lockSwitch, 0, 2) subLayout.addWidget(self.startSwitch, 0, 0) for chan in self.chaninfo: wmChannel = self.chaninfo[chan][0] hint = self.chaninfo[chan][1] position = self.chaninfo[chan][2] stretched = self.chaninfo[chan][3] displayPID = self.chaninfo[chan][4] dacPort = self.chaninfo[chan][5] widget = QCustomWavemeterChannel(chan, wmChannel, dacPort, hint, stretched, displayPID) if displayPID: try: rails = self.chaninfo[chan][6] widget.PIDindicator.set_rails(rails) except: rails = [-10.0, 10.0] widget.PIDindicator.set_rails(rails) from common.lib.clients.qtui import RGBconverter as RGB RGB = RGB.RGBconverter() color = int(2.998e8 / (float(hint) * 1e3)) color = RGB.wav2RGB(color) color = tuple(color) if dacPort != 0: self.wmChannels[dacPort] = wmChannel initcourse = yield self.getPIDCourse(dacPort, hint) widget.spinFreq.setValue(initcourse) widget.spinFreq.valueChanged.connect( lambda freq=widget.spinFreq.value( ), dacPort=dacPort: self.freqChanged(freq, dacPort)) widget.setPID.clicked.connect( lambda state=widget.setPID.isDown(), chan=chan, dacPort= dacPort: self.InitializePIDGUI(dacPort, chan)) initLock = yield self.server.get_channel_lock( dacPort, wmChannel) widget.lockChannel.setChecked(bool(initLock)) widget.lockChannel.toggled.connect( lambda state=widget.lockChannel.isDown( ), dacPort=dacPort: self.lockSingleChannel(state, dacPort)) else: widget.spinFreq.setValue(float(hint)) widget.lockChannel.toggled.connect( lambda state=widget.lockChannel.isDown( ), wmChannel=wmChannel: self.setButtonOff(wmChannel)) widget.currentfrequency.setStyleSheet('color: rgb' + str(color)) widget.spinExp.valueChanged.connect( lambda exp=widget.spinExp.value( ), wmChannel=wmChannel: self.expChanged(exp, wmChannel)) initvalue = yield self.server.get_exposure(wmChannel) widget.spinExp.setValue(initvalue) initmeas = yield self.server.get_switcher_signal_state(wmChannel) initmeas = initmeas widget.measSwitch.setChecked(bool(initmeas)) widget.measSwitch.toggled.connect( lambda state=widget.measSwitch.isDown( ), wmChannel=wmChannel: self.changeState(state, wmChannel)) self.d[wmChannel] = widget subLayout.addWidget(self.d[wmChannel], position[1], position[0], 1, 3) self.setLayout(layout)
class wavemeterclient(QtGui.QWidget): def __init__(self, reactor, parent=None): """initializes the GUI, creates the reactor and empty dictionary for channel widgets to be stored for iteration. also grabs chan info from multiplexer_config """ super(wavemeterclient, self).__init__() self.password = os.environ['LABRADPASSWORD'] self.setSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed) self.reactor = reactor self.name = socket.gethostname() + ' Wave Meter Client' self.d = {} self.wmChannels = {} self.connect() self._check_window_size() def _check_window_size(self): """Checks screen size to make sure window fits in the screen. """ desktop = QtGui.QDesktopWidget() screensize = desktop.availableGeometry() width = screensize.width() height = screensize.height() min_pixel_size = 1080 if (width <= min_pixel_size or height <= min_pixel_size): self.showMaximized() @inlineCallbacks def connect(self): """Creates an Asynchronous connection to the wavemeter computer and connects incoming signals to relavent functions """ self.chaninfo = multiplexer_config.info self.wavemeterIP = multiplexer_config.ip from labrad.wrappers import connectAsync self.cxn = yield connectAsync(self.wavemeterIP, name=self.name, password=self.password) self.server = yield self.cxn.multiplexerserver yield self.server.signal__frequency_changed(SIGNALID1) yield self.server.signal__selected_channels_changed(SIGNALID2) yield self.server.signal__update_exp(SIGNALID3) yield self.server.signal__output_changed(SIGNALID5) yield self.server.signal__amplitude_changed(SIGNALID8) yield self.server.addListener(listener=self.updateFrequency, source=None, ID=SIGNALID1) yield self.server.addListener(listener=self.toggleMeas, source=None, ID=SIGNALID2) yield self.server.addListener(listener=self.updateexp, source=None, ID=SIGNALID3) yield self.server.addListener(listener=self.updateWLMOutput, source=None, ID=SIGNALID5) yield self.server.addListener(listener=self.updateAmplitude, source=None, ID=SIGNALID8) # starts display of wavemeter data self.initializeGUI() @inlineCallbacks def initializeGUI(self): """ TODO: modify QCustomWavemeterChannel to get rid of PID button """ layout = QtGui.QGridLayout() self.setWindowTitle('Multiplexed Wavemeter') # this "group" contains all 8 channel outputs and settings qBox = QtGui.QGroupBox('Wave Length and Lock settings') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) # button to start wavemeter measurement (turn wavemeter on) self.startSwitch = TextChangingButton('Wavemeter') self.startSwitch.setMaximumHeight(50) initstartvalue = yield self.server.get_wlm_output() self.startSwitch.setChecked(initstartvalue) self.startSwitch.toggled.connect(self.setOutput) subLayout.addWidget(self.startSwitch, 0, 0) # create display box for each channel # need to modify QCustomWavemeterChannel to get rid of PID button for chan in self.chaninfo: wmChannel = self.chaninfo[chan][0] hint = self.chaninfo[chan][1] position = self.chaninfo[chan][2] stretched = self.chaninfo[chan][3] displayPID = self.chaninfo[chan][4] dacPort = self.chaninfo[chan][5] widget = QCustomWavemeterChannel(chan, wmChannel, dacPort, hint, stretched, displayPID) from common.lib.clients.qtui import RGBconverter as RGB RGB = RGB.RGBconverter() color = int(2.998e8 / (float(hint) * 1e3)) color = RGB.wav2RGB(color) color = tuple(color) widget.currentfrequency.setStyleSheet('color: rgb' + str(color)) widget.spinExp.valueChanged.connect( lambda exp=widget.spinExp.value( ), wmChannel=wmChannel: self.expChanged(exp, wmChannel)) initvalue = yield self.server.get_exposure(wmChannel) widget.spinExp.setValue(initvalue) initmeas = yield self.server.get_switcher_signal_state(wmChannel) initmeas = initmeas widget.measSwitch.setChecked(bool(initmeas)) widget.measSwitch.toggled.connect( lambda state=widget.measSwitch.isDown( ), wmChannel=wmChannel: self.changeState(state, wmChannel)) self.d[wmChannel] = widget subLayout.addWidget(self.d[wmChannel], position[1], position[0], 1, 3) self.setLayout(layout) # updates exposure time from GUI? @inlineCallbacks def expChanged(self, exp, chan): # these are switched, dont know why exp = int(exp) yield self.server.set_exposure_time(chan, exp) # sets display of update frequency and light exposure level def updateFrequency(self, c, signal): chan = signal[0] if chan in self.d: freq = signal[1] if not self.d[chan].measSwitch.isChecked(): self.d[chan].currentfrequency.setText('Not Measured') elif freq == -3.0: self.d[chan].currentfrequency.setText('Under Exposed') elif freq == -4.0: self.d[chan].currentfrequency.setText('Over Exposed') else: self.d[chan].currentfrequency.setText(str(freq)[0:10]) def toggleMeas(self, c, signal): chan = signal[0] value = signal[1] if chan in self.d: self.d[chan].measSwitch.setChecked(value) def updateexp(self, c, signal): chan = signal[0] value = signal[1] if chan in self.d: self.d[chan].spinExp.setValue(value) def updateWLMOutput(self, c, signal): self.startSwitch.setChecked(signal) def updateAmplitude(self, c, signal): wmChannel = signal[0] value = signal[1] if wmChannel in self.d: self.d[wmChannel].powermeter.setValue(value) def setButtonOff(self, wmChannel): self.d[wmChannel].lockChannel.setChecked(False) @inlineCallbacks def changeState(self, state, chan): yield self.server.set_switcher_signal_state(chan, state) @inlineCallbacks def setOutput(self, state): yield self.server.set_wlm_output(state) def closeEvent(self, x): self.reactor.stop()
class QCustomFreqPower(QtGui.QFrame): def __init__(self, title, switchable = True, parent=None): QtGui.QWidget.__init__(self, parent) self.setFrameStyle(0x0001 | 0x0030) self.makeLayout(title, switchable) def makeLayout(self, title, switchable): layout = QtGui.QGridLayout() #labels title = QtGui.QLabel(title) title.setFont(QtGui.QFont('MS Shell Dlg 2',pointSize=16)) title.setAlignment(QtCore.Qt.AlignCenter) freqlabel = QtGui.QLabel('Frequency (MHz)') powerlabel = QtGui.QLabel('Power (dBM)') if switchable: layout.addWidget(title,0, 0, 1, 3) else: layout.addWidget(title,0, 0, 1, 2) layout.addWidget(freqlabel,1, 0, 1, 1) layout.addWidget(powerlabel,1, 1, 1, 1) #editable fields self.spinFreq = QtGui.QDoubleSpinBox() self.spinFreq.setFont(QtGui.QFont('MS Shell Dlg 2',pointSize=16)) self.spinFreq.setDecimals(3) self.spinFreq.setSingleStep(0.1) self.spinFreq.setRange(10.0,250.0) self.spinFreq.setKeyboardTracking(False) self.spinPower = QtGui.QDoubleSpinBox() self.spinPower.setFont(QtGui.QFont('MS Shell Dlg 2',pointSize=16)) self.spinPower.setDecimals(3) self.spinPower.setSingleStep(0.1) self.spinPower.setRange(-145.0, 30.0) self.spinPower.setKeyboardTracking(False) layout.addWidget(self.spinFreq, 2, 0) layout.addWidget(self.spinPower, 2, 1) if switchable: self.buttonSwitch = TextChangingButton(("I", "O")) layout.addWidget(self.buttonSwitch, 2, 2) self.setLayout(layout) def setPowerRange(self, powerrange): self.spinPower.setRange(*powerrange) def setFreqRange(self, freqrange): self.spinFreq.setRange(*freqrange) def setPowerNoSignal(self, power): self.spinPower.blockSignals(True) self.spinPower.setValue(power) self.spinPower.blockSignals(False) def setFreqNoSignal(self, freq): self.spinFreq.blockSignals(True) self.spinFreq.setValue(freq) self.spinFreq.blockSignals(False) def setStateNoSignal(self, state): self.buttonSwitch.blockSignals(True) self.buttonSwitch.setChecked(state) self.buttonSwitch.setAppearance(state) self.buttonSwitch.blockSignals(False)
class wavemeterclient(QtGui.QWidget): def __init__(self, reactor, parent=None): """initializes the GUI, creates the reactor and empty dictionary for channel widgets to be stored for iteration. also grabs chan info from multiplexer_config """ super(wavemeterclient, self).__init__() self.password = os.environ['LABRADPASSWORD'] self.setSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed) self.reactor = reactor self.name = socket.gethostname() + ' Wave Meter Client' self.d = {} self.wmChannels = {} self.connect() self._check_window_size() def _check_window_size(self): """Checks screen size to make sure window fits in the screen. """ desktop = QtGui.QDesktopWidget() screensize = desktop.availableGeometry() width = screensize.width() height = screensize.height() min_pixel_size = 1080 if (width <= min_pixel_size or height <= min_pixel_size): self.showMaximized() @inlineCallbacks def connect(self): """Creates an Asynchronous connection to the wavemeter computer and connects incoming signals to relavent functions """ self.chaninfo = multiplexer_config.info self.wavemeterIP = multiplexer_config.ip from labrad.wrappers import connectAsync self.cxn = yield connectAsync(self.wavemeterIP, name=self.name, password=self.password) self.server = yield self.cxn.multiplexerserver yield self.server.signal__frequency_changed(SIGNALID1) yield self.server.signal__selected_channels_changed(SIGNALID2) yield self.server.signal__update_exp(SIGNALID3) yield self.server.signal__output_changed(SIGNALID5) yield self.server.signal__amplitude_changed(SIGNALID8) yield self.server.addListener(listener=self.updateFrequency, source=None, ID=SIGNALID1) yield self.server.addListener(listener=self.toggleMeas, source=None, ID=SIGNALID2) yield self.server.addListener(listener=self.updateexp, source=None, ID=SIGNALID3) yield self.server.addListener(listener=self.updateWLMOutput, source=None, ID=SIGNALID5) yield self.server.addListener(listener=self.updateAmplitude, source=None, ID=SIGNALID8) # starts display of wavemeter data self.initializeGUI() @inlineCallbacks def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Wavemeter') # this "group" contains all 8 channel outputs and settings qBox = QtGui.QGroupBox('Wave Length and Lock settings') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) # button to start wavemeter measurement (turn wavemeter on) self.startSwitch = TextChangingButton('Wavemeter') self.startSwitch.setMaximumHeight(50) initstartvalue = yield self.server.get_wlm_output() self.startSwitch.setChecked(initstartvalue) self.startSwitch.toggled.connect(self.setOutput) subLayout.addWidget(self.startSwitch, 0, 0) # create display box for each channel # need to modify QCustomWavemeterChannel to get rid of PID button for chan in self.chaninfo: wmChannel = self.chaninfo[chan][0] hint = self.chaninfo[chan][1] position = self.chaninfo[chan][2] stretched = self.chaninfo[chan][3] widget = QCustomWavemeterChannel(chan, wmChannel, hint, stretched) from common.lib.clients.qtui import RGBconverter as RGB RGB = RGB.RGBconverter() color = int(2.998e8/(float(hint)*1e3)) color = RGB.wav2RGB(color) color = tuple(color) widget.currentfrequency.setStyleSheet('color: rgb' + str(color)) widget.spinExp.valueChanged.connect(lambda exp=widget.spinExp.value(), wmChannel=wmChannel : self.expChanged(exp, wmChannel)) initvalue = yield self.server.get_exposure(wmChannel) widget.spinExp.setValue(initvalue) initmeas = yield self.server.get_switcher_signal_state(wmChannel) initmeas = initmeas widget.measSwitch.setChecked(bool(initmeas)) widget.measSwitch.toggled.connect(lambda state=widget.measSwitch.isDown(), wmChannel=wmChannel : self.changeState(state, wmChannel)) self.d[wmChannel] = widget subLayout.addWidget(self.d[wmChannel], position[1], position[0], 1, 3) self.setLayout(layout) # updates exposure time from GUI? @inlineCallbacks def expChanged(self, exp, chan): # these are switched, dont know why exp = int(exp) yield self.server.set_exposure_time(chan, exp) # sets display of update frequency and light exposure level def updateFrequency(self, c, signal): chan = signal[0] if chan in self.d: freq = signal[1] if not self.d[chan].measSwitch.isChecked(): self.d[chan].currentfrequency.setText('Not Measured') elif freq == -3.0: self.d[chan].currentfrequency.setText('Under Exposed') elif freq == -4.0: self.d[chan].currentfrequency.setText('Over Exposed') elif freq == -17.0: self.d[chan].currentfrequency.setText('Data Error') else: self.d[chan].currentfrequency.setText(str(freq)[0:10]) def toggleMeas(self, c, signal): chan = signal[0] value = signal[1] if chan in self.d: self.d[chan].measSwitch.setChecked(value) def updateexp(self, c, signal): chan = signal[0] value = signal[1] if chan in self.d: self.d[chan].spinExp.setValue(value) def updateWLMOutput(self, c, signal): self.startSwitch.setChecked(signal) def updateAmplitude(self, c, signal): wmChannel = signal[0] value = signal[1] if wmChannel in self.d: self.d[wmChannel].powermeter.setValue(value) def setButtonOff(self, wmChannel): self.d[wmChannel].lockChannel.setChecked(False) @inlineCallbacks def changeState(self, state, chan): yield self.server.set_switcher_signal_state(chan, state) @inlineCallbacks def setOutput(self, state): yield self.server.set_wlm_output(state) def closeEvent(self, x): self.reactor.stop()
class rigolclient(QtGui.QWidget): def __init__(self, reactor, parent = None): """initializels the GUI creates the reactor """ super(rigolclient, self).__init__() self.setSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Fixed) self.reactor = reactor self.connect() @inlineCallbacks def connect(self): """Creates an Asynchronous connection """ from labrad.wrappers import connectAsync from labrad.units import WithUnit as U self.U = U self.cxn = yield connectAsync(name = "rigol client") self.server = self.cxn.rigol_dg1022_server self.devicelist = yield self.server.list_devices() if self.devicelist: yield self.server.select_device(0) self.initializeGUI() def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Rigol DG1022 Control') qBox = QtGui.QGroupBox('Rigol DG1022') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) self.deviceselect = QtGui.QComboBox(self) self.updatedevices() self.offsetwidget1 = QCustomSpinBox('Offset', (-5, 5)) self.offsetwidget2 = QCustomSpinBox('Offset', (-5, 5)) self.volt1widget = QCustomSpinBox('Amplitude (Vpp)', (-10, 10)) self.freq1widget = QCustomSpinBox('Frequency (Hz)', (0, 40e6)) self.volt2widget = QCustomSpinBox('Amplitude (Vpp)', (-10, 10)) self.freq2widget = QCustomSpinBox('Frequency (Hz)', (0, 40e6)) self.waveselect1 = QtGui.QComboBox(self) self.waveselect2 = QtGui.QComboBox(self) self.output1 = TextChangingButton(('On','Off')) self.output2 = TextChangingButton(('On','Off')) self.waveselect1.addItem("sine") self.waveselect1.addItem("square") self.waveselect1.addItem("ramp") self.waveselect1.addItem("pulse") self.waveselect1.addItem("noise") self.waveselect1.addItem("DC") self.waveselect1.addItem("USER") self.waveselect2.addItem("sine") self.waveselect2.addItem("square") self.waveselect2.addItem("ramp") self.waveselect2.addItem("pulse") self.waveselect2.addItem("noise") self.waveselect2.addItem("DC") self.waveselect2.addItem("USER") self.output1.toggled.connect(lambda state = self.output1.isDown(), chan = 1, : self.setoutput(chan, state)) self.output2.toggled.connect(lambda state = self.output1.isDown(), chan = 2, : self.setoutput(chan, state)) self.volt1widget.spinLevel.valueChanged.connect(lambda value = self.volt1widget.spinLevel.value(), chan = 1 : self.voltchanged(chan, value)) self.volt2widget.spinLevel.valueChanged.connect(lambda value = self.volt2widget.spinLevel.value(), chan = 2 : self.voltchanged(chan, value)) self.freq1widget.spinLevel.valueChanged.connect(lambda value = self.freq1widget.spinLevel.value(), chan = 1 : self.freqchanged(chan, value)) self.freq2widget.spinLevel.valueChanged.connect(lambda value = self.freq2widget.spinLevel.value(), chan = 2 : self.freqchanged(chan, value)) self.offsetwidget1.spinLevel.valueChanged.connect(lambda value = self.offsetwidget1.spinLevel.value(), chan = 1 : self.offsetchanged(chan, value)) self.offsetwidget2.spinLevel.valueChanged.connect(lambda value = self.offsetwidget2.spinLevel.value(), chan = 2 : self.offsetchanged(chan, value)) self.waveselect1.activated[str].connect(lambda wave = self.waveselect1.currentText(), chan = 1 : self.waveselect(chan, wave)) self.waveselect2.activated[str].connect(lambda wave = self.waveselect2.currentText(), chan = 2 : self.waveselect(chan, wave)) self.deviceselect.activated[str].connect(self.changedevice) subLayout.addWidget(self.freq1widget, 1,0) subLayout.addWidget(self.volt1widget, 1,1) subLayout.addWidget(self.freq2widget, 1,2) subLayout.addWidget(self.volt2widget, 1,3) subLayout.addWidget(self.waveselect1, 2,0, 1,2) subLayout.addWidget(self.waveselect2, 2,2, 1,2) subLayout.addWidget(self.offsetwidget1, 3,0) subLayout.addWidget(self.offsetwidget2, 3,2) subLayout.addWidget(self.output1, 3,1) subLayout.addWidget(self.output2, 3,3) subLayout.addWidget(self.deviceselect, 0,3) self.setLayout(layout) @inlineCallbacks def voltchanged(self, chan, value): value = self.U(value, 'V') yield self.server.amplitude(chan, value) @inlineCallbacks def freqchanged(self, chan, value): value = self.U(value, 'Hz') yield self.server.frequency(chan, value) @inlineCallbacks def offsetchanged(self, chan, value): value = self.U(value, 'V') yield self.server.offset(chan, value) @inlineCallbacks def setoutput(self, chan, state): yield self.server.output(chan, state) @inlineCallbacks def waveselect(self, chan, wave): if wave == 'DC': if chan == 1: self.freq1widget.setEnabled(False) else: self.freq2widget.setEnabled(False) else: self.freq1widget.setEnabled(True) self.freq2widget.setEnabled(True) yield self.server.wave_function(chan, str(wave)) @inlineCallbacks def changedevice(self, deviceid): if deviceid == 'Refresh List': yield self.server.refresh() self.updatedevices() else: self.server.release_device() self.server.select_device(int(deviceid[1])) @inlineCallbacks def updatedevices(self): self.deviceselect.clear() self.devicelist = yield self.server.list_devices() for device in self.devicelist: self.deviceselect.addItem(str(device)) self.deviceselect.addItem('Refresh List') def closeEvent(self, x): self.reactor.stop()
def initializeGUI(self): layout = QtGui.QGridLayout() self.setWindowTitle('Rigol DG1022 Control') qBox = QtGui.QGroupBox('Rigol DG1022') subLayout = QtGui.QGridLayout() qBox.setLayout(subLayout) layout.addWidget(qBox, 0, 0) self.deviceselect = QtGui.QComboBox(self) self.updatedevices() self.offsetwidget1 = QCustomSpinBox('Offset', (-5, 5)) self.offsetwidget2 = QCustomSpinBox('Offset', (-5, 5)) self.volt1widget = QCustomSpinBox('Amplitude (Vpp)', (-10, 10)) self.freq1widget = QCustomSpinBox('Frequency (Hz)', (0, 40e6)) self.volt2widget = QCustomSpinBox('Amplitude (Vpp)', (-10, 10)) self.freq2widget = QCustomSpinBox('Frequency (Hz)', (0, 40e6)) self.waveselect1 = QtGui.QComboBox(self) self.waveselect2 = QtGui.QComboBox(self) self.output1 = TextChangingButton(('On','Off')) self.output2 = TextChangingButton(('On','Off')) self.waveselect1.addItem("sine") self.waveselect1.addItem("square") self.waveselect1.addItem("ramp") self.waveselect1.addItem("pulse") self.waveselect1.addItem("noise") self.waveselect1.addItem("DC") self.waveselect1.addItem("USER") self.waveselect2.addItem("sine") self.waveselect2.addItem("square") self.waveselect2.addItem("ramp") self.waveselect2.addItem("pulse") self.waveselect2.addItem("noise") self.waveselect2.addItem("DC") self.waveselect2.addItem("USER") self.output1.toggled.connect(lambda state = self.output1.isDown(), chan = 1, : self.setoutput(chan, state)) self.output2.toggled.connect(lambda state = self.output1.isDown(), chan = 2, : self.setoutput(chan, state)) self.volt1widget.spinLevel.valueChanged.connect(lambda value = self.volt1widget.spinLevel.value(), chan = 1 : self.voltchanged(chan, value)) self.volt2widget.spinLevel.valueChanged.connect(lambda value = self.volt2widget.spinLevel.value(), chan = 2 : self.voltchanged(chan, value)) self.freq1widget.spinLevel.valueChanged.connect(lambda value = self.freq1widget.spinLevel.value(), chan = 1 : self.freqchanged(chan, value)) self.freq2widget.spinLevel.valueChanged.connect(lambda value = self.freq2widget.spinLevel.value(), chan = 2 : self.freqchanged(chan, value)) self.offsetwidget1.spinLevel.valueChanged.connect(lambda value = self.offsetwidget1.spinLevel.value(), chan = 1 : self.offsetchanged(chan, value)) self.offsetwidget2.spinLevel.valueChanged.connect(lambda value = self.offsetwidget2.spinLevel.value(), chan = 2 : self.offsetchanged(chan, value)) self.waveselect1.activated[str].connect(lambda wave = self.waveselect1.currentText(), chan = 1 : self.waveselect(chan, wave)) self.waveselect2.activated[str].connect(lambda wave = self.waveselect2.currentText(), chan = 2 : self.waveselect(chan, wave)) self.deviceselect.activated[str].connect(self.changedevice) subLayout.addWidget(self.freq1widget, 1,0) subLayout.addWidget(self.volt1widget, 1,1) subLayout.addWidget(self.freq2widget, 1,2) subLayout.addWidget(self.volt2widget, 1,3) subLayout.addWidget(self.waveselect1, 2,0, 1,2) subLayout.addWidget(self.waveselect2, 2,2, 1,2) subLayout.addWidget(self.offsetwidget1, 3,0) subLayout.addWidget(self.offsetwidget2, 3,2) subLayout.addWidget(self.output1, 3,1) subLayout.addWidget(self.output2, 3,3) subLayout.addWidget(self.deviceselect, 0,3) self.setLayout(layout)