aboutsummaryrefslogtreecommitdiff
path: root/examples/lock_eit.py
diff options
context:
space:
mode:
Diffstat (limited to 'examples/lock_eit.py')
-rw-r--r--examples/lock_eit.py446
1 files changed, 247 insertions, 199 deletions
diff --git a/examples/lock_eit.py b/examples/lock_eit.py
index f226935..40612e6 100644
--- a/examples/lock_eit.py
+++ b/examples/lock_eit.py
@@ -15,62 +15,66 @@ from qolab.data import TraceSetSameX, TraceXY, Trace
from qolab.hardware.i_server import I800
# this should be done before justpy is called or log formatter does not work
-logging.basicConfig(format='%(asctime)s %(levelname)8s %(name)s: %(message)s', datefmt='%m/%d/%Y %H:%M:%S')
+logging.basicConfig(
+ format="%(asctime)s %(levelname)8s %(name)s: %(message)s",
+ datefmt="%m/%d/%Y %H:%M:%S",
+)
-l = logging.getLogger('qolab.gui.web')
+l = logging.getLogger("qolab.gui.web")
l.setLevel(logging.INFO)
-l = logging.getLogger('qolab.tsdb')
+l = logging.getLogger("qolab.tsdb")
l.setLevel(logging.INFO)
-logger = logging.getLogger('Magnetometer')
+logger = logging.getLogger("Magnetometer")
logger.setLevel(logging.INFO)
+
def getConfig(apparatus):
config = apparatus.config.copy()
ai = apparatus.instruments
for n, i in ai.items():
- config[n]=i.getConfig()
+ config[n] = i.getConfig()
return config
+
def initLog(extra_tags={}):
errorTrace = Trace("error")
- errorTrace.config['unit']='V'
+ errorTrace.config["unit"] = "V"
timeTrace = Trace("time")
- timeTrace.config['unit']='S'
- timeTrace.config['type'] = 'timestamp'
+ timeTrace.config["unit"] = "S"
+ timeTrace.config["type"] = "timestamp"
errorLog = TraceXY("error")
errorLog.x = timeTrace
errorLog.y = errorTrace
freqTrace = Trace("frequency")
- freqTrace.config['unit']='Hz'
+ freqTrace.config["unit"] = "Hz"
freqLog = TraceXY("frequency")
freqLog.x = timeTrace
freqLog.y = freqTrace
feedbackTrace = Trace("feedback")
- feedbackTrace.config['unit']='Hz'
+ feedbackTrace.config["unit"] = "Hz"
feedbackLog = TraceXY("feedback")
feedbackLog.x = timeTrace
feedbackLog.y = feedbackTrace
eitTrace = Trace("eit")
- eitTrace.config['unit']='V'
+ eitTrace.config["unit"] = "V"
eitLog = TraceXY("eit")
eitLog.x = timeTrace
eitLog.y = eitTrace
rfPoutTrace = Trace("rfPout")
- rfPoutTrace.config['unit']='dBm'
+ rfPoutTrace.config["unit"] = "dBm"
rfPoutLog = TraceXY("rfPout")
rfPoutLog.x = timeTrace
rfPoutLog.y = rfPoutTrace
-
cellTemperatureLog = TraceXY("cellTemperature")
cellTemperatureLog.x = timeTrace
cellTemperatureLog.y = Trace("cellTemperature")
- cellTemperatureLog.y.config['unit'] = 'C'
+ cellTemperatureLog.y.config["unit"] = "C"
log = TraceSetSameX("timelog")
log.addTrace(errorLog)
@@ -79,24 +83,26 @@ def initLog(extra_tags={}):
log.addTrace(eitLog)
log.addTrace(rfPoutLog)
log.addTrace(cellTemperatureLog)
- log.config['tags']['apparatus']=getConfig(apparatus)
- log.config['tags'].update(extra_tags)
+ log.config["tags"]["apparatus"] = getConfig(apparatus)
+ log.config["tags"].update(extra_tags)
return log
+
async def feedbackLoop(apparatus, nsteps):
# while True:
- for i in range(0,nsteps):
+ for i in range(0, nsteps):
adjustRFandLog(apparatus)
await asyncio.sleep(0.1)
apparatus.runStatus = False
+
def adjustRFandLog(apparatus):
timenow = time.time()
ai = apparatus.instruments
- pid = ai['pid']
- scope_fdbk = ai['scope.feedback']
- log = apparatus.gui_log.traces
+ pid = ai["pid"]
+ scope_fdbk = ai["scope.feedback"]
+ log = apparatus.gui_log.traces
err, eit = apparatus.getErrAndEit()
fdbck = pid.feedback(err)
@@ -106,9 +112,10 @@ def adjustRFandLog(apparatus):
rfPout = apparatus.getRFAmplitude()
- apparatus.getBCurrent(); # this automatically logs value to TSDB
+ apparatus.getBCurrent()
+ # this automatically logs value to TSDB
- tCell = ai['cellTemperatureController'].getTemperature()
+ tCell = ai["cellTemperatureController"].getTemperature()
log.addPointToTrace(timenow)
log.addPointToTrace(err, "error")
@@ -118,194 +125,186 @@ def adjustRFandLog(apparatus):
log.addPointToTrace(eit, "eit")
log.addPointToTrace(tCell, "cellTemperature")
+
async def initial_lock_to_eit(apparatus, extra_tags={}):
rfPout = apparatus.getRFAmplitude()
- apparatus.state = f'Initial lock RF power {rfPout} dBm'
+ apparatus.state = f"Initial lock RF power {rfPout} dBm"
logger.info(apparatus.state)
update_webpage(apparatus=apparatus)
ai = apparatus.instruments
- apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
- ai['pid'].reset()
- ai['pid'].setEnable(True)
+ apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
+ ai["pid"].reset()
+ ai["pid"].setEnable(True)
apparatus.runStatus = True
- res = await asyncio.gather(
- feedbackLoop(apparatus, nsteps=50)
- )
+ res = await asyncio.gather(feedbackLoop(apparatus, nsteps=50))
+
async def calibratingLockin(apparatus, extra_tags={}):
ai = apparatus.instruments
rfPout = apparatus.getRFAmplitude()
- apparatus.state = f'Calibrating lockin response at RF power {rfPout} dBm'
+ apparatus.state = f"Calibrating lockin response at RF power {rfPout} dBm"
logger.info(apparatus.state)
update_webpage(apparatus=apparatus)
- ai['pid'].setEnable(False)
- ai['pid'].reset()
- apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
- res = await asyncio.gather(
- feedbackLoop(apparatus, nsteps=20)
- )
-
- fr0 = ai['rfgen'].getFreqFixed()
+ ai["pid"].setEnable(False)
+ ai["pid"].reset()
+ apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
+ res = await asyncio.gather(feedbackLoop(apparatus, nsteps=20))
+
+ fr0 = ai["rfgen"].getFreqFixed()
df = 10
- ai['pid'].setEnable(False)
- ai['pid'].reset()
- apparatus.setRFreq(fr0+df)
- res = await asyncio.gather(
- feedbackLoop(apparatus, nsteps=20)
- )
+ ai["pid"].setEnable(False)
+ ai["pid"].reset()
+ apparatus.setRFreq(fr0 + df)
+ res = await asyncio.gather(feedbackLoop(apparatus, nsteps=20))
apparatus.setRFreq(fr0)
- log = apparatus.gui_log.traces
- trE=log.getTrace('error')
+ log = apparatus.gui_log.traces
+ trE = log.getTrace("error")
e1 = np.mean(trE.y.values[0:20])
e2 = np.mean(trE.y.values[20:])
- dE = e2-e1
- slope = dE/df
+ dE = e2 - e1
+ slope = dE / df
apparatus.setLockinSlope(slope)
- logger.info(f'dE = {dE}')
- logger.info(f'lockin error signal slope = {slope} V/Hz')
- ai['error_signal_response_to_eit_detuning'].conversion_factor = float(slope)
+ logger.info(f"dE = {dE}")
+ logger.info(f"lockin error signal slope = {slope} V/Hz")
+ ai["error_signal_response_to_eit_detuning"].conversion_factor = float(slope)
return float(slope)
+
async def responseToChangeOfBfieldControlVoltage(apparatus, extra_tags={}):
ai = apparatus.instruments
rfPout = apparatus.getRFAmplitude()
- apparatus.state = f'Calibrating lockin response to change of Bfield control voltage, {rfPout} dBm'
+ apparatus.state = (
+ f"Calibrating lockin response to change of Bfield control voltage, {rfPout} dBm"
+ )
logger.info(apparatus.state)
update_webpage(apparatus=apparatus)
- ai['pid'].setEnable(True)
- ai['pid'].reset()
- apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
+ ai["pid"].setEnable(True)
+ ai["pid"].reset()
+ apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
dV = 0.01
- ai['lockin'].AuxOut1=dV
+ ai["lockin"].AuxOut1 = dV
# initial lock
- ai['pid'].setEnable(True)
- ai['pid'].reset()
- res = await asyncio.gather(
- feedbackLoop(apparatus, nsteps=20)
- )
+ ai["pid"].setEnable(True)
+ ai["pid"].reset()
+ res = await asyncio.gather(feedbackLoop(apparatus, nsteps=20))
# this is for the money lock
- res = await asyncio.gather(
- feedbackLoop(apparatus, nsteps=30)
- )
+ res = await asyncio.gather(feedbackLoop(apparatus, nsteps=30))
- fr0 = ai['rfgen'].getFreqFixed()
+ fr0 = ai["rfgen"].getFreqFixed()
# this is for the money lock
- ai['lockin'].AuxOut1=0
- ai['pid'].setEnable(True)
- ai['pid'].reset()
- res = await asyncio.gather(
- feedbackLoop(apparatus, nsteps=30)
- )
- fr1 = ai['rfgen'].getFreqFixed()
+ ai["lockin"].AuxOut1 = 0
+ ai["pid"].setEnable(True)
+ ai["pid"].reset()
+ res = await asyncio.gather(feedbackLoop(apparatus, nsteps=30))
+ fr1 = ai["rfgen"].getFreqFixed()
- log = apparatus.gui_log.traces
- trE=log.getTrace('error')
+ log = apparatus.gui_log.traces
+ trE = log.getTrace("error")
df = fr0 - fr1
- slope = df/dV
+ slope = df / dV
- logger.info(f'df = {df}')
- logger.info(f'response to magnetic control voltage = {slope} Hz/V')
- ai['B_control_voltage_to_eit_detuning'].conversion_factor = float(slope)
+ logger.info(f"df = {df}")
+ logger.info(f"response to magnetic control voltage = {slope} Hz/V")
+ ai["B_control_voltage_to_eit_detuning"].conversion_factor = float(slope)
# relock to default state
- ai['lockin'].AuxOut1=0
- ai['pid'].setEnable(True)
- ai['pid'].reset()
- res = await asyncio.gather(
- feedbackLoop(apparatus, nsteps=20)
- )
+ ai["lockin"].AuxOut1 = 0
+ ai["pid"].setEnable(True)
+ ai["pid"].reset()
+ res = await asyncio.gather(feedbackLoop(apparatus, nsteps=20))
return float(slope)
+
async def record_magnetometer_noise(apparatus):
ai = apparatus.instruments
rfPout = apparatus.getRFAmplitude()
- ai['pid'].setEnable(False)
+ ai["pid"].setEnable(False)
- apparatus.state = f'Record magnetometer noise, RF power {rfPout} dBm'
+ apparatus.state = f"Record magnetometer noise, RF power {rfPout} dBm"
logger.info(apparatus.state)
- scope = ai['scope.monitor']
+ scope = ai["scope.monitor"]
old_config = scope.getConfig()
- tperdiv=1
+ tperdiv = 1
scope.setTimePerDiv(tperdiv)
scope.setRoll(True)
- await asyncio.sleep(tperdiv*14 + 1)
- errorTr=scope.getTrace(1, maxRequiredPoints=10000)
- errorTr.config['label'] = 'error vs time'
- errorTr.y.config['label'] = 'error'
+ await asyncio.sleep(tperdiv * 14 + 1)
+ errorTr = scope.getTrace(1, maxRequiredPoints=10000)
+ errorTr.config["label"] = "error vs time"
+ errorTr.y.config["label"] = "error"
log = errorTr
- log.config['tags']['apparatus']=getConfig(apparatus)
- magNoise = BasicInstrument(device_nickname='.'.join(['magnetometer', 'noise']))
- magNoise.config['FnamePrefix'] = 'magnetometer_noise'
- magNoise.config['SavePath']=apparatus.config['SavePath']
+ log.config["tags"]["apparatus"] = getConfig(apparatus)
+ magNoise = BasicInstrument(device_nickname=".".join(["magnetometer", "noise"]))
+ magNoise.config["FnamePrefix"] = "magnetometer_noise"
+ magNoise.config["SavePath"] = apparatus.config["SavePath"]
fname = magNoise.getNextDataFile()
log.save(fname)
- logger.info(f'Magnetometer noise file: {fname}')
+ logger.info(f"Magnetometer noise file: {fname}")
- apparatus.gui_log.setTraces( log )
+ apparatus.gui_log.setTraces(log)
update_webpage(apparatus=apparatus)
- logger.info('Restoring scope settings')
+ logger.info("Restoring scope settings")
scope.setConfig(old_config)
+
async def longTermLock(apparatus, extra_tags={}):
ai = apparatus.instruments
rfPout = apparatus.getRFAmplitude()
- apparatus.state = f'Long term lock RF power {rfPout} dBm'
+ apparatus.state = f"Long term lock RF power {rfPout} dBm"
logger.info(apparatus.state)
ai = apparatus.instruments
rfPout = apparatus.getRFAmplitude()
apparatus.runStatus = True
- ai['pid'].setEnable(True)
+ ai["pid"].setEnable(True)
- apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
+ apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
update_webpage(apparatus=apparatus)
- res = await asyncio.gather(
- feedbackLoop(apparatus, nsteps=10000000)
- )
+ res = await asyncio.gather(feedbackLoop(apparatus, nsteps=10000000))
return res
+
async def sweepRFPower(apparatus, extra_tags={}, rfPowerList=[]):
- apparatus.gui_log.setTraces( initLog(extra_tags=extra_tags) )
+ apparatus.gui_log.setTraces(initLog(extra_tags=extra_tags))
ai = apparatus.instruments
# for p in np.linspace(-10,10, 110):
- ai['pid'].setEnable(True)
+ ai["pid"].setEnable(True)
for p in rfPowerList:
- ai['rfgen'].setRFAmplitude(p)
- rfPout = ai['rfgen'].getRFAmplitude()
- apparatus.state = f'lock with RF power {rfPout} dBm'
+ ai["rfgen"].setRFAmplitude(p)
+ rfPout = ai["rfgen"].getRFAmplitude()
+ apparatus.state = f"lock with RF power {rfPout} dBm"
logger.info(apparatus.state)
update_webpage(apparatus=apparatus)
- ai['pid'].reset()
+ ai["pid"].reset()
apparatus.runStatus = True
- res = await asyncio.gather(
- feedbackLoop(apparatus, nsteps=50)
- )
+ res = await asyncio.gather(feedbackLoop(apparatus, nsteps=50))
return res
freqZero = 6_834_686_400
-#freqDeltaMp2 = 6_835_385_570; # T=83.7C
-freqDeltaMp2 = 6_835_393_258; # T=60C
+# freqDeltaMp2 = 6_835_385_570; # T=83.7C
+freqDeltaMp2 = 6_835_393_258
+# T=60C
# freqDeltaMp2 = 6_835_396_000; # T=44.6C
dfB = freqDeltaMp2 - freqZero
-freqDeltaMm2 = freqZero - dfB;
+freqDeltaMm2 = freqZero - dfB
+
async def main():
- app_nickname=apparatus.config['DeviceNickname']
+ app_nickname = apparatus.config["DeviceNickname"]
task_wp_update_loop = asyncio.create_task(update_webpage_loop(update_interval=1))
@@ -314,14 +313,30 @@ async def main():
logger.info("Accessing hardware")
rm = pyvisa.ResourceManager()
- instr_scope=rm.open_resource('TCPIP::192.168.0.61::INSTR')
- scope_fdbk = SDS1104X(instr_scope, device_nickname='.'.join([app_nickname, 'scope.feedback']), tsdb_ingester=tsdb_ingester)
- instr_scope=rm.open_resource('TCPIP::192.168.0.62::INSTR')
- scope_mon = SDS1104X(instr_scope, device_nickname='.'.join([app_nickname, 'scope.monitor']), tsdb_ingester=tsdb_ingester)
- instr_rfgen=rm.open_resource('TCPIP::192.168.0.114::INSTR')
- rfgen = AgilentE8257D(instr_rfgen, device_nickname='.'.join([app_nickname, 'rfgen']), tsdb_ingester=tsdb_ingester)
- instr_lockin=rm.open_resource('TCPIP::192.168.0.51::INSTR')
- lockin = SRS_SR865A(instr_lockin, device_nickname='.'.join([app_nickname, 'lockin']), tsdb_ingester=tsdb_ingester)
+ instr_scope = rm.open_resource("TCPIP::192.168.0.61::INSTR")
+ scope_fdbk = SDS1104X(
+ instr_scope,
+ device_nickname=".".join([app_nickname, "scope.feedback"]),
+ tsdb_ingester=tsdb_ingester,
+ )
+ instr_scope = rm.open_resource("TCPIP::192.168.0.62::INSTR")
+ scope_mon = SDS1104X(
+ instr_scope,
+ device_nickname=".".join([app_nickname, "scope.monitor"]),
+ tsdb_ingester=tsdb_ingester,
+ )
+ instr_rfgen = rm.open_resource("TCPIP::192.168.0.114::INSTR")
+ rfgen = AgilentE8257D(
+ instr_rfgen,
+ device_nickname=".".join([app_nickname, "rfgen"]),
+ tsdb_ingester=tsdb_ingester,
+ )
+ instr_lockin = rm.open_resource("TCPIP::192.168.0.51::INSTR")
+ lockin = SRS_SR865A(
+ instr_lockin,
+ device_nickname=".".join([app_nickname, "lockin"]),
+ tsdb_ingester=tsdb_ingester,
+ )
# print('------ Header start -------------')
# print(str.join('\n', scope.getHeader()))
# print(str.join('\n', rfgen.getHeader()))
@@ -330,21 +345,31 @@ async def main():
# traces = scope.getAllTraces()
# pid = PID(100,400,0, sign=-1); # good for dm=-2 resonance
# pid = PID(50,200,0, sign=-1, device_nickname='.'.join([app_nickname, 'pid']), tsdb_ingester=tsdb_ingester)
- pid = PID(5,20,0, sign=-1, device_nickname='.'.join([app_nickname, 'pid']), tsdb_ingester=tsdb_ingester)
-
- apparatus.instruments={}
+ pid = PID(
+ 5,
+ 20,
+ 0,
+ sign=-1,
+ device_nickname=".".join([app_nickname, "pid"]),
+ tsdb_ingester=tsdb_ingester,
+ )
+
+ apparatus.instruments = {}
ai = apparatus.instruments
- ai['rfgen'] = rfgen
- ai['lockin'] = lockin
- ai['pid'] = pid
- ai['cellTemperatureController'] = I800(device_nickname='.'.join([app_nickname, 'cellTemperatureController']), tsdb_ingester=tsdb_ingester)
- ai['scope.feedback'] = scope_fdbk
+ ai["rfgen"] = rfgen
+ ai["lockin"] = lockin
+ ai["pid"] = pid
+ ai["cellTemperatureController"] = I800(
+ device_nickname=".".join([app_nickname, "cellTemperatureController"]),
+ tsdb_ingester=tsdb_ingester,
+ )
+ ai["scope.feedback"] = scope_fdbk
scope_fdbk.setRoll(False)
scope_fdbk.setRun(True)
scope_fdbk.setTimePerDiv(0.0005)
scope_fdbk.setChanVoltsPerDiv(1, 0.2)
scope_fdbk.setChanVoltsPerDiv(3, 0.02)
- ai['scope.monitor'] = scope_mon
+ ai["scope.monitor"] = scope_mon
scope_mon.setRoll(False)
scope_mon.setRun(True)
scope_mon.setTimePerDiv(0.0005)
@@ -354,44 +379,59 @@ async def main():
apparatus.state = None
apparatus.runStatus = False
- error_signal_response_to_eit_detuning = BasicInstrument(device_nickname='.'.join([app_nickname, 'error_signal_response_to_eit_detuning']), tsdb_ingester=tsdb_ingester)
- error_signal_response_to_eit_detuning.deviceProperties.update({'conversion_factor', 'unit'})
+ error_signal_response_to_eit_detuning = BasicInstrument(
+ device_nickname=".".join(
+ [app_nickname, "error_signal_response_to_eit_detuning"]
+ ),
+ tsdb_ingester=tsdb_ingester,
+ )
+ error_signal_response_to_eit_detuning.deviceProperties.update(
+ {"conversion_factor", "unit"}
+ )
error_signal_response_to_eit_detuning.conversion_factor = None
- error_signal_response_to_eit_detuning.unit = 'V_per_Hz'
- ai['error_signal_response_to_eit_detuning']=error_signal_response_to_eit_detuning
-
- B_control_voltage_to_eit_detuning = BasicInstrument(device_nickname='.'.join([app_nickname, 'B_control_voltage_to_eit_detuning']), tsdb_ingester=tsdb_ingester)
- B_control_voltage_to_eit_detuning.deviceProperties.update({'conversion_factor', 'unit'})
+ error_signal_response_to_eit_detuning.unit = "V_per_Hz"
+ ai["error_signal_response_to_eit_detuning"] = error_signal_response_to_eit_detuning
+
+ B_control_voltage_to_eit_detuning = BasicInstrument(
+ device_nickname=".".join([app_nickname, "B_control_voltage_to_eit_detuning"]),
+ tsdb_ingester=tsdb_ingester,
+ )
+ B_control_voltage_to_eit_detuning.deviceProperties.update(
+ {"conversion_factor", "unit"}
+ )
B_control_voltage_to_eit_detuning.conversion_factor = None
- B_control_voltage_to_eit_detuning.unit = 'Hz_per_V'
- ai['B_control_voltage_to_eit_detuning'] = B_control_voltage_to_eit_detuning
-
+ B_control_voltage_to_eit_detuning.unit = "Hz_per_V"
+ ai["B_control_voltage_to_eit_detuning"] = B_control_voltage_to_eit_detuning
SweepSpan = 10000
- ai['rfgen'].stopFrequencySweep()
+ ai["rfgen"].stopFrequencySweep()
# ai['rfgen'].setFreqFixed(freqDeltaMm2)
# ai['rfgen'].setFreqFixed(freqZero)
apparatus.setRFreq(freqDeltaMp2)
# apparatus.setRFreq(freqZero)
- rfPstart = -10
+ rfPstart = -10
rfPstop = 10
rfPowerList = np.linspace(rfPstart, rfPstop, 11)
rfPower0 = rfPstart
- rfPower0 = 9
+ rfPower0 = 9
apparatus.setRFAmplitude(rfPower0)
- d=getConfig(apparatus)
- instruments_config=gui.QOLDictionary(a=wp, name='Instruments configs', container=d)
- extra_tags={}
+ d = getConfig(apparatus)
+ instruments_config = gui.QOLDictionary(
+ a=wp, name="Instruments configs", container=d
+ )
+ extra_tags = {}
await initial_lock_to_eit(apparatus, extra_tags=extra_tags)
- lockin_slope= await calibratingLockin(apparatus, extra_tags=extra_tags)
+ lockin_slope = await calibratingLockin(apparatus, extra_tags=extra_tags)
instruments_config.container = getConfig(apparatus)
instruments_config.display_container_dictionary()
- B_response= await responseToChangeOfBfieldControlVoltage(apparatus, extra_tags=extra_tags)
+ B_response = await responseToChangeOfBfieldControlVoltage(
+ apparatus, extra_tags=extra_tags
+ )
instruments_config.container = getConfig(apparatus)
instruments_config.display_container_dictionary()
@@ -399,10 +439,9 @@ async def main():
await record_magnetometer_noise(apparatus)
-
await longTermLock(apparatus, extra_tags=extra_tags)
- apparatus.state = 'Done working with hardware'
+ apparatus.state = "Done working with hardware"
logger.info(apparatus.state)
update_webpage(apparatus=apparatus)
@@ -410,26 +449,30 @@ async def main():
task_wp_update_loop.cancel()
logger.info("exiting main loop")
update_webpage(apparatus=apparatus)
- return(apparatus)
+ return apparatus
+
def update_webpage(byWhom=None, apparatus=None):
timestr = time.strftime("%a, %d %b %Y, %H:%M:%S", time.localtime())
- clock_upd.text = f'Last update at {timestr}'
+ clock_upd.text = f"Last update at {timestr}"
try:
status_line.text = apparatus.state
except:
pass
jp.run_task(wp.update())
+
async def update_webpage_loop(update_interval=1):
while True:
update_webpage()
await asyncio.sleep(update_interval)
+
async def getPage():
return wp
-async def jp_startup():
+
+async def jp_startup():
jp.run_task(main())
@@ -440,95 +483,100 @@ class Apparatus(BasicInstrument):
@BasicInstrument.tsdb_append
def getBCurrent(self):
- scope = self.instruments['scope.monitor']
- ch=scope.getTrace(2, decimate=False)
- bCurrent = np.mean(ch.y.values); # mV -> mA
+ scope = self.instruments["scope.monitor"]
+ ch = scope.getTrace(2, decimate=False)
+ bCurrent = np.mean(ch.y.values)
+ # mV -> mA
return bCurrent
def getErrAndEit(self):
- scope = self.instruments['scope.feedback']
+ scope = self.instruments["scope.feedback"]
# we need to freeze scope since this two values are taken on the same scope
trg_mode = scope.getTriggerMode()
- scope.setTriggerMode('STOP')
+ scope.setTriggerMode("STOP")
err = self.getErr()
eit = self.getEIT()
scope.setTriggerMode(trg_mode)
- return(err,eit)
-
-
+ return (err, eit)
@BasicInstrument.tsdb_append
def getErr(self):
- scope = self.instruments['scope.feedback']
- ch1=scope.getTrace(1, decimate=False)
+ scope = self.instruments["scope.feedback"]
+ ch1 = scope.getTrace(1, decimate=False)
err = np.mean(ch1.y.values)
return err
@BasicInstrument.tsdb_append
def getEIT(self):
- scope = self.instruments['scope.feedback']
- ch3=scope.getTrace(3, decimate=False)
+ scope = self.instruments["scope.feedback"]
+ ch3 = scope.getTrace(3, decimate=False)
eit = np.mean(ch3.y.values)
return eit
@BasicInstrument.tsdb_append
def setFeefback(self, val):
freq0 = self.getRFreq()
- self.setRFreq(freq0+val)
+ self.setRFreq(freq0 + val)
@BasicInstrument.tsdb_append
def getRFreq(self):
- rfgen = self.instruments['rfgen']
+ rfgen = self.instruments["rfgen"]
return rfgen.getFreqFixed()
@BasicInstrument.tsdb_append
- def setRFreq(self,val):
- rfgen = self.instruments['rfgen']
+ def setRFreq(self, val):
+ rfgen = self.instruments["rfgen"]
rfgen.setFreqFixed(val)
@BasicInstrument.tsdb_append
def getRFAmplitude(self):
- rfgen = self.instruments['rfgen']
+ rfgen = self.instruments["rfgen"]
return rfgen.getRFAmplitude()
@BasicInstrument.tsdb_append
def setRFAmplitude(self, val):
- rfgen = self.instruments['rfgen']
+ rfgen = self.instruments["rfgen"]
return rfgen.setRFAmplitude(val)
@BasicInstrument.tsdb_append
def setLockinSlope(self, val):
- self.lockin_slope=val
+ self.lockin_slope = val
-if __name__ == '__main__':
- logger.info('========== Start up ===========')
- tsdb_client = tsdb.Client('influx', 'http://lumus.physics.wm.edu:8428', database='qolab')
- tsdb_ingester = tsdb.Ingester(tsdb_client, batch=11, measurement_prefix='VAMPIRE.HighPower')
+if __name__ == "__main__":
+ logger.info("========== Start up ===========")
+ tsdb_client = tsdb.Client(
+ "influx", "http://lumus.physics.wm.edu:8428", database="qolab"
+ )
+ tsdb_ingester = tsdb.Ingester(
+ tsdb_client, batch=11, measurement_prefix="VAMPIRE.HighPower"
+ )
wp = jp.WebPage(delete_flag=False)
- apparatus = Apparatus(tsdb_ingester=tsdb_ingester, device_nickname='magnetometer',)
- apparatus.config['Device type'] = 'QOL VAMPIRE HighPower magnetometer'
- apparatus.config['Device model'] = 'v0.1'
- apparatus.config['FnamePrefix'] = 'magnetometer'
- apparatus.config['SavePath'] = '/mnt/qol_grp_data/data.VAMPIRE.HighPower'
+ apparatus = Apparatus(
+ tsdb_ingester=tsdb_ingester,
+ device_nickname="magnetometer",
+ )
+ apparatus.config["Device type"] = "QOL VAMPIRE HighPower magnetometer"
+ apparatus.config["Device model"] = "v0.1"
+ apparatus.config["FnamePrefix"] = "magnetometer"
+ apparatus.config["SavePath"] = "/mnt/qol_grp_data/data.VAMPIRE.HighPower"
# apparatus.config['SavePath'] = './data'
- d=jp.Div(text='Magnetometer log', a=wp, classes='text-white bg-blue-500 text-center text-xl')
+ d = jp.Div(
+ text="Magnetometer log",
+ a=wp,
+ classes="text-white bg-blue-500 text-center text-xl",
+ )
- div_status = jp.Div(classes='text-xl flex m0 p-1 space-x-4 bg-gray-300 font-mono', a=wp)
- clock_upd = jp.Div(text='Clock Loading...', classes='text-xl bg-gray-400', a=div_status)
- status_line = jp.Div(text='Status Loading...',classes='text-xl', a=div_status)
+ div_status = jp.Div(
+ classes="text-xl flex m0 p-1 space-x-4 bg-gray-300 font-mono", a=wp
+ )
+ clock_upd = jp.Div(
+ text="Clock Loading...", classes="text-xl bg-gray-400", a=div_status
+ )
+ status_line = jp.Div(text="Status Loading...", classes="text-xl", a=div_status)
# mpl.use("TkAgg")
# apparatus = asyncio.run(main())
jp.justpy(getPage, startup=jp_startup)
-
-
-
-
-
-
-
-
-
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-16 18:37:16 +0000