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, 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 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 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)
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)
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)
