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)
