linse/frappy
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove 'maxage' argument for read_* methods

Browse Source 
'maxage' is not really used at any place. remove it, as this makes
the code cleaner

Change-Id: I6f10b4ab91fc57640336db1832716ca9012eb241
Reviewed-on: https://forge.frm2.tum.de/review/20347
Tested-by: JenkinsCodeReview <bjoern_pedersen@frm2.tum.de>
Reviewed-by: Enrico Faulhaber <enrico.faulhaber@frm2.tum.de>
Reviewed-by: Markus Zolliker <markus.zolliker@psi.ch>
This commit is contained in:
zolliker 2019-04-09 10:45:45 +02:00
parent fa9e451c54
commit cafc7a1409
10 changed files with 82 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
secop/lib/sequence.py
View File

@ -127,7 +127,7 @@ class SequencerMixin(object):
"""Can be called to check if a sequence is currently running."""
return self._seq_thread and self._seq_thread.isAlive()
def read_status(self, maxage=0):
def read_status(self):
if self.seq_is_alive():
return self.Status.BUSY, u'moving: ' + self._seq_phase
elif self._seq_error:
@ -139,7 +139,7 @@ class SequencerMixin(object):
return self.Status.ERROR, self._seq_stopped
return self.Status.WARN, self._seq_stopped
if hasattr(self, u'read_hw_status'):
return self.read_hw_status(maxage)
return self.read_hw_status()
return self.Status.IDLE, u''
def do_stop(self):

4
secop/metaclass.py
View File

@ -140,11 +140,11 @@ class ModuleMeta(type):
break
rfunc = getattr(base, 'read_' + pname, None)
def wrapped_rfunc(self, maxage=0, pname=pname, rfunc=rfunc):
def wrapped_rfunc(self, pname=pname, rfunc=rfunc):
if rfunc:
self.log.debug("rfunc(%s): call %r" % (pname, rfunc))
try:
value = rfunc(self, maxage)
value = rfunc(self)
except Exception as e:
pobj = self.accessibles[pname]
self.DISPATCHER.announce_update_error(self, pname, pobj, e)

2
secop/modules.py
View File

@ -352,7 +352,7 @@ class Drivable(Writable):
# improved polling: may poll faster if module is BUSY
def pollParams(self, nr=0):
# poll status first
self.read_status(0)
self.read_status()
fastpoll = self.isBusy()
for pname, pobj in self.parameters.items():
if not pobj.poll:

6
secop/simulation.py
View File

@ -47,7 +47,7 @@ class SimBase(object):
self.accessibles[k] = Parameter('extra_param: %s' % k.strip(),
datatype=FloatRange(),
default=0.0)
def reader(maxage=0, pname=k):
def reader(pname=k):
self.log.debug('simulated reading %s' % pname)
return self.accessibles[pname].value
setattr(self, 'read_' + k, reader)
@ -71,7 +71,7 @@ class SimBase(object):
def sim(self):
return True
def read_value(self, maxage=0):
def read_value(self):
if 'jitter' in self.accessibles:
return self._value + self.jitter*(0.5-random.random())
return self._value
@ -95,7 +95,7 @@ class SimWritable(SimBase, Writable):
SimBase.__init__(self, cfgdict)
Writable.__init__(self, devname, logger, cfgdict, dispatcher)
self._value = self.accessibles['value'].default
def read_value(self, maxage=0):
def read_value(self):
return self.target
def write_target(self, value):
self.value = value

10
secop_demo/cryo.py
View File

@ -140,16 +140,16 @@ class Cryostat(CryoBase):
self._stopflag = False
self._thread = mkthread(self.thread)
def read_status(self, maxage=0):
def read_status(self):
# instead of asking a 'Hardware' take the value from the simulation
return self.status
def read_value(self, maxage=0):
def read_value(self):
# return regulation value (averaged regulation temp)
return self.regulationtemp + \
self.jitter * (0.5 - random.random())
def read_target(self, maxage=0):
def read_target(self):
return self.target
def write_target(self, value):
@ -162,7 +162,7 @@ class Cryostat(CryoBase):
self.status = self.Status.BUSY, 'new target set'
return value
def read_maxpower(self, maxage=0):
def read_maxpower(self):
return self.maxpower
def write_maxpower(self, newpower):
@ -176,7 +176,7 @@ class Cryostat(CryoBase):
self.p, self.i, self.d = newpid
return (self.p, self.i, self.d)
def read_pid(self, maxage=0):
def read_pid(self):
return (self.p, self.i, self.d)
def do_stop(self):

14
secop_demo/modules.py
View File

@ -53,13 +53,13 @@ class Switch(Drivable):
),
}
def read_value(self, maxage=0):
def read_value(self):
# could ask HW
# we just return the value of the target here.
self._update()
return self.value
def read_target(self, maxage=0):
def read_target(self):
# could ask HW
return self.target
@ -69,7 +69,7 @@ class Switch(Drivable):
# note: setting self.target to the new value is done after this....
# note: we may also return the read-back value from the hw here
def read_status(self, maxage=0):
def read_status(self):
self.log.info("read status")
info = self._update()
if self.target == self.value:
@ -129,7 +129,7 @@ class MagneticField(Drivable):
_thread.daemon = True
_thread.start()
def read_value(self, maxage=0):
def read_value(self):
return self.value
def write_target(self, value):
@ -139,7 +139,7 @@ class MagneticField(Drivable):
# note: setting self.target to the new value is done after this....
# note: we may also return the read-back value from the hw here
def read_status(self, maxage=0):
def read_status(self):
if self._state == self._state.enum.idle:
return (self.Status.PERSIST, 'at field') if self.value else \
(self.Status.IDLE, 'zero field')
@ -206,7 +206,7 @@ class CoilTemp(Readable):
),
}
def read_value(self, maxage=0):
def read_value(self):
return round(2.3 + random.random(), 3)
@ -275,7 +275,7 @@ class Label(Readable):
),
}
def read_value(self, maxage=0):
def read_value(self):
strings = [self.system]
dev_ts = self.DISPATCHER.get_module(self.subdev_ts)

6
secop_demo/test.py
View File

@ -44,7 +44,7 @@ class LN2(Readable):
but the implementation may do anything
"""
def read_value(self, maxage=0):
def read_value(self):
return round(100 * random.random(), 1)
@ -60,7 +60,7 @@ class Heater(Drivable):
),
}
def read_value(self, maxage=0):
def read_value(self):
return round(100 * random.random(), 1)
def write_target(self, target):
@ -90,7 +90,7 @@ class Temp(Drivable):
),
}
def read_value(self, maxage=0):
def read_value(self):
return round(100 * random.random(), 1)
def write_target(self, target):

20
secop_ess/epics.py
View File

@ -103,10 +103,10 @@ class EpicsReadable(Readable):
pv = PV(pv_name + ".VAL")
pv.value = write_value
def read_value(self, maxage=0):
def read_value(self):
return self._read_pv(self.value_pv)
def read_status(self, maxage=0):
def read_status(self):
# XXX: comparison may need to be a little unsharp
# XXX: Hardware may have it's own idea about the status: how to obtain?
if self.status_pv != 'unset':
@ -164,16 +164,16 @@ class EpicsDrivable(Drivable):
pv = PV(pv_name + ".VAL")
pv.value = write_value
def read_target(self, maxage=0):
def read_target(self):
return self._read_pv(self.target_pv)
def write_target(self, write_value):
self._write_pv(self.target_pv, write_value)
def read_value(self, maxage=0):
def read_value(self):
return self._read_pv(self.value_pv)
def read_status(self, maxage=0):
def read_status(self):
# XXX: comparison may need to be a little unsharp
# XXX: Hardware may have it's own idea about the status: how to obtain?
if self.status_pv != 'unset':
@ -204,7 +204,7 @@ class EpicsTempCtrl(EpicsDrivable):
datatype=StringType(), default="unset", export=False,),
}
def read_target(self, maxage=0):
def read_target(self):
return self._read_pv(self.target_pv)
def write_target(self, write_value):
@ -213,19 +213,19 @@ class EpicsTempCtrl(EpicsDrivable):
# update our status
self.read_status()
def read_value(self, maxage=0):
def read_value(self):
return self._read_pv(self.value_pv)
def read_status(self, maxage=0):
def read_status(self):
# XXX: comparison may need to collect a history to detect oscillations
at_target = abs(self.read_value(maxage) - self.read_target(maxage)) \
at_target = abs(self.read_value() - self.read_target()) \
<= self.tolerance
if at_target:
return (Drivable.Status.IDLE, 'at Target')
return (Drivable.Status.BUSY, 'Moving')
# TODO: add support for strings over epics pv
# def read_heaterrange(self, maxage=0):
# def read_heaterrange(self):
# return self._read_pv(self.heaterrange_pv)
# TODO: add support for strings over epics pv

34
secop_mlz/amagnet.py
View File

@ -142,9 +142,9 @@ class GarfieldMagnet(SequencerMixin, Drivable):
self._currentsource = self.DISPATCHER.get_module(
self.subdev_currentsource)
self.init_sequencer(fault_on_error=False, fault_on_stop=False)
self._symmetry.read_value(0)
self._symmetry.read_value()
def read_calibration(self, maxage=0):
def read_calibration(self):
try:
try:
return self.calibrationtable[self._symmetry.value]
@ -175,13 +175,13 @@ class GarfieldMagnet(SequencerMixin, Drivable):
limits = self._checkLimits(value)
return limits
def read_abslimits(self, maxage=0):
def read_abslimits(self):
maxfield = self._current2field(self._currentsource.abslimits[1])
# limit to configured value (if any)
maxfield = min(maxfield, max(self.accessibles['abslimits'].default))
return -maxfield, maxfield
def read_ramp(self, maxage=0):
def read_ramp(self):
# This is an approximation!
return self.calibration[0] * abs(self._currentsource.ramp)
@ -213,26 +213,26 @@ class GarfieldMagnet(SequencerMixin, Drivable):
# unsafe to switch, go to safe state first
self._currentsource.write_target(0)
def read_value(self, maxage=0):
def read_value(self):
return self._current2field(
self._currentsource.read_value(maxage) *
self._currentsource.read_value() *
self._get_field_polarity())
def read_hw_status(self, maxage=0):
def read_hw_status(self):
# called from SequencerMixin.read_status if no sequence is running
if self._enable.value == 'Off':
return self.Status.WARN, 'Disabled'
if self._enable.read_status(maxage)[0] != self.Status.IDLE:
if self._enable.read_status()[0] != self.Status.IDLE:
return self._enable.status
if self._polswitch.value in ['0', 0]:
return self.Status.IDLE, 'Shorted, ' + self._currentsource.status[1]
if self._symmetry.value in ['short', 0]:
return self._currentsource.status[
0], 'Shorted, ' + self._currentsource.status[1]
return self._currentsource.read_status(maxage)
return self._currentsource.read_status()
def write_target(self, target):
if target != 0 and self._symmetry.read_value(0) in ['short', 0]:
if target != 0 and self._symmetry.read_value() in ['short', 0]:
raise DisabledError(
'Symmetry is shorted, please select another symmetry first!')
@ -245,7 +245,7 @@ class GarfieldMagnet(SequencerMixin, Drivable):
seq.append(Step('preparing', 0, self._prepare_ramp))
seq.append(Step('recover', 0, self._recover))
if current_polarity != wanted_polarity:
if self._currentsource.read_value(0) > 0.1:
if self._currentsource.read_value() > 0.1:
# switching only allowed if current is low enough -> ramp down
# first
seq.append(
@ -286,7 +286,7 @@ class GarfieldMagnet(SequencerMixin, Drivable):
def _recover(self, store):
# check for interlock
if self._currentsource.read_status(0)[0] != self.Status.ERROR:
if self._currentsource.read_status()[0] != self.Status.ERROR:
return
# recover from interlock
ramp = self._currentsource.ramp
@ -303,11 +303,11 @@ class GarfieldMagnet(SequencerMixin, Drivable):
def _ramp_current(self, store, target):
if abs(self._currentsource.value - target) <= 0.05:
# done with this step if no longer BUSY
return self._currentsource.read_status(0)[0] == 'BUSY'
return self._currentsource.read_status()[0] == 'BUSY'
if self._currentsource.status[0] != 'BUSY':
if self._enable.status[0] == 'ERROR':
self._enable.do_reset()
self._enable.read_status(0)
self._enable.read_status()
self._enable.write_target('On')
self._enable._hw_wait()
self._currentsource.write_target(target)
@ -316,15 +316,15 @@ class GarfieldMagnet(SequencerMixin, Drivable):
def _ramp_current_cleanup(self, store, step_was_busy, target):
# don't cleanup if step finished
if step_was_busy:
self._currentsource.write_target(self._currentsource.read_value(0))
self._currentsource.write_target(self._currentsource.read_value())
self._currentsource.window = max(store.old_window, 10)
def _set_polarity(self, store, target):
if self._polswitch.read_status(0)[0] == self.Status.BUSY:
if self._polswitch.read_status()[0] == self.Status.BUSY:
return True
if int(self._polswitch.value) == int(target):
return False # done with this step
if self._polswitch.read_value(0) != 0:
if self._polswitch.read_value() != 0:
self._polswitch.write_target(0)
else:
self._polswitch.write_target(target)

64
secop_mlz/entangle.py
View File

@ -229,7 +229,7 @@ class PyTangoDevice(Module):
def _hw_wait(self):
"""Wait until hardware status is not BUSY."""
while self.read_status(0)[0] == Drivable.Status.BUSY:
while self.read_status()[0] == Drivable.Status.BUSY:
sleep(0.3)
def _getProperty(self, name, dev=None):
@ -361,7 +361,7 @@ class PyTangoDevice(Module):
self.log.debug('PyTango error: %s', fulldesc)
raise exclass(self, fulldesc)
def read_status(self, maxage=0):
def read_status(self):
# Query status code and string
tangoState = self._dev.State()
tangoStatus = self._dev.Status()
@ -389,7 +389,7 @@ class AnalogInput(PyTangoDevice, Readable):
if attrInfo.unit != 'No unit':
self.accessibles['value'].unit = attrInfo.unit
def read_value(self, maxage=0):
def read_value(self):
return self._dev.value
@ -481,12 +481,12 @@ class AnalogOutput(PyTangoDevice, Drivable):
# else: remove a stale point
self._history.pop(0)
def read_value(self, maxage=0):
def read_value(self):
value = self._dev.value
self._history.append((currenttime(), value))
return value
def read_target(self, maxage=0):
def read_target(self):
attrObj = self._dev.read_attribute('value')
return attrObj.w_value
@ -511,7 +511,7 @@ class AnalogOutput(PyTangoDevice, Drivable):
return stable and at_target
def read_status(self, maxage=0):
def read_status(self):
if self._isAtTarget():
self._timeout = None
self._moving = False
@ -584,7 +584,7 @@ class AnalogOutput(PyTangoDevice, Drivable):
self._timeout = None
self._moving = True
self._history = [] # clear history
self.read_status(0) # poll our status to keep it updated
self.read_status() # poll our status to keep it updated
def _hw_wait(self):
while super(AnalogOutput, self).read_status()[0] == self.Status.BUSY:
@ -620,18 +620,18 @@ class Actuator(AnalogOutput):
),
}
def read_speed(self, maxage=0):
def read_speed(self):
return self._dev.speed
def write_speed(self, value):
self._dev.speed = value
def read_ramp(self, maxage=0):
def read_ramp(self):
return self.read_speed() * 60
def write_ramp(self, value):
self.write_speed(value / 60.)
return self.read_speed(0) * 60
return self.read_speed() * 60
def do_setposition(self, value=FloatRange()):
self._dev.Adjust(value)
@ -660,16 +660,16 @@ class Motor(Actuator):
'reference': Command('Do a reference run', argument=None, result=None),
}
def read_refpos(self, maxage=0):
def read_refpos(self):
return float(self._getProperty('refpos'))
def read_accel(self, maxage=0):
def read_accel(self):
return self._dev.accel
def write_accel(self, value):
self._dev.accel = value
def read_decel(self, maxage=0):
def read_decel(self):
return self._dev.decel
def write_decel(self, value):
@ -712,32 +712,32 @@ class TemperatureController(Actuator):
'precision': Override(default=0.1),
}
def read_ramp(self, maxage=0):
def read_ramp(self):
return self._dev.ramp
def write_ramp(self, value):
self._dev.ramp = value
return self._dev.ramp
def read_p(self, maxage=0):
def read_p(self):
return self._dev.p
def write_p(self, value):
self._dev.p = value
def read_i(self, maxage=0):
def read_i(self):
return self._dev.i
def write_i(self, value):
self._dev.i = value
def read_d(self, maxage=0):
def read_d(self):
return self._dev.d
def write_d(self, value):
self._dev.d = value
def read_pid(self, maxage=0):
def read_pid(self):
self.read_p()
self.read_i()
self.read_d()
@ -748,10 +748,10 @@ class TemperatureController(Actuator):
self._dev.i = value[1]
self._dev.d = value[2]
def read_setpoint(self, maxage=0):
def read_setpoint(self):
return self._dev.setpoint
def read_heateroutput(self, maxage=0):
def read_heateroutput(self):
return self._dev.heaterOutput
@ -768,16 +768,16 @@ class PowerSupply(Actuator):
datatype=FloatRange(), poll=-5),
}
def read_ramp(self, maxage=0):
def read_ramp(self):
return self._dev.ramp
def write_ramp(self, value):
self._dev.ramp = value
def read_voltage(self, maxage=0):
def read_voltage(self):
return self._dev.voltage
def read_current(self, maxage=0):
def read_current(self):
return self._dev.current
@ -789,7 +789,7 @@ class DigitalInput(PyTangoDevice, Readable):
'value': Override(datatype=IntRange()),
}
def read_value(self, maxage=0):
def read_value(self):
return self._dev.value
@ -810,7 +810,7 @@ class NamedDigitalInput(DigitalInput):
except Exception as e:
raise ValueError('Illegal Value for mapping: %r' % e)
def read_value(self, maxage=0):
def read_value(self):
value = self._dev.value
return value # mapping is done by datatype upon export()
@ -832,7 +832,7 @@ class PartialDigitalInput(NamedDigitalInput):
self._mask = (1 << self.bitwidth) - 1
# self.accessibles['value'].datatype = IntRange(0, self._mask)
def read_value(self, maxage=0):
def read_value(self):
raw_value = self._dev.value
value = (raw_value >> self.startbit) & self._mask
return value # mapping is done by datatype upon export()
@ -848,14 +848,14 @@ class DigitalOutput(PyTangoDevice, Drivable):
'target': Override(datatype=IntRange()),
}
def read_value(self, maxage=0):
def read_value(self):
return self._dev.value # mapping is done by datatype upon export()
def write_target(self, value):
self._dev.value = value
self.read_value()
def read_target(self, maxage=0):
def read_target(self):
attrObj = self._dev.read_attribute('value')
return attrObj.w_value
@ -903,7 +903,7 @@ class PartialDigitalOutput(NamedDigitalOutput):
# self.accessibles['value'].datatype = IntRange(0, self._mask)
# self.accessibles['target'].datatype = IntRange(0, self._mask)
def read_value(self, maxage=0):
def read_value(self):
raw_value = self._dev.value
value = (raw_value >> self.startbit) & self._mask
return value # mapping is done by datatype upon export()
@ -933,19 +933,19 @@ class StringIO(PyTangoDevice, Module):
group='communication'),
}
def read_bustimeout(self, maxage=0):
def read_bustimeout(self):
return self._dev.communicationTimeout
def write_bustimeout(self, value):
self._dev.communicationTimeout = value
def read_endofline(self, maxage=0):
def read_endofline(self):
return self._dev.endOfLine
def write_endofline(self, value):
self._dev.endOfLine = value
def read_startofline(self, maxage=0):
def read_startofline(self):
return self._dev.startOfLine
def write_startofline(self, value):