mercury, ips, sea, triton, convergence

after gerrit

Change-Id: Iff14047ecc476589aef10c96fae9970133b8bd14

frappy_psi/magfield.py

@@ -20,12 +20,11 @@
 """generic persistent magnet driver"""
 
 import time
-from frappy.core import Drivable, Parameter, Done, IDLE, BUSY, ERROR
-from frappy.datatypes import FloatRange, EnumType, ArrayOf, TupleOf, StatusType
-from frappy.features import HasTargetLimits
-from frappy.errors import ConfigError, ProgrammingError, HardwareError, BadValueError
+from frappy.core import Drivable, Parameter, BUSY, Limit
+from frappy.datatypes import FloatRange, EnumType, TupleOf, StatusType
+from frappy.errors import ConfigError, HardwareError, DisabledError
 from frappy.lib.enum import Enum
-from frappy.states import Retry, HasStates, status_code, Start
+from frappy.states import Retry, HasStates, status_code
 
 UNLIMITED = FloatRange()
 
@@ -48,8 +47,10 @@ OFF = 0
 ON = 1
 
 
-class SimpleMagfield(HasStates, HasTargetLimits, Drivable):
+class SimpleMagfield(HasStates, Drivable):
     value = Parameter('magnetic field', datatype=FloatRange(unit='T'))
+    target_min = Limit()
+    target_max = Limit()
     ramp = Parameter(
         'wanted ramp rate for field', FloatRange(unit='$/min'), readonly=False)
     # export only when different from ramp:
@@ -68,6 +69,22 @@ class SimpleMagfield(HasStates, HasTargetLimits, Drivable):
         FloatRange(0, unit='s'), readonly=False, default=30)
 
     _last_target = None
+    _symmetric_limits = False
+
+    def earlyInit(self):
+        super().earlyInit()
+        # when limits are symmetric at init, we want auto symmetric limits
+        self._symmetric_limits = self.target_min == -self.target_max
+
+    def write_target_max(self, value):
+        if self._symmetric_limits:
+            self.target_min = -value
+        return value
+
+    def write_target_min(self, value):
+        """when modified to other than a symmetric value, we assume the user does not want auto symmetric limits"""
+        self._symmetric_limits = value == -self.target_max
+        return value
 
     def checkProperties(self):
         dt = self.parameters['target'].datatype
@@ -76,6 +93,9 @@ class SimpleMagfield(HasStates, HasTargetLimits, Drivable):
             raise ConfigError('target.max not configured')
         if dt.min == UNLIMITED.min:  # not given: assume bipolar symmetric
             dt.min = -max_
+            self.target_min = max(dt.min, self.target_min)
+            if 'target_max' in self.writeDict:
+                self.writeDict.setdefault('target_min', -self.writeDict['target_max'])
         super().checkProperties()
 
     def stop(self):
@@ -101,7 +121,6 @@ class SimpleMagfield(HasStates, HasTargetLimits, Drivable):
         return last
 
     def write_target(self, target):
-        self.check_limits(target)
         self.start_machine(self.start_field_change, target=target)
         return target
 
@@ -147,8 +166,7 @@ class SimpleMagfield(HasStates, HasTargetLimits, Drivable):
 
 class Magfield(SimpleMagfield):
     status = Parameter(datatype=StatusType(Status))
-    mode = Parameter(
-        'persistent mode', EnumType(Mode), readonly=False, initwrite=False, default=Mode.PERSISTENT)
+    mode = Parameter('persistent mode', EnumType(Mode), readonly=False, default=Mode.PERSISTENT)
     switch_heater = Parameter('switch heater', EnumType(off=OFF, on=ON),
                               readonly=False, default=0)
     current = Parameter(
@@ -180,6 +198,9 @@ class Magfield(SimpleMagfield):
     def doPoll(self):
         if self.init_persistency:
             if self.read_switch_heater() and self.mode != Mode.DRIVEN:
+                # switch heater is on on startup: got to persistent mode
+                # do this after some delay, so the user might continue
+                # driving without delay after a restart
                 self.start_machine(self.go_persistent_soon, mode=self.mode)
             self.init_persistency = False
         super().doPoll()
@@ -207,9 +228,7 @@ class Magfield(SimpleMagfield):
         if self.mode == Mode.DISABLED:
             if target == 0:
                 return 0
-            self.log.info('raise error %r', target)
-            raise BadValueError('disabled')
-        self.check_limits(target)
+            raise DisabledError('disabled')
         self.start_machine(self.start_field_change, target=target, mode=self.mode)
         return target