magfield adapted to new state machine
This commit is contained in:
l_samenv
@ -20,12 +20,12 @@
|
||||
"""generic persistent magnet driver"""
|
||||
|
||||
import time
|
||||
from secop.core import Drivable, Parameter, Done
|
||||
from secop.core import Drivable, Parameter, Done, IDLE, BUSY, ERROR
|
||||
from secop.datatypes import FloatRange, EnumType, ArrayOf, TupleOf, StatusType
|
||||
from secop.features import HasLimits
|
||||
from secop.errors import ConfigError, ProgrammingError
|
||||
from secop.errors import ConfigError, ProgrammingError, HardwareError
|
||||
from secop.lib.enum import Enum
|
||||
from secop.lib.statemachine import Retry, StateMachine
|
||||
from secop.states import Retry, HasStates, status_code
|
||||
|
||||
UNLIMITED = FloatRange()
|
||||
|
||||
@ -48,52 +48,23 @@ OFF = 0
|
||||
ON = 1
|
||||
|
||||
|
||||
class Magfield(HasLimits, Drivable):
|
||||
class SimpleMagfield(HasStates, HasLimits, Drivable):
|
||||
value = Parameter('magnetic field', datatype=FloatRange(unit='T'))
|
||||
status = Parameter(datatype=StatusType(Status))
|
||||
mode = Parameter(
|
||||
'persistent mode', EnumType(Mode), readonly=False, default=Mode.PERSISTENT)
|
||||
ramp = Parameter(
|
||||
'wanted ramp rate for field', FloatRange(unit='$/min'), readonly=False)
|
||||
# export only when different from ramp:
|
||||
workingramp = Parameter(
|
||||
'effective ramp rate for field', FloatRange(unit='$/min'), export=False)
|
||||
tolerance = Parameter(
|
||||
'tolerance', FloatRange(0, unit='$'), readonly=False, default=0.0002)
|
||||
switch_heater = Parameter('switch heater', EnumType(off=OFF, on=ON),
|
||||
readonly=False, default=0)
|
||||
persistent_field = Parameter(
|
||||
'persistent field', FloatRange(unit='$'), readonly=False)
|
||||
current = Parameter(
|
||||
'leads current (in units of field)', FloatRange(unit='$'))
|
||||
ramp = Parameter(
|
||||
'ramp rate for field', FloatRange(unit='$/min'), readonly=False)
|
||||
trained = Parameter(
|
||||
'trained field (positive)',
|
||||
TupleOf(FloatRange(-99, 0, unit='$'), FloatRange(0, unit='$')),
|
||||
readonly=False, default=(0, 0))
|
||||
# TODO: time_to_target
|
||||
# profile = Parameter(
|
||||
# 'ramp limit table', ArrayOf(TupleOf(FloatRange(unit='$'), FloatRange(unit='$/min'))),
|
||||
# readonly=False)
|
||||
# profile_training = Parameter(
|
||||
# 'ramp limit table when in training',
|
||||
# ArrayOf(TupleOf(FloatRange(unit='$'), FloatRange(unit='$/min'))), readonly=False)
|
||||
# TODO: the following parameters should be changed into properties after tests
|
||||
wait_switch_on = Parameter(
|
||||
'wait time to ensure switch is on', FloatRange(0, unit='s'), readonly=False, default=60)
|
||||
wait_switch_off = Parameter(
|
||||
'wait time to ensure switch is off', FloatRange(0, unit='s'), readonly=False, default=60)
|
||||
wait_stable_leads = Parameter(
|
||||
'wait time to ensure current is stable', FloatRange(0, unit='s'), readonly=False, default=6)
|
||||
wait_stable_field = Parameter(
|
||||
'wait time to ensure field is stable', FloatRange(0, unit='s'), readonly=False, default=30)
|
||||
persistent_limit = Parameter(
|
||||
'above this limit, lead currents are not driven to 0',
|
||||
FloatRange(0, unit='$'), readonly=False, default=99)
|
||||
'wait time to ensure field is stable', FloatRange(0, unit='s'), readonly=False, default=31)
|
||||
|
||||
_state = None
|
||||
_last_target = None
|
||||
switch_time = None, None
|
||||
|
||||
def doPoll(self):
|
||||
self.read_value()
|
||||
self._state.cycle()
|
||||
|
||||
def checkProperties(self):
|
||||
dt = self.parameters['target'].datatype
|
||||
@ -104,216 +75,285 @@ class Magfield(HasLimits, Drivable):
|
||||
dt.min = -max_
|
||||
super().checkProperties()
|
||||
|
||||
def initModule(self):
|
||||
super().initModule()
|
||||
self.registerCallbacks(self) # for update_switch_heater
|
||||
self._state = StateMachine(logger=self.log, threaded=False, cleanup=self.cleanup_state)
|
||||
|
||||
def startModule(self, start_events):
|
||||
start_events.queue(self.startupCheck)
|
||||
super().startModule(start_events)
|
||||
|
||||
def startupCheck(self):
|
||||
if self.read_switch_heater() and self.mode == Mode.PERSISTENT:
|
||||
self.read_value() # check for persistent field mismatch
|
||||
# switch off heater from previous live or manual intervention
|
||||
self.write_mode(self.mode)
|
||||
self.write_target(self.persistent_field)
|
||||
else:
|
||||
self._last_target = self.persistent_field
|
||||
|
||||
def write_target(self, target):
|
||||
self.check_limits(target)
|
||||
self.target = target
|
||||
if not self._state.is_active:
|
||||
# as long as the state machine is still running, it takes care of changing targets
|
||||
self._state.start(self.start_field_change)
|
||||
self.doPoll()
|
||||
return Done
|
||||
|
||||
def write_mode(self, value):
|
||||
self.mode = value
|
||||
if not self._state.is_active:
|
||||
self._state.start(self.start_field_change)
|
||||
self.doPoll()
|
||||
return Done
|
||||
|
||||
def cleanup_state(self, state):
|
||||
self.status = Status.ERROR, repr(state.last_error)
|
||||
self.log.error('in state %s: %r', state.state.__name__, state.last_error)
|
||||
self.setFastPoll(False)
|
||||
if self.switch_heater != 0:
|
||||
self.persistent_field = self.read_value()
|
||||
if self.mode != Mode.DRIVEN:
|
||||
self.log.warning('turn switch heater off')
|
||||
self.write_switch_heater(0)
|
||||
|
||||
def stop(self):
|
||||
"""keep field at current value"""
|
||||
# let the state machine do the needed steps to finish
|
||||
self.write_target(self.value)
|
||||
|
||||
def start_field_change(self, state):
|
||||
def write_target(self, target):
|
||||
self.check_limits(target)
|
||||
self.start_machine(self.start_field_change, target=target)
|
||||
return target
|
||||
|
||||
def init_progress(self, sm, value):
|
||||
sm.prev_point = sm.now, value
|
||||
|
||||
def get_progress(self, sm, value):
|
||||
"""return the time passed for at least one tolerance step"""
|
||||
t, v = sm.prev_point
|
||||
dif = abs(v - value)
|
||||
tdif = sm.now - t
|
||||
if dif > self.tolerance:
|
||||
sm.prev_point = sm.now, value
|
||||
return tdif
|
||||
|
||||
@status_code(BUSY, 'start ramp to target')
|
||||
def start_field_change(self, sm):
|
||||
self.setFastPoll(True, 1.0)
|
||||
self.status = Status.PREPARING, 'changed target field'
|
||||
if (self.target == self._last_target and
|
||||
abs(self.target - self.persistent_field) <= self.tolerance): # short cut
|
||||
return self.start_ramp_to_target
|
||||
|
||||
@status_code(BUSY, 'ramping field')
|
||||
def ramp_to_target(self, sm):
|
||||
if sm.init:
|
||||
self.init_progress(sm, self.value)
|
||||
# Remarks: assume there is a ramp limiting feature
|
||||
if abs(self.value - sm.target) > self.tolerance:
|
||||
if self.get_progress(sm, self.value):
|
||||
return Retry
|
||||
raise HardwareError('no progress')
|
||||
sm.stabilize_start = time.time()
|
||||
return self.stabilize_field
|
||||
|
||||
@status_code(BUSY, 'stabilizing field')
|
||||
def stabilize_field(self, sm):
|
||||
if sm.now - sm.stabilize_start < self.wait_stable_field:
|
||||
return Retry
|
||||
return self.final_status()
|
||||
|
||||
def read_workingramp(self):
|
||||
return self.ramp
|
||||
|
||||
|
||||
class Magfield(SimpleMagfield):
|
||||
status = Parameter(datatype=StatusType(Status))
|
||||
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)
|
||||
persistent_field = Parameter(
|
||||
'persistent field', FloatRange(unit='$'), readonly=False)
|
||||
current = Parameter(
|
||||
'leads current (in units of field)', FloatRange(unit='$'))
|
||||
# TODO: time_to_target
|
||||
# profile = Parameter(
|
||||
# 'ramp limit table', ArrayOf(TupleOf(FloatRange(unit='$'), FloatRange(unit='$/min'))),
|
||||
# readonly=False)
|
||||
# profile_training = Parameter(
|
||||
# 'ramp limit table when in training',
|
||||
# ArrayOf(TupleOf(FloatRange(unit='$'), FloatRange(unit='$/min'))), readonly=False)
|
||||
# TODO: the following parameters should be changed into properties after tests
|
||||
wait_switch_on = Parameter(
|
||||
'wait time to ensure switch is on', FloatRange(0, unit='s'), readonly=False, default=61)
|
||||
wait_switch_off = Parameter(
|
||||
'wait time to ensure switch is off', FloatRange(0, unit='s'), readonly=False, default=61)
|
||||
wait_stable_leads = Parameter(
|
||||
'wait time to ensure current is stable', FloatRange(0, unit='s'), readonly=False, default=6)
|
||||
persistent_limit = Parameter(
|
||||
'above this limit, lead currents are not driven to 0',
|
||||
FloatRange(0, unit='$'), readonly=False, default=99)
|
||||
leads_ramp_tmo = Parameter(
|
||||
'timeout for leads ramp progress',
|
||||
FloatRange(0, unit='s'), readonly=False, default=30)
|
||||
ramp_tmo = Parameter(
|
||||
'timeout for field ramp progress',
|
||||
FloatRange(0, unit='s'), readonly=False, default=30)
|
||||
__init = True
|
||||
switch_on_time = None
|
||||
switch_off_time = None
|
||||
|
||||
def doPoll(self):
|
||||
if self.__init:
|
||||
self.__init = False
|
||||
if self.read_switch_heater() and self.mode == Mode.PERSISTENT:
|
||||
self.read_value() # check for persistent field mismatch
|
||||
# switch off heater from previous live or manual intervention
|
||||
self.write_target(self.persistent_field)
|
||||
else:
|
||||
self._last_target = self.persistent_field
|
||||
else:
|
||||
super().doPoll()
|
||||
|
||||
def initModule(self):
|
||||
super().initModule()
|
||||
self.registerCallbacks(self) # for update_switch_heater
|
||||
|
||||
def write_mode(self, value):
|
||||
self.start_machine(self.start_field_change, cleanup=self.cleanup, target=self.target, mode=value)
|
||||
return value
|
||||
|
||||
def write_target(self, target):
|
||||
self.check_limits(target)
|
||||
self.start_machine(self.start_field_change, cleanup=self.cleanup, target=target, mode=self.mode)
|
||||
return target
|
||||
|
||||
def cleanup(self, sm): # sm is short for statemachine
|
||||
if self.switch_heater != 0:
|
||||
self.persistent_field = self.read_value()
|
||||
if sm.mode != Mode.DRIVEN:
|
||||
self.log.warning('turn switch heater off')
|
||||
self.write_switch_heater(0)
|
||||
|
||||
@status_code('PREPARING')
|
||||
def start_field_change(self, sm):
|
||||
self.setFastPoll(True, 1.0)
|
||||
if sm.target == self.persistent_field or (
|
||||
sm.target == self._last_target and
|
||||
abs(sm.target - self.persistent_field) <= self.tolerance): # short cut
|
||||
return self.check_switch_off
|
||||
if self.switch_heater:
|
||||
return self.start_switch_on
|
||||
return self.start_ramp_to_field
|
||||
|
||||
def start_ramp_to_field(self, state):
|
||||
@status_code('PREPARING')
|
||||
def start_ramp_to_field(self, sm):
|
||||
"""start ramping current to persistent field
|
||||
|
||||
should return ramp_to_field
|
||||
initiate ramp to persistent field (with corresponding ramp rate)
|
||||
the implementation should return ramp_to_field
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
def ramp_to_field(self, state):
|
||||
"""ramping, wait for current at persistent field"""
|
||||
if (self.target == self._last_target and
|
||||
abs(self.target - self.persistent_field) <= self.tolerance): # short cut
|
||||
return self.check_switch_off
|
||||
if abs(self.current - self.persistent_field) > self.tolerance:
|
||||
if state.init:
|
||||
self.status = Status.PREPARING, 'ramping leads current to field'
|
||||
return Retry()
|
||||
state.stabilize_start = time.time()
|
||||
@status_code('PREPARING', 'ramp leads to match field')
|
||||
def ramp_to_field(self, sm):
|
||||
if sm.init:
|
||||
sm.stabilize_start = 0 # in case current is already at field
|
||||
self.init_progress(sm, self.current)
|
||||
dif = abs(self.current - self.persistent_field)
|
||||
if dif > self.tolerance:
|
||||
tdif = self.get_progress(sm, self.current)
|
||||
if tdif > self.leads_ramp_tmo:
|
||||
raise HardwareError('no progress')
|
||||
sm.stabilize_start = None # force reset
|
||||
return Retry
|
||||
if sm.stabilize_start is None:
|
||||
sm.stabilize_start = sm.now
|
||||
return self.stabilize_current
|
||||
|
||||
def stabilize_current(self, state):
|
||||
"""wait for stable current at persistent field"""
|
||||
if state.now - state.stabilize_start < self.wait_stable_leads:
|
||||
if state.init:
|
||||
self.status = Status.PREPARING, 'stabilizing leads current'
|
||||
return Retry()
|
||||
@status_code('PREPARING')
|
||||
def stabilize_current(self, sm):
|
||||
if sm.now - sm.stabilize_start < self.wait_stable_leads:
|
||||
return Retry
|
||||
return self.start_switch_on
|
||||
|
||||
def update_switch_heater(self, value):
|
||||
"""is called whenever switch heater was changed"""
|
||||
switch_time = self.switch_time[value]
|
||||
if switch_time is None:
|
||||
switch_time = time.time()
|
||||
self.switch_time = [None, None]
|
||||
self.switch_time[value] = switch_time
|
||||
print('SW', value)
|
||||
if value == 0:
|
||||
if self.switch_off_time is None:
|
||||
self.log.info('restart switch_off_time')
|
||||
self.switch_off_time = time.time()
|
||||
self.switch_on_time = None
|
||||
else:
|
||||
if self.switch_on_time is None:
|
||||
self.log.info('restart switch_on_time')
|
||||
self.switch_on_time = time.time()
|
||||
self.switch_off_time = None
|
||||
|
||||
def start_switch_on(self, state):
|
||||
"""switch heater on"""
|
||||
if self.switch_heater == 0:
|
||||
@status_code('PREPARING')
|
||||
def start_switch_on(self, sm):
|
||||
if self.read_switch_heater() == 0:
|
||||
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()
|
||||
return Retry
|
||||
else:
|
||||
self.status = Status.PREPARING, 'wait for heater on'
|
||||
return self.switch_on
|
||||
return self.wait_for_switch_on
|
||||
|
||||
def switch_on(self, state):
|
||||
"""wait for switch heater open"""
|
||||
if (self.target == self._last_target and
|
||||
abs(self.target - self.persistent_field) <= self.tolerance): # short cut
|
||||
@status_code('PREPARING')
|
||||
def wait_for_switch_on(self, sm):
|
||||
if (sm.target == self._last_target and
|
||||
abs(sm.target - self.persistent_field) <= self.tolerance): # short cut
|
||||
return self.check_switch_off
|
||||
self.read_switch_heater()
|
||||
if self.switch_time[ON] is None:
|
||||
self.read_switch_heater() # trigger switch_on/off_time
|
||||
if self.switch_heater == 0:
|
||||
self.log.warning('switch turned off manually?')
|
||||
return self.start_switch_on
|
||||
if state.now - self.switch_time[ON] < self.wait_switch_on:
|
||||
return Retry()
|
||||
self._last_target = self.target
|
||||
if sm.now - self.switch_on_time < self.wait_switch_on:
|
||||
if sm.delta(10):
|
||||
self.log.info('waited for %g sec', sm.now - self.switch_on_time)
|
||||
return Retry
|
||||
self._last_target = sm.target
|
||||
return self.start_ramp_to_target
|
||||
|
||||
def start_ramp_to_target(self, state):
|
||||
"""start ramping current to target
|
||||
@status_code('RAMPING')
|
||||
def start_ramp_to_target(self, sm):
|
||||
"""start ramping current to target field
|
||||
|
||||
should return ramp_to_target
|
||||
initiate ramp to target
|
||||
the implementation should return ramp_to_target
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
def ramp_to_target(self, state):
|
||||
"""ramp field to target"""
|
||||
if self.target != self._last_target: # target was changed
|
||||
self._last_target = self.target
|
||||
return self.start_ramp_to_target
|
||||
@status_code('RAMPING')
|
||||
def ramp_to_target(self, sm):
|
||||
self.persistent_field = self.value
|
||||
# Remarks: assume there is a ramp limiting feature
|
||||
if abs(self.value - self.target) > self.tolerance:
|
||||
if state.init:
|
||||
self.status = Status.RAMPING, 'ramping field'
|
||||
return Retry()
|
||||
state.stabilize_start = time.time()
|
||||
dif = abs(self.value - sm.target)
|
||||
if sm.init:
|
||||
sm.stabilize_start = 0 # in case current is already at target
|
||||
self.init_progress(sm, self.value)
|
||||
if dif > self.tolerance:
|
||||
sm.stabilize_start = sm.now
|
||||
tdif = self.get_progress(sm, self.value)
|
||||
if tdif > self.workingramp / self.tolerance * 60 + self.ramp_tmo:
|
||||
raise HardwareError('no progress')
|
||||
sm.stabilize_start = None
|
||||
return Retry
|
||||
if sm.stabilize_start is None:
|
||||
sm.stabilize_start = sm.now
|
||||
return self.stabilize_field
|
||||
|
||||
def stabilize_field(self, state):
|
||||
"""stabilize field"""
|
||||
if self.target != self._last_target: # target was changed
|
||||
self._last_target = self.target
|
||||
return self.start_ramp_to_target
|
||||
@status_code('STABILIZING')
|
||||
def stabilize_field(self, sm):
|
||||
self.persistent_field = self.value
|
||||
if state.now - state.stabilize_start < self.wait_stable_field:
|
||||
if state.init:
|
||||
self.status = Status.STABILIZING, 'stabilizing field'
|
||||
return Retry()
|
||||
if sm.now > sm.stablize_start + self.wait_stable_field:
|
||||
return Retry
|
||||
return self.check_switch_off
|
||||
|
||||
def check_switch_off(self, state):
|
||||
if self.mode == Mode.DRIVEN:
|
||||
self.status = Status.PREPARED, 'driven'
|
||||
return self.finish_state
|
||||
def check_switch_off(self, sm):
|
||||
if sm.mode == Mode.DRIVEN:
|
||||
return self.final_status(Status.PREPARED, 'driven')
|
||||
return self.start_switch_off
|
||||
|
||||
def start_switch_off(self, state):
|
||||
"""turn off switch heater"""
|
||||
@status_code('FINALIZING')
|
||||
def start_switch_off(self, sm):
|
||||
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'
|
||||
return self.switch_off
|
||||
return self.wait_for_switch_off
|
||||
|
||||
def switch_off(self, state):
|
||||
"""wait for switch heater closed"""
|
||||
if self.target != self._last_target or self.mode == Mode.DRIVEN:
|
||||
# target or mode has changed -> redo
|
||||
self._last_target = None
|
||||
return self.start_switch_on
|
||||
@status_code('FINALIZING')
|
||||
def wait_for_switch_off(self, sm):
|
||||
self.persistent_field = self.value
|
||||
self.read_switch_heater()
|
||||
if self.switch_time[OFF] is None:
|
||||
if self.switch_off_time is None:
|
||||
self.log.warning('switch turned on manually?')
|
||||
return self.start_switch_off
|
||||
if state.now - self.switch_time[OFF] < self.wait_switch_off:
|
||||
return Retry()
|
||||
if sm.now - self.switch_off_time < self.wait_switch_off:
|
||||
return Retry
|
||||
if abs(self.value) > self.persistent_limit:
|
||||
self.status = Status.IDLE, 'leads current at field, switch off'
|
||||
return self.finish_state
|
||||
return self.final_status(Status.IDLE, 'leads current at field, switch off')
|
||||
return self.start_ramp_to_zero
|
||||
|
||||
def start_ramp_to_zero(self, state):
|
||||
"""start ramping current to target
|
||||
@status_code('FINALIZING')
|
||||
def start_ramp_to_zero(self, sm):
|
||||
"""start ramping current to zero
|
||||
|
||||
initiate ramp to zero (with corresponding ramp rate)
|
||||
should return ramp_to_zero
|
||||
the implementation should return ramp_to_zero
|
||||
"""
|
||||
raise NotImplementedError
|
||||
|
||||
def ramp_to_zero(self, state):
|
||||
@status_code('FINALIZING')
|
||||
def ramp_to_zero(self, sm):
|
||||
"""ramp field to zero"""
|
||||
if self.target != self._last_target or self.mode == Mode.DRIVEN:
|
||||
# target or mode has changed -> redo
|
||||
self._last_target = None
|
||||
return self.start_field_change
|
||||
if sm.init:
|
||||
self.init_progress(sm, self.current)
|
||||
if abs(self.current) > self.tolerance:
|
||||
if state.init:
|
||||
self.status = Status.FINALIZING, 'ramp leads to zero'
|
||||
return Retry()
|
||||
if self.mode == Mode.DISABLED and self.persistent_field == 0:
|
||||
self.status = Status.DISABLED, 'disabled'
|
||||
else:
|
||||
self.status = Status.IDLE, 'persistent mode'
|
||||
return self.finish_state
|
||||
|
||||
def finish_state(self, state):
|
||||
"""finish"""
|
||||
self.setFastPoll(False)
|
||||
return None
|
||||
if self.get_progress(sm, self.current, self.ramp) > self.leads_ramp_tmo:
|
||||
raise HardwareError('no progress')
|
||||
return Retry
|
||||
if sm.mode == Mode.DISABLED and self.persistent_field == 0:
|
||||
return self.final_status(Status.DISABLED, 'disabled')
|
||||
return self.final_status(Status.IDLE, 'persistent mode')
|
||||
|
||||
Reference in New Issue
Block a user