lakeshore ramp

Change-Id: I323c2b88e554bc2dc9c3f1af2b23f99aa082489f

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',
+    output_module='Heater',
-    target = Param(max=470),
+    target=Param(max=470),
-    io = 'io',
+    io='io',
-    channel = 'B',
+    channel='B'
-)
+    )
 
 Mod('T_cold_finger',
     'frappy_psi.lakeshore.Sensor340',
     'cold finger temperature',
-    io = 'io',
+    io='io',
-    channel = 'A'
+    channel='A'
-)
+    )
 
 Mod('Heater',
     'frappy_psi.lakeshore.HeaterOutput',
     'heater output',
-    channel = 'B',
+    channel='B',
-    io = 'io',
+    io='io',
-    resistance = 50,
+    resistance=50,
-    max_power = 50,
+    max_power=50,
-    current = 1
+    current=1
-)
+    )
-

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 self.get_par(f'KRDG? {self.channel}')
-        return float(reply)
 
     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};'
+        self.set_par(f'CLIMIT {self.loop}', self.SETPOINTLIMS, 0, 0, icurrent, irange)
-                         f'RANGE {irange};'
+        self.set_par(f'RANGE {irange}')
-                         f'CDISP {self.loop},1,{self.resistance},0;RANGE?;'
+        self.set_par(f'CDISP {self.loop}', 1, self.resistance, 0)
-                         f'RELAY? 1') #only high relay
+        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;.'
+        self.set_par(f'CSET {self.loop}', self.channel, 1, 1, 0)
-                         f'CMODE {self.loop}, {int(mode)};'
+        self.set_par(f'CMODE {self.loop}', int(mode))
-                         f'RANGE?')
+        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):
+    def read_setpoint(self):
-        return self.get_par(f'SETP?{self.loop}')[0]
+        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