class CameraClient(QtWidgets.QWidget):
andor_servername = 'andor'
andor_serial_number = 0
servername = 'camera'
update_id = np.random.randint(0, 2**31 - 1)
data_directory = os.path.join(os.getenv('LABRADDATA'), 'data')
name = None
cxn = None
timeRange = (0, 1e9)
timeDisplayUnits = [(0, 's'), (-3, 'ms'), (-6, 'us')]
timeDigits = 2
def __init__(self, reactor):
super(CameraClient, self).__init__()
self.reactor = reactor
self.connect()
@inlineCallbacks
def connect(self):
if self.cxn is None:
self.cxn = connection()
cname = '{} - {} - client'.format(self.servername, self.name)
yield self.cxn.connect(name=cname)
try:
self.populate()
yield self.connectSignals()
except Exception as e:
print(e)
def populate(self):
self.andorLabel = ClickableLabel('<b>' + 'IXon - 888' + '</b>')
self.tempLabel = ClickableLabel('Temp: ')
self.tempBox = QtWidgets.QDoubleSpinBox()
self.tempBox.setRange(-150, 50)
self.tempBox.setReadOnly(True)
self.tempBox.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
self.tempBox.setDecimals(0)
self.tempBox.setSuffix(' \u00b0 C')
self.tempBox.setFixedWidth(80)
self.emgainLabel = ClickableLabel('EM Gain: ')
self.emgainBox = QtWidgets.QDoubleSpinBox()
self.emgainBox.setRange(0, 300)
self.emgainBox.setReadOnly(True)
self.emgainBox.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
self.emgainBox.setDecimals(0)
self.emgainBox.setFixedWidth(80)
self.exposureLabel = ClickableLabel('Exposure Time: ')
self.exposureBox = SuperSpinBox(self.timeRange, self.timeDisplayUnits,
self.timeDigits)
self.exposureBox.setReadOnly(True)
self.exposureBox.setFixedWidth(80)
self.accumulationLabel = ClickableLabel('Accumulation Time: ')
self.accumulationBox = SuperSpinBox(self.timeRange,
self.timeDisplayUnits,
self.timeDigits)
self.accumulationBox.setReadOnly(True)
self.accumulationBox.setFixedWidth(80)
self.kineticLabel = ClickableLabel('Kinetic Time: ')
self.kineticBox = SuperSpinBox(self.timeRange, self.timeDisplayUnits,
self.timeDigits)
self.kineticBox.setReadOnly(True)
self.kineticBox.setFixedWidth(80)
self.readoutLabel = ClickableLabel('Readout Time: ')
self.readoutBox = SuperSpinBox(self.timeRange, self.timeDisplayUnits,
self.timeDigits)
self.readoutBox.setReadOnly(True)
self.readoutBox.setFixedWidth(80)
self.imageView = pg.ImageView()
self.imageView.setColorMap(MyColorMap)
self.imageView.show()
self.layout = QtWidgets.QGridLayout()
self.layout.setSpacing(5)
self.layout.setContentsMargins(5, 5, 5, 5)
self.layout.addWidget(self.andorLabel, 1, 0, 1, 2,
QtCore.Qt.AlignCenter)
self.layout.addWidget(self.tempLabel, 1, 2, 1, 1, QtCore.Qt.AlignRight)
self.layout.addWidget(self.tempBox, 1, 3, 1, 1)
self.layout.addWidget(self.emgainLabel, 1, 4, 1, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.emgainBox, 1, 5, 1, 1)
self.layout.addWidget(self.exposureLabel, 1, 6, 1, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.exposureBox, 1, 7, 1, 1)
self.layout.addWidget(self.accumulationLabel, 1, 8, 1, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.accumulationBox, 1, 9, 1, 1)
self.layout.addWidget(self.kineticLabel, 1, 10, 1, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.kineticBox, 1, 11, 1, 1)
self.layout.addWidget(self.readoutLabel, 1, 12, 1, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.readoutBox, 1, 13, 1, 1)
self.layout.addWidget(self.imageView, 2, 0, 15, 15)
self.setLayout(self.layout)
# self.setFixedSize(1200, 800)
self.setWindowTitle('{} - {} - client'.format(self.servername,
self.name))
@inlineCallbacks
def connectSignals(self):
self.context = yield self.cxn.context()
server = yield self.cxn.get_server(self.servername)
yield server.signal__update(self.update_id)
yield server.addListener(listener=self.receive_update,
source=None,
ID=self.update_id)
yield self.cxn.add_on_connect(self.servername, self.reinitialize)
yield self.cxn.add_on_disconnect(self.servername, self.disable)
self.imageView.scene.sigMouseClicked.connect(self.handle_click)
self.andorLabel.clicked.connect(self.getAll)
self.tempLabel.clicked.connect(self.getTemperature)
self.emgainLabel.clicked.connect(self.getEMGain)
self.getAll()
@inlineCallbacks
def reinitialize(self):
server = yield self.cxn.get_server(self.servername)
yield server.signal__update(self.update_id, context=self.context)
try:
yield server.removeListener(listener=self.receive_update,
source=None,
ID=self.update_id,
context=self.context)
yield server.addListener(listener=self.receive_update,
source=None,
ID=self.update_id,
context=self.context)
except:
pass
def disable(self):
pass
def getAll(self):
self.getTemperature()
self.getEMGain()
self.getAcquisitionTiming()
self.getReadOutTime()
@inlineCallbacks
def getTemperature(self):
server = yield self.cxn.get_server(self.andor_servername)
temp = yield server.get_temperature(self.andor_serial_number)
self.DisplayTemperature(temp[1])
def DisplayTemperature(self, temp):
self.tempBox.setValue(temp)
@inlineCallbacks
def getEMGain(self):
server = yield self.cxn.get_server(self.andor_servername)
error, emgain = yield server.get_emccd_gain(self.andor_serial_number)
self.DisplayEMGain(emgain)
def DisplayEMGain(self, emgain):
self.emgainBox.setValue(emgain)
@inlineCallbacks
def getAcquisitionTiming(self):
server = yield self.cxn.get_server(self.andor_servername)
error, exposure, accumulation, kinetic = yield server.get_acquisition_timings(
self.andor_serial_number)
self.DisplayExposure(exposure)
self.DisplayAccumulation(accumulation)
self.DisplayKinetic(kinetic)
def DisplayExposure(self, exposure):
self.exposureBox.display(exposure)
def DisplayAccumulation(self, accumulation):
self.accumulationBox.display(accumulation)
def DisplayKinetic(self, kinetic):
self.kineticBox.display(kinetic)
@inlineCallbacks
def getReadOutTime(self):
server = yield self.cxn.get_server(self.andor_servername)
error, readoutTime = yield server.get_read_out_time(
self.andor_serial_number)
self.DisplayReadOutTime(readoutTime)
def DisplayReadOutTime(self, readoutTime):
self.readoutBox.display(readoutTime)
def handle_click(self, mouseClickEvent):
print(mouseClickEvent.double())
if mouseClickEvent.double():
scenePos = mouseClickEvent.scenePos()
print(scenePos)
pos = self.imageView.getView().mapSceneToView(scenePos)
if not hasattr(self, 'crosshairs'):
self.crosshairs = {
'x': pg.InfiniteLine(angle=90, pen='g'),
'y': pg.InfiniteLine(angle=0, pen='g'),
}
self.imageView.addItem(self.crosshairs['x'])
self.imageView.addItem(self.crosshairs['y'])
self.crosshairs['x'].setPos(pos.x())
self.crosshairs['y'].setPos(pos.y())
def receive_update(self, c, signal):
signal = json.loads(signal)
for key, value in signal.items():
if key == self.name:
record_path = value['record_path']
record_type = value['record_type']
record_settings = value['record_settings']
image_path = self.data_directory.format(*record_path)
image_path = os.path.join(self.data_directory,
*record_path.split('/')) + '.hdf5'
self.plot(image_path, record_type, record_settings)
def plot(self, image_path, record_type, record_settings):
image = process_image(image_path, record_type, record_settings)
image = np.rot90(image)
self.imageView.setImage(image, autoRange=False, autoLevels=False)
def closeEvent(self, x):
self.reactor.stop()
class MSQClient(QtWidgets.QWidget):
""" Widget for Msquared server control """
msquared_servername = None
msquared_devicename = None
wlm_servername = None
update_time1 = 2500 # [ms]
update_time2 = 5000 # [ms]
lock_update_time = 2500 # [ms]
is_on_OneShot = False
frequency_units = ['THz', 'GHz']
wavelength_units = ['nm', 'um']
etalon_range = (0, 100) # Etalon tuner
etalon_units = [(0, '%')]
etalon_digits = 2
etalon_max = 196
resonator_range = (0, 100) # Resonator tuner
resonator_units = [(0, '%')]
resonator_digits = 4
resonator_max = 196
fineresonator_range = (0, 100) # Resonator Fine tuner
fineresonator_units = [(0, '%')]
fineresonator_digits = 2
PD_range = (0, 100)
PD_units = [(0, 'V')]
PD_digits = 4
xy_range = (0, 100) # X, Y tuner
xy_units = [(0, '%')]
xy_digits = 2
wl_range = (696, 877) # Rough wavelength
wl_units = [(0, 'nm')]
wl_digits = 1
spinbox_height = 30
spinbox_width = 80
update_id = np.random.randint(0, 2**31 - 1)
def __init__(self, reactor, cxn, msquared_servername, msquared_devicename,
wlm_servername, parent):
super(MSQClient, self).__init__()
try:
self.reactor = reactor
self.cxn = cxn
self.msquared_servername = msquared_servername
self.msquared_devicename = msquared_devicename
self.wlm_servername = wlm_servername
self.parent = parent
self.connect()
except Exception as e:
print(e)
traceback.print_exc()
@inlineCallbacks
def connect(self):
if self.cxn == None:
self.cxn = connection()
yield self.cxn.connect()
self.populate()
yield self.connectWidgets()
def populate(self):
self.nameLabel = ClickableLabel('<b> MSquared Laser Control </b>')
self.statusLabel = ClickableLabel('<b> MSquared Status: </b>')
self.statusText = QtWidgets.QLineEdit()
self.statusText.setReadOnly(True)
self.statusText.setAlignment(QtCore.Qt.AlignCenter)
self.statusText.setFixedHeight(40)
self.statusText.setFont(QtGui.QFont('Arial', 10))
self.wlmLabel = ClickableLabel('<b> HF Wavemeter: </b>')
self.wlmText = QtWidgets.QLineEdit()
self.wlmText.setReadOnly(True)
self.wlmText.setAlignment(QtCore.Qt.AlignCenter)
self.wlmText.setFixedHeight(40)
self.wlmText.setFont(QtGui.QFont('Arial', 10))
self.lockButton = QtWidgets.QPushButton()
self.lockButton.setCheckable(True)
self.lockButton.setFixedHeight(40)
self.lockButton.setFixedWidth(120)
self.oneshotButton = QtWidgets.QPushButton()
self.oneshotButton.setFixedHeight(40)
self.oneshotButton.setFixedWidth(120)
self.oneshotButton.setText('One Shot Alignment')
self.manualButton = QtWidgets.QPushButton()
self.manualButton.setFixedHeight(40)
self.manualButton.setFixedWidth(120)
self.manualButton.setText('Manual Alignment')
self.EtalonTunerLabel = ClickableLabel('Etalon Tuner: ')
self.EtalonTunerBox = SuperSpinBox(self.etalon_range,
self.etalon_units,
self.etalon_digits)
self.EtalonTunerBox.setFixedHeight(self.spinbox_height)
self.EtalonTunerBox.setFixedWidth(self.spinbox_width)
self.ResonatorTunerLabel = ClickableLabel('Resonator Tuner: ')
self.ResonatorTunerBox = SuperSpinBox(self.resonator_range,
self.resonator_units,
self.resonator_digits)
self.ResonatorTunerBox.setFixedHeight(self.spinbox_height)
self.ResonatorTunerBox.setFixedWidth(self.spinbox_width)
self.ResonatorFineTunerLabel = ClickableLabel(
'Resonator Fine \n Tuner:')
self.ResonatorFineTunerLabel.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
self.ResonatorFineTunerBox = SuperSpinBox(self.fineresonator_range,
self.fineresonator_units,
self.fineresonator_digits)
self.ResonatorFineTunerBox.setFixedHeight(self.spinbox_height)
self.ResonatorFineTunerBox.setFixedWidth(self.spinbox_width)
self.XLabel = ClickableLabel('X Tuner: ')
self.XBox = SuperSpinBox(self.xy_range, self.xy_units, self.xy_digits)
self.XBox.setFixedHeight(self.spinbox_height)
self.XBox.setFixedWidth(self.spinbox_width)
self.YLabel = ClickableLabel('Y Tuner: ')
self.YBox = SuperSpinBox(self.xy_range, self.xy_units, self.xy_digits)
self.YBox.setFixedHeight(self.spinbox_height)
self.YBox.setFixedWidth(self.spinbox_width)
self.wavelengthLabel = ClickableLabel(
'Preset wavelength: \n (rough tune)')
self.wavelengthLabel.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
self.wavelengthBox = SuperSpinBox(self.wl_range, self.wl_units,
self.wl_digits)
self.wavelengthBox.setFixedHeight(self.spinbox_height)
self.wavelengthBox.setFixedWidth(self.spinbox_width)
self.EtalonPDLabel = ClickableLabel('Etalon PD DC:')
self.EtalonPDLabel.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
self.EtalonPDBox = SuperSpinBox(self.PD_range, self.PD_units,
self.PD_digits)
self.EtalonPDBox.setFixedHeight(self.spinbox_height)
self.EtalonPDBox.setFixedWidth(self.spinbox_width)
self.EtalonPDBox.setReadOnly(True)
self.OutputPDLabel = ClickableLabel('Output PD:')
self.OutputPDLabel.setAlignment(QtCore.Qt.AlignRight
| QtCore.Qt.AlignVCenter)
self.OutputPDBox = SuperSpinBox(self.PD_range, self.PD_units,
self.PD_digits)
self.OutputPDBox.setFixedHeight(self.spinbox_height)
self.OutputPDBox.setFixedWidth(self.spinbox_width)
self.OutputPDBox.setReadOnly(True)
self.layout = QtWidgets.QGridLayout()
self.layout.addWidget(self.nameLabel, 1, 0, 1, 6,
QtCore.Qt.AlignHCenter)
self.layout.addWidget(self.statusLabel, 2, 0, 2, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.statusText, 2, 1, 2, 5)
self.layout.addWidget(self.wlmLabel, 4, 0, 2, 1, QtCore.Qt.AlignRight)
self.layout.addWidget(self.wlmText, 4, 1, 2, 5)
self.layout.addWidget(self.lockButton, 6, 0, 2, 2,
QtCore.Qt.AlignHCenter)
self.layout.addWidget(self.oneshotButton, 6, 2, 2, 2,
QtCore.Qt.AlignHCenter)
self.layout.addWidget(self.manualButton, 6, 4, 2, 2,
QtCore.Qt.AlignHCenter)
self.layout.addWidget(self.EtalonTunerLabel, 8, 0, 2, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.EtalonTunerBox, 8, 1, 2, 2,
QtCore.Qt.AlignLeft)
self.layout.addWidget(self.XLabel, 8, 3, 2, 1, QtCore.Qt.AlignRight)
self.layout.addWidget(self.XBox, 8, 4, 2, 2, QtCore.Qt.AlignLeft)
self.layout.addWidget(self.ResonatorTunerLabel, 10, 0, 2, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.ResonatorTunerBox, 10, 1, 2, 2,
QtCore.Qt.AlignLeft)
self.layout.addWidget(self.YLabel, 10, 3, 2, 1, QtCore.Qt.AlignRight)
self.layout.addWidget(self.YBox, 10, 4, 2, 2, QtCore.Qt.AlignLeft)
self.layout.addWidget(self.ResonatorFineTunerLabel, 12, 0, 2, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.ResonatorFineTunerBox, 12, 1, 2, 2,
QtCore.Qt.AlignLeft)
self.layout.addWidget(self.wavelengthLabel, 12, 3, 2, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.wavelengthBox, 12, 4, 2, 2,
QtCore.Qt.AlignLeft)
self.layout.addWidget(self.EtalonPDLabel, 14, 0, 2, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.EtalonPDBox, 14, 1, 2, 2,
QtCore.Qt.AlignLeft)
self.layout.addWidget(self.OutputPDLabel, 14, 3, 2, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.OutputPDBox, 14, 4, 2, 2,
QtCore.Qt.AlignLeft)
self.layout.setContentsMargins(5, 5, 5, 5)
self.layout.setSpacing(5)
self.setLayout(self.layout)
self.setFixedSize(450, 450)
@inlineCallbacks
def connectWidgets(self):
self.msquared_server = yield self.cxn.get_server(
self.msquared_servername)
yield self.msquared_server.signal__update(self.update_id)
yield self.msquared_server.addListener(listener=self.receive_update,
source=None,
ID=self.update_id)
self.wlm_server = yield self.cxn.get_server(self.wlm_servername)
self.nameLabel.clicked.connect(self.onNameLabelClick)
self.wlmLabel.clicked.connect(self.getWLM)
self.lockButton.released.connect(self.onLockButton)
self.oneshotButton.released.connect(self.onOneShotButton)
self.manualButton.released.connect(self.onManualButton)
self.XBox.returnPressed.connect(self.onX)
self.YBox.returnPressed.connect(self.onY)
self.wavelengthBox.returnPressed.connect(self.onWavelength)
self.EtalonPDLabel.clicked.connect(self.getEtalonPD)
self.OutputPDLabel.clicked.connect(self.getOutputPD)
self.timer1 = QtCore.QTimer(self)
self.timer1.timeout.connect(self.timer_task1)
self.timer1.start(self.update_time1)
self.timer2 = QtCore.QTimer(self)
self.timer2.timeout.connect(self.timer_task2)
self.timer2.start(self.update_time2)
self.lock_timer = QtCore.QTimer(self)
self.lock_timer.timeout.connect(self.lock_timer_task)
self.getAll()
def receive_update(self, c, signal_json):
signal = json.loads(signal_json)
message = signal.get('alignment_x_auto')
if message is not None:
value = message[self.msquared_devicename]
self.displayX(value)
message = signal.get('alignment_y_auto')
if message is not None:
value = message[self.msquared_devicename]
self.displayY(value)
def disable_when_wlm_lock(self, state):
self.lockButton.setDisabled(state)
self.EtalonTunerBox.setDisabled(state)
self.wavelengthBox.setDisabled(state)
resonator_state = not bool(state ^ self.lockButton.isChecked())
self.ResonatorTunerBox.setDisabled(resonator_state)
self.ResonatorFineTunerBox.setDisabled(resonator_state)
def onNameLabelClick(self):
self.getAll()
def timer_task1(self):
if self.lockButton.isChecked():
self.getLockState()
if self.parent.LockClient.lockButton.isChecked():
self.lock_timer.start(self.lock_update_time)
else:
self.lock_timer.stop()
def timer_task2(self):
if self.is_on_OneShot:
self.getOneShotState()
self.getOutputPD()
self.getEtalonPD()
def lock_timer_task(self):
self.getWLM()
self.getResonatorTuner()
self.getEtalonPD()
self.getOutputPD()
def getAll(self):
self.getLockState()
self.getEtalonTuner()
self.getResonatorTuner()
self.getX()
self.getY()
self.getWavelength()
self.getWLM()
self.getEtalonPD()
self.getOutputPD()
def onLockButton(self):
lock_state = self.lockButton.isChecked()
self.setLockState(lock_state)
@inlineCallbacks
def setLockState(self, lock_state):
if lock_state:
request_json = json.dumps({self.msquared_devicename: True})
else:
request_json = json.dumps({self.msquared_devicename: False})
yield self.msquared_server.etalon_lock(request_json)
self.displayLockState(lock_state)
@inlineCallbacks
def getLockState(self):
request_json = json.dumps({self.msquared_devicename: None})
response_json = yield self.msquared_server.etalon_lock(request_json)
response = json.loads(response_json)
message = response[self.msquared_devicename]
if message == True:
lock_state = True
elif message == False:
lock_state = False
else:
lock_state = False
self.statusText.setText(message)
request_json = json.dumps({self.msquared_devicename: False})
yield self.msquared_server.etalon_lock(request_json)
self.displayLockState(lock_state)
def displayLockState(self, lock_state):
if lock_state == True:
self.lockButton.setChecked(1)
self.lockButton.setText('Remove Etalon Lock')
self.statusText.setText('Etalon lock ON')
self.ResonatorTunerBox.setDisabled(False)
self.ResonatorFineTunerBox.setDisabled(False)
else:
self.lockButton.setChecked(0)
self.lockButton.setText('Apply Etalon Lock')
self.statusText.setText('Etalon lock OFF')
self.ResonatorTunerBox.setDisabled(True)
self.ResonatorFineTunerBox.setDisabled(True)
self.parent.toggle_lock()
@inlineCallbacks
def onOneShotButton(self):
if not self.is_on_OneShot:
self.is_on_OneShot = True
mode = 4 # 4 for One Shot
request_json = json.dumps({self.msquared_devicename: mode})
yield self.msquared_server.beam_alignment(request_json)
self.statusText.setText('One Shot Alignment Started...')
self.oneshotButton.setDisabled(True)
self.manualButton.setEnabled(True)
self.XBox.setDisabled(True)
self.YBox.setDisabled(True)
else:
pass
@inlineCallbacks
def getOneShotState(self):
if self.is_on_OneShot:
request_json = json.dumps({self.msquared_devicename: None})
response_json = yield self.msquared_server.beam_alignment(
request_json)
status = json.loads(response_json).get(self.msquared_devicename)
if status == True:
self.is_on_OneShot = False
self.statusText.setText('One Shot Alignment Completed')
self.oneshotButton.setDisabled(False)
self.XBox.setDisabled(False)
self.YBox.setDisabled(False)
else:
pass
else:
pass
@inlineCallbacks
def onNewEtalonTuner(self):
value = self.EtalonTunerBox.value()
request_json = json.dumps({self.msquared_devicename: value})
yield self.msquared_server.etalon_tune(request_json)
self.displayEtalonTuner(value)
@inlineCallbacks
def getEtalonTuner(self):
request_json = json.dumps({self.msquared_devicename: None})
response_json = yield self.msquared_server.etalon_tune(request_json)
response = json.loads(response_json)
value = response.get(self.msquared_devicename)
value_percentage = value / self.etalon_max * 100
self.displayEtalonTuner(value_percentage)
def displayEtalonTuner(self, value):
self.EtalonTunerBox.display(value)
@inlineCallbacks
def onNewResonatorTuner(self):
value = self.ResonatorTunerBox.value()
request_json = json.dumps({self.msquared_devicename: value})
yield self.msquared_server.resonator_tune(request_json)
self.displayResonatorTuner(value)
@inlineCallbacks
def getResonatorTuner(self):
request_json = json.dumps({self.msquared_devicename: None})
response_json = yield self.msquared_server.resonator_tune(request_json)
response = json.loads(response_json)
value = response.get(self.msquared_devicename)
value_percentage = value / self.resonator_max * 100
self.displayResonatorTuner(value_percentage)
def displayResonatorTuner(self, value):
self.ResonatorTunerBox.display(value)
@inlineCallbacks
def onManualButton(self):
self.is_on_OneShot = False
self.oneshotButton.setDisabled(False)
self.XBox.setDisabled(False)
self.YBox.setDisabled(False)
mode = 1 # 1 for Manual
request_json = json.dumps({self.msquared_devicename: mode})
yield self.msquared_server.beam_alignment(request_json)
@inlineCallbacks
def onX(self):
value = self.XBox.value()
request_json = json.dumps({self.msquared_devicename: value})
yield self.msquared_server.alignment_x(request_json)
self.displayX(value)
@inlineCallbacks
def getX(self):
request_json = json.dumps({self.msquared_devicename: None})
response_json = yield self.msquared_server.alignment_x(request_json)
response = json.loads(response_json)
value = response.get(self.msquared_devicename)
self.displayX(value)
def displayX(self, value):
self.XBox.display(value)
@inlineCallbacks
def onY(self):
value = self.YBox.value()
request_json = json.dumps({self.msquared_devicename: value})
yield self.msquared_server.alignment_y(request_json)
self.displayY(value)
@inlineCallbacks
def getY(self):
request_json = json.dumps({self.msquared_devicename: None})
response_json = yield self.msquared_server.alignment_y(request_json)
response = json.loads(response_json)
value = response.get(self.msquared_devicename)
self.displayY(value)
def displayY(self, value):
self.YBox.display(value)
@inlineCallbacks
def onWavelength(self):
value = self.wavelengthBox.value()
request_json = json.dumps({self.msquared_devicename: value})
yield self.msquared_server.wavelength(request_json)
self.displayWavelength(value)
@inlineCallbacks
def getWavelength(self):
request_json = json.dumps({self.msquared_devicename: None})
response_json = yield self.msquared_server.wavelength(request_json)
response = json.loads(response_json)
value = response.get(self.msquared_devicename)
self.displayWavelength(value)
def displayWavelength(self, value):
self.wavelengthBox.display(value)
@inlineCallbacks
def getWLM(self):
units = self.parent.PIDClient.unitsBox.currentText()
channel = self.parent.PIDClient.channelBox.currentText()
if units in self.frequency_units:
value = yield self.wlm_server.get_frequency(int(channel))
elif units in self.wavelength_units:
value = yield self.wlm_server.get_wavelength(int(channel))
self.displayWLM(value, units)
def displayWLM(self, value, units):
self.wlmText.setText('{} {}'.format(value, units))
@inlineCallbacks
def getEtalonPD(self):
request_json = json.dumps({self.msquared_devicename: None})
response_json = yield self.msquared_server.etalon_pd(request_json)
response = json.loads(response_json)
value = response.get(self.msquared_devicename)
self.displayEtalonPD(value)
def displayEtalonPD(self, value):
self.EtalonPDBox.display(value)
@inlineCallbacks
def getOutputPD(self):
request_json = json.dumps({self.msquared_devicename: None})
response_json = yield self.msquared_server.output_pd(request_json)
response = json.loads(response_json)
value = response.get(self.msquared_devicename)
self.displayOutputPD(value)
def displayOutputPD(self, value):
self.OutputPDBox.display(value)
def closeEvent(self, x):
pass
class DIM3000_RFClient(QtWidgets.QGroupBox):
name = None
DeviceProxy = None
updateID = np.random.randint(0, 2**31 - 1)
amplitudeDisplayUnits = [(0, 'dBm')]
amplitudeDigits = None
frequencyDisplayUnits = [(-6, 'uHz'), (-3, 'mHz'), (0, 'Hz'), (3, 'kHz'),
(6, 'MHz'), (9, 'GHz')]
frequencyDigits = None
fmfreqDisplayUnits = [(-6, 'uHz/V'), (-3, 'mHz/V'), (0, 'Hz/V'),
(3, 'kHz/V'), (6, 'MHz/V'), (9, 'GHz/V')]
fmfreqDigits = None
spinboxWidth = 80
def __init__(self, reactor, cxn=None):
QtWidgets.QDialog.__init__(self)
self.reactor = reactor
reactor.callInThread(self.initialize)
self.connectLabrad()
def initialize(self):
import labrad
cxn = labrad.connect(name=self.name,
host=os.getenv('LABRADHOST'),
password='')
self.device = self.DeviceProxy(cxn)
self.reactor.callFromThread(self.populateGUI)
self.fm_dev = self.device.fm_dev
def populateGUI(self):
self.nameLabel = ClickableLabel('<b>' + self.name + '</b>')
self.stateButton = QtWidgets.QPushButton()
self.stateButton.setCheckable(True)
self.frequencyLabel = ClickableLabel('Frequency: ')
self.frequencyBox = SuperSpinBox(self.device._frequency_range,
self.frequencyDisplayUnits,
self.frequencyDigits)
self.frequencyBox.setFixedWidth(self.spinboxWidth)
self.amplitudeLabel = ClickableLabel('Amplitude: ')
self.amplitudeBox = SuperSpinBox(self.device._amplitude_range,
self.amplitudeDisplayUnits,
self.amplitudeDigits)
self.amplitudeBox.setFixedWidth(self.spinboxWidth)
self.fmstateButton = QtWidgets.QPushButton()
self.fmfreqBox = SuperSpinBox(self.device._fmfreq_range,
self.fmfreqDisplayUnits,
self.fmfreqDigits)
self.fmfreqBox.setFixedWidth(self.spinboxWidth)
self.fmfreqBox.setReadOnly(True)
self.fmstateButton.setCheckable(True)
self.fmdevLabel = ClickableLabel('FM Dev: ')
self.fmdevBox = QtWidgets.QDoubleSpinBox()
self.fmdevBox.setKeyboardTracking(False)
self.fmdevBox.setRange(*self.device._fmdev_range)
# self.fmdevBox.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
self.fmdevBox.setDecimals(0)
self.layout = QtWidgets.QGridLayout()
self.layout.addWidget(self.nameLabel, 0, 0, 1, 1, QtCore.Qt.AlignRight)
self.layout.addWidget(self.stateButton, 0, 1)
self.layout.addWidget(self.frequencyLabel, 1, 0, 1, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.frequencyBox, 1, 1)
self.layout.addWidget(self.amplitudeLabel, 2, 0, 1, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.amplitudeBox, 2, 1)
self.layout.addWidget(self.fmstateButton, 3, 0, 1, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.fmfreqBox, 3, 1)
self.layout.addWidget(self.fmdevLabel, 4, 0, 1, 1,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.fmdevBox, 4, 1)
self.setLayout(self.layout)
self.setWindowTitle(self.name)
self.setFixedSize(120 + self.spinboxWidth, 180)
self.connectSignals()
self.reactor.callInThread(self.getAll)
def getAll(self):
self.getRFState()
self.getFMState()
self.getFrequency()
self.getAmplitude()
self.getFMdev()
self.getFMfreq()
def getFMdev(self):
fm_dev = self.fm_dev
self.reactor.callFromThread(self.displayFMdev, fm_dev)
def displayFMdev(self, fm_dev):
self.fmdevBox.setValue(fm_dev)
def getFMfreq(self):
fm_freq = 3200 * 2**int(self.fm_dev)
self.reactor.callFromThread(self.displayFMfreq, fm_freq)
def displayFMfreq(self, fm_freq):
self.fmfreqBox.display(fm_freq)
def getRFState(self):
rf_state = self.device.state
self.reactor.callFromThread(self.displayRFState, rf_state)
def displayRFState(self, rf_state):
if rf_state:
self.stateButton.setChecked(1)
self.stateButton.setText('RF ON')
else:
self.stateButton.setChecked(0)
self.stateButton.setText('RF OFF')
def getFMState(self):
fm_state = self.device.fm
self.reactor.callFromThread(self.displayFMState, fm_state)
def displayFMState(self, fm_state):
if fm_state:
self.fmstateButton.setChecked(1)
self.fmstateButton.setText('FM ON')
else:
self.fmstateButton.setChecked(0)
self.fmstateButton.setText('FM OFF')
def getFrequency(self):
frequency = self.device.frequency
self.reactor.callFromThread(self.displayFrequency, frequency)
def displayFrequency(self, frequency):
self.frequencyBox.display(frequency)
def getAmplitude(self):
amplitude = self.device.amplitude
self.reactor.callFromThread(self.displayAmplitude, amplitude)
def displayAmplitude(self, amplitude):
self.amplitudeBox.display(amplitude)
def connectSignals(self):
self.nameLabel.clicked.connect(self.onNameLabelClick)
self.frequencyLabel.clicked.connect(self.onFrequencyLabelClick)
self.amplitudeLabel.clicked.connect(self.onAmplitudeLabelClick)
self.stateButton.released.connect(self.onNewRFState)
self.fmstateButton.released.connect(self.onNewFMState)
self.frequencyBox.returnPressed.connect(self.onNewFrequency)
self.amplitudeBox.returnPressed.connect(self.onNewAmplitude)
self.fmdevBox.valueChanged.connect(self.onNewFMDev)
def onNameLabelClick(self):
self.reactor.callInThread(self.getAll)
def onFrequencyLabelClick(self):
self.reactor.callInThread(self.getFrequency)
def onAmplitudeLabelClick(self):
self.reactor.callInThread(self.getAmplitude)
def onNewRFState(self):
rf_state = self.stateButton.isChecked()
self.reactor.callInThread(self.setRFState, rf_state)
def setRFState(self, rf_state):
self.device.state = rf_state
self.reactor.callFromThread(self.displayRFState, rf_state)
def onNewFMState(self):
fm_state = self.fmstateButton.isChecked()
self.reactor.callInThread(self.setFMState, fm_state)
def setFMState(self, fm_state):
self.device.fm = fm_state
self.reactor.callFromThread(self.displayFMState, fm_state)
def onNewFMDev(self):
self.fm_dev = self.fmdevBox.value()
fm_dev = self.fm_dev
self.reactor.callInThread(self.setFMDev, fm_dev)
def setFMDev(self, fm_dev):
self.device.set_fm_dev(fm_dev)
self.getFMdev()
self.getFMfreq()
def onNewFrequency(self):
frequency = self.frequencyBox.value()
self.reactor.callInThread(self.setFrequency, frequency)
def setFrequency(self, frequency):
self.device.frequency = frequency
self.reactor.callFromThread(self.displayFrequency, frequency)
def onNewAmplitude(self):
amplitude = self.amplitudeBox.value()
self.reactor.callInThread(self.setAmplitude, amplitude)
def setAmplitude(self, amplitude):
self.device.amplitude = amplitude
self.reactor.callFromThread(self.displayAmplitude, amplitude)
@inlineCallbacks
def connectLabrad(self):
from labrad.wrappers import connectAsync
self.cxn = yield connectAsync(name=self.name,
host=os.getenv('LABRADHOST'),
password='')
yield self.cxn.update.signal__signal(self.updateID)
yield self.cxn.update.addListener(listener=self.receiveUpdate,
source=None,
ID=self.updateID)
yield self.cxn.update.register(self.name)
def receiveUpdate(self, c, updateJson):
update = json.loads(updateJson)
state = update.get('state')
if state is not None:
self.displayState(state)
frequency = update.get('frequency')
if frequency is not None:
self.displayFrequency(frequency)
amplitude = update.get('amplitude')
if amplitude is not None:
self.displayAmplitude(amplitude)
def closeEvent(self, x):
self.reactor.stop()