diff --git a/cfg/ls340_cfg.py b/cfg/ls340_cfg.py index c42833a..41b7399 100644 --- a/cfg/ls340_cfg.py +++ b/cfg/ls340_cfg.py @@ -1,37 +1,36 @@ Node('ls340test.psi.ch', 'ls340 test', - 'tcp://5000', -) + 'tcp://5000' + ) Mod('io', 'frappy_psi.lakeshore.Ls340IO', 'communication to ls340', - uri = 'tcp://ldmprep56-ts:3002' -) + uri='tcp://ldmprep56-ts:3002' + ) Mod('T', 'frappy_psi.lakeshore.TemperatureLoop340', 'sample temperature', - output_module = 'Heater', - target = Param(max=470), - io = 'io', - channel = 'B', -) + output_module='Heater', + target=Param(max=470), + io='io', + channel='B' + ) Mod('T_cold_finger', 'frappy_psi.lakeshore.Sensor340', 'cold finger temperature', - io = 'io', - channel = 'A' -) + io='io', + channel='A' + ) Mod('Heater', 'frappy_psi.lakeshore.HeaterOutput', 'heater output', - channel = 'B', - io = 'io', - resistance = 50, - max_power = 50, - current = 1 -) - + channel='B', + io='io', + resistance=50, + max_power=50, + current=1 + ) diff --git a/frappy_psi/lakeshore.py b/frappy_psi/lakeshore.py index 9bb3120..64b9667 100644 --- a/frappy_psi/lakeshore.py +++ b/frappy_psi/lakeshore.py @@ -22,8 +22,9 @@ from frappy.core import Readable, Parameter, IntRange, EnumType, FloatRange, \ StringIO, HasIO, StringType, Property, Writable, Drivable, IDLE, ERROR, \ - Attached, StructOf, WARN + Attached, StructOf, WARN, Done, BoolType +from frappy_psi.convergence import HasConvergence from frappy_psi.mixins import HasOutputModule, HasControlledBy @@ -58,11 +59,10 @@ class Sensor340(LakeShore, Readable): value = Parameter(unit='K') def read_value(self): - reply = self.communicate(f'KRDG? {self.channel}') - return float(reply) + return self.get_par(f'KRDG? {self.channel}') def read_status(self): - c = int(self.communicate(f'RDGST? {self.channel}')) + c = int(self.get_par(f'RDGST? {self.channel}')) if c >= 128: return ERROR, 'units overrange' if c >= 64: @@ -75,7 +75,7 @@ class Sensor340(LakeShore, Readable): if c % 2: return ERROR, 'invalid reading' # ask for high alarm status and return warning - if '1' in self.communicate(f'ALARMST? {self.channel}'): + if '1' in self.get_par(f'ALARMST? {self.channel}'): return WARN, 'alarm triggered' return IDLE, '' @@ -128,15 +128,15 @@ class HeaterOutput(LakeShore, HasControlledBy, HasIO, Writable): break prev = power self._range = irange - self.communicate(f'CLIMIT {self.loop},{self.SETPOINTLIMS},0,0,{icurrent},{irange};' - f'RANGE {irange};' - f'CDISP {self.loop},1,{self.resistance},0;RANGE?;' - f'RELAY? 1') #only high relay + self.set_par(f'CLIMIT {self.loop}', self.SETPOINTLIMS, 0, 0, icurrent, irange) + self.set_par(f'RANGE {irange}') + self.set_par(f'CDISP {self.loop}', 1, self.resistance, 0) + self.get_par(f'RELAY? 1') #only high relay return self.read_max_power() def read_max_power(self): setplimit, _, _, icurrent, irange = [ - float(s) for s in self.communicate(f'CLIMIT? {self.loop}').split(',')] + float(s) for s in self.get_par(f'CLIMIT? {self.loop}')] # max_power from codes disregarding voltage limit: self._max_power = self.MAXCURRENTS[icurrent] ** 2 * self.RANGES[irange] * self.resistance # voltage limit = 50V: @@ -154,7 +154,7 @@ class HeaterOutput(LakeShore, HasControlledBy, HasIO, Writable): return (power / self._max_power) ** (1 / 2) * 100 # limit def read_status(self): - return self.STATUS_MAP[int(self.communicate(f'HTRST?'))] + return self.STATUS_MAP[int(self.get_par(f'HTRST?'))] def write_target(self, target): self.self_controlled() @@ -162,24 +162,31 @@ class HeaterOutput(LakeShore, HasControlledBy, HasIO, Writable): self.set_heater_mode(3) self.set_range() percent = self.power_to_percent(target) - reply, = self.set_par(f'MOUT {self.loop}, {percent:g}') + reply, = self.set_par(f'MOUT {self.loop}', '%g' % percent) return self.percent_to_power(reply) def set_heater_mode(self, mode): - self.communicate(f'CSET {self.loop},{self.channel},1,1,0;.' - f'CMODE {self.loop}, {int(mode)};' - f'RANGE?') + self.set_par(f'CSET {self.loop}', self.channel, 1, 1, 0) + self.set_par(f'CMODE {self.loop}', int(mode)) + return self.get_par(f'RANGE?') def read_value(self): - return self.percent_to_power(float(self.communicate(f'HTR?'))) + return self.percent_to_power(self.get_par(f'HTR?')) -class TemperatureLoop340(HasOutputModule, Sensor340, Drivable, LakeShore): +class TemperatureLoop340(HasConvergence, HasOutputModule, Sensor340, Drivable, LakeShore): target = Parameter(unit='K') ctrlpars = Parameter('PID parameters', StructOf(p=FloatRange(0, 1000), i=FloatRange(0, 1000), d=FloatRange(0, 1000)), readonly=False) loop = Property('lakeshore loop', IntRange(1, 2), default=1) + ramp = Parameter('ramp rate', FloatRange(min=0, max=1000), unit='K/min', readonly=False) + ramp_used = Parameter('whether ramp is used or not', BoolType(), readonly=False) + setpoint = Parameter('setpoint', datatype=FloatRange, unit='K') + + def doPoll(self): + super().doPoll() + self.read_setpoint() def write_target(self, target): out = self.output_module @@ -189,10 +196,15 @@ class TemperatureLoop340(HasOutputModule, Sensor340, Drivable, LakeShore): out.write_max_power(out.max_power) self.activate_output() out.set_range() - return self.set_par(f'SETP {self.loop},{target}')[0] + self.set_par(f'SETP {self.loop}', target) + return target - def read_target(self): - return self.get_par(f'SETP?{self.loop}')[0] + def read_setpoint(self): + setpoint = self.get_par(f'SETP?{self.loop}')[0] + status = self.get_par(f'RAMPST? {self.loop}') + if status == 0: + self.target = setpoint + return setpoint def write_ctrlpars(self, ctrlpars): p, i, d = self.set_par(f'PID {self.loop}', ctrlpars['p'], ctrlpars['i'], ctrlpars['d']) @@ -202,10 +214,25 @@ class TemperatureLoop340(HasOutputModule, Sensor340, Drivable, LakeShore): p, i, d = self.get_par(f'PID? {self.loop}') return {'p': p, 'i': i, 'd': d} - - - - + def write_ramp(self, ramp): + return self.set_par(f'RAMP {self.loop}', self.ramp_used, ramp) + + def write_ramp_used(self, ramp_used): + return self.set_par(f'RAMP {self.loop}', ramp_used, self.ramp) + + def read_ramp(self): + status, rate = self.get_par(f'RAMP? {self.loop}') + if status == 'off': + return False, rate + return True, rate + + def read_status(self): + statuscode, statustext = super().read_status() + if statuscode == IDLE: + return Done + if self.convergence_state.is_active(): + self.convergence_state.stop_machine((statuscode, statustext)) + return ERROR, statustext