fix bugs with persistent_limit parameter

take into account that reading the switch heater might be delayed

cfg/main/mb11.cfg

@@ -82,6 +82,16 @@ description = dynamic needle valve position
 slot =  DB8.P1,DB4.G1
 io = itc1
 
+[mf]
+class = secop_psi.ips_mercury.Field
+description = magnetic field
+slot = GRPZ
+io = ips
+tolerance = 0.001
+wait_stable_field = 60
+target.max = 11
+persistent_limit = 7
+
 [lev]
 class = secop_psi.mercury.HeLevel
 description = LHe level
@@ -156,14 +166,6 @@ description = coil temperature
 slot = MB1.T1
 io = ips
 
-[mf]
-class = secop_psi.ips_mercury.Field
-description = magnetic field
-slot = GRPZ
-io = ips
-tolerance = 0.001
-target.max = 11
-
 [om_io]
 description = dom motor IO
 class = secop_psi.phytron.PhytronIO

secop_psi/ips_mercury.py

@@ -119,16 +119,27 @@ class Field(MercuryChannel, Magfield):
             return current / self.atob
         return 0
 
-    def start_ramp_to_field(self, state):
+    def set_and_go(self, value):
-        self.change('PSU:SIG:FSET', self.persistent_field)
+        self.change('PSU:SIG:FSET', value)
         assert self.write_action('hold') == 'hold'
         assert self.write_action('run_to_set') == 'run_to_set'
+
+    def start_ramp_to_field(self, state):
+        try:
+            self.set_and_go(self.persistent_field)
+        except (HardwareError, AssertionError):
+            state.switch_undef = self.switch_on_time or state.now
+            return self.wait_for_switch
+        return self.ramp_to_field
+
+    def wait_for_switch(self, state):
+        if self.now - self.switch_undef < self.wait_switch_on:
+            return Retry()
+        self.set_and_go(self.persistent_field)
         return self.ramp_to_field
         
     def start_ramp_to_target(self, state):
-        self.change('PSU:SIG:FSET', self.target)
+        self.set_and_go(self.target)
-        assert self.write_action('hold') == 'hold'
-        assert self.write_action('run_to_set') == 'run_to_set'
         return self.ramp_to_target
 
     def start_ramp_to_zero(self, state):

secop_psi/magfield.py

@@ -185,7 +185,7 @@ class Magfield(HasLimits, Drivable):
 
     def update_switch_heater(self, value):
         """is called whenever switch heater was changed"""
-        if value:
+        if value != 0:
             self.switch_off_time = None
             if self.switch_on_time is None:
                 self.switch_on_time = time.time()
@@ -196,11 +196,15 @@ class Magfield(HasLimits, Drivable):
 
     def start_switch_on(self, state):
         """switch heater on"""
-        if self.switch_heater != 0:
+        if self.switch_heater == 0:
-            self.status = Status.PREPARING, 'wait for heater on'
-        else:
             self.status = Status.PREPARING, 'turn switch heater on'
+            try:
                 self.write_switch_heater(True)
+            except Exception as e:
+                self.log.warning('write_switch_heater %r', e)
+                return Retry()
+        else:
+            self.status = Status.PREPARING, 'wait for heater on'
         return self.switch_on
 
     def switch_on(self, state):
@@ -210,8 +214,10 @@ class Magfield(HasLimits, Drivable):
             return self.check_switch_off
         self.read_switch_heater()
         if self.switch_on_time is None:
-            self.log.warning('switch turned off manually - try again')
+            if state.now - self.switch_off_time > 10:
+                 self.log.warning('switch turned off manually?')
                  return self.start_switch_on
+            return Retry()
         if state.now - self.switch_on_time < self.wait_switch_on:
             return Retry()
         self._last_target = self.target
@@ -258,11 +264,11 @@ class Magfield(HasLimits, Drivable):
 
     def start_switch_off(self, state):
         """turn off switch heater"""
-        if self.switch_heater != 0:
+        if self.switch_heater == 1:
             self.status = Status.FINALIZING, 'turn switch heater off'
+            self.write_switch_heater(False)
         else:
             self.status = Status.FINALIZING, 'wait for heater off'
-        self.write_switch_heater(False)
         return self.switch_off
 
     def switch_off(self, state):
@@ -274,8 +280,10 @@ class Magfield(HasLimits, Drivable):
         self.persistent_field = self.value
         self.read_switch_heater()
         if self.switch_off_time is None:
-            self.log.warning('switch turned on manually - try again')
+            if state.now - self.switch_on_time > 10:
+                 self.log.warning('switch turned on manually?')
                  return self.start_switch_off
+            return Retry()
         if state.now - self.switch_off_time < self.wait_switch_off:
             return Retry()
         if abs(self.value) > self.persistent_limit: