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
Download Patch File Download Diff File Expand all files Collapse all files

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):