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

rename Param -> Parameter

Browse Source 
Change-Id: Idcbc440b76219282a888172890673a4d74935dfd
Reviewed-on: https://forge.frm2.tum.de/review/18210
Tested-by: JenkinsCodeReview <bjoern_pedersen@frm2.tum.de>
Reviewed-by: Enrico Faulhaber <enrico.faulhaber@frm2.tum.de>
This commit is contained in:
Enrico Faulhaber 2018-06-19 13:53:04 +02:00
parent 82caa33a5e
commit 22645b449b
11 changed files with 157 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
secop/gui/paramview.py
View File

@ -45,11 +45,11 @@ class ParameterView(QWidget):
self._propWidgets = {} # widget cache do avoid garbage collection self._propWidgets = {} # widget cache do avoid garbage collection
self.paramNameLabel.setText("%s:%s" % (module, parameter)) self.paramNameLabel.setText("%s:%s" % (module, parameter))
self._initParamWidgets() self._initParameterWidgets()
# self._node.newData.connect(self._updateValue) # self._node.newData.connect(self._updateValue)
def _initParamWidgets(self): def _initParameterWidgets(self):
# initValues = self._node.queryCache(self._module) #? mix live data? # initValues = self._node.queryCache(self._module) #? mix live data?
row = 0 row = 0

64
secop/modules.py
View File

@ -59,7 +59,7 @@ from secop.datatypes import DataType, EnumType, TupleOf, StringType, FloatRange,
EVENT_ONLY_ON_CHANGED_VALUES = False EVENT_ONLY_ON_CHANGED_VALUES = False
class Param(object): class Parameter(object):
"""storage for Parameter settings + value + qualifiers """storage for Parameter settings + value + qualifiers
if readonly is False, the value can be changed (by code, or remote) if readonly is False, the value can be changed (by code, or remote)
@ -85,7 +85,9 @@ class Param(object):
group='', group='',
poll=False, poll=False,
value=unset_value, value=unset_value,
timestamp=0): timestamp=0,
optional=False,
ctr=None):
if not isinstance(datatype, DataType): if not isinstance(datatype, DataType):
if issubclass(datatype, DataType): if issubclass(datatype, DataType):
# goodie: make an instance from a class (forgotten ()???) # goodie: make an instance from a class (forgotten ()???)
@ -100,6 +102,7 @@ class Param(object):
self.readonly = readonly self.readonly = readonly
self.export = export self.export = export
self.group = group self.group = group
self.optional = optional
# note: auto-converts True/False to 1/0 which yield the expected # note: auto-converts True/False to 1/0 which yield the expected
# behaviour... # behaviour...
@ -114,7 +117,7 @@ class Param(object):
def copy(self): def copy(self):
# return a copy of ourselfs # return a copy of ourselfs
return Param(**self.__dict__) return Parameter(**self.__dict__)
def for_export(self): def for_export(self):
# used for serialisation only # used for serialisation only
@ -134,7 +137,7 @@ class Param(object):
class Override(object): class Override(object):
"""Stores the overrides to ba applied to a Param """Stores the overrides to ba applied to a Parameter
note: overrides are applied by the metaclass during class creating note: overrides are applied by the metaclass during class creating
""" """
@ -142,7 +145,7 @@ class Override(object):
self.kwds = kwds self.kwds = kwds
def apply(self, paramobj): def apply(self, paramobj):
if isinstance(paramobj, Param): if isinstance(paramobj, Parameter):
for k, v in self.kwds.items(): for k, v in self.kwds.items():
if hasattr(paramobj, k): if hasattr(paramobj, k):
setattr(paramobj, k, v) setattr(paramobj, k, v)
@ -153,20 +156,22 @@ class Override(object):
(k, v, paramobj)) (k, v, paramobj))
else: else:
raise ProgrammingError( raise ProgrammingError(
"Overrides can only be applied to Param's, %r is none!" % "Overrides can only be applied to Parameter's, %r is none!" %
paramobj) paramobj)
class Command(object): class Command(object):
"""storage for Commands settings (description + call signature...) """storage for Commands settings (description + call signature...)
""" """
def __init__(self, description, arguments=None, result=None): def __init__(self, description, arguments=None, result=None, optional=False):
# descriptive text for humans # descriptive text for humans
self.description = description self.description = description
# list of datatypes for arguments # list of datatypes for arguments
self.arguments = arguments or [] self.arguments = arguments or []
# datatype for result # datatype for result
self.resulttype = result self.resulttype = result
# whether implementation is optional
self.optional = optional
def __repr__(self): def __repr__(self):
return '%s(%s)' % (self.__class__.__name__, ', '.join( return '%s(%s)' % (self.__class__.__name__, ', '.join(
@ -198,7 +203,7 @@ class ModuleMeta(type):
if '__constructed__' in attrs: if '__constructed__' in attrs:
return newtype return newtype
# merge properties, Param and commands from all sub-classes # merge properties, Parameter and commands from all sub-classes
for entry in ['properties', 'parameters', 'commands']: for entry in ['properties', 'parameters', 'commands']:
newentry = {} newentry = {}
for base in reversed(bases): for base in reversed(bases):
@ -221,12 +226,12 @@ class ModuleMeta(type):
if isinstance(v.datatype, EnumType) and not v.datatype._enum.name: if isinstance(v.datatype, EnumType) and not v.datatype._enum.name:
v.datatype._enum.name = k v.datatype._enum.name = k
# check validity of Param entries # check validity of Parameter entries
for pname, pobj in newtype.parameters.items(): for pname, pobj in newtype.parameters.items():
# XXX: allow dicts for overriding certain aspects only. # XXX: allow dicts for overriding certain aspects only.
if not isinstance(pobj, Param): if not isinstance(pobj, Parameter):
raise ProgrammingError('%r: Params entry %r should be a ' raise ProgrammingError('%r: Parameters entry %r should be a '
'Param object!' % (name, pname)) 'Parameter object!' % (name, pname))
# XXX: create getters for the units of params ?? # XXX: create getters for the units of params ??
@ -409,7 +414,7 @@ class Module(object):
'not unterstood! (use one of %s)' % 'not unterstood! (use one of %s)' %
(self.name, k, ', '.join(self.parameters))) (self.name, k, ', '.join(self.parameters)))
# complain if a Param entry has no default value and # complain if a Parameter entry has no default value and
# is not specified in cfgdict # is not specified in cfgdict
for k, v in self.parameters.items(): for k, v in self.parameters.items():
if k not in cfgdict: if k not in cfgdict:
@ -421,7 +426,7 @@ class Module(object):
# assume default value was given # assume default value was given
cfgdict[k] = v.default cfgdict[k] = v.default
# replace CLASS level Param objects with INSTANCE level ones # replace CLASS level Parameter objects with INSTANCE level ones
# self.parameters[k] = self.parameters[k].copy() # already done above... # self.parameters[k] = self.parameters[k].copy() # already done above...
# now 'apply' config: # now 'apply' config:
@ -468,14 +473,19 @@ class Readable(Module):
UNKNOWN = 900, UNKNOWN = 900,
) )
parameters = { parameters = {
'value': Param('current value of the Module', readonly=True, default=0., 'value': Parameter('current value of the Module', readonly=True,
datatype=FloatRange(), unit='', poll=True), default=0., datatype=FloatRange(),
'pollinterval': Param('sleeptime between polls', default=5, unit='', poll=True,
readonly=False, datatype=FloatRange(0.1, 120), ), ),
'status': Param('current status of the Module', 'pollinterval': Parameter('sleeptime between polls', default=5,
default=(Status.IDLE, ''), readonly=False,
datatype=TupleOf(EnumType(Status), StringType()), datatype=FloatRange(0.1, 120),
readonly=True, poll=True), ),
'status': Parameter('current status of the Module',
default=(Status.IDLE, ''),
datatype=TupleOf(EnumType(Status), StringType()),
readonly=True, poll=True,
),
} }
def init(self): def init(self):
@ -522,14 +532,10 @@ class Writable(Readable):
providing a settable 'target' parameter to those of a Readable providing a settable 'target' parameter to those of a Readable
""" """
parameters = { parameters = {
'target': Param( 'target': Parameter('target value of the Module',
'target value of the Module', default=0., readonly=False, datatype=FloatRange(),
default=0., ),
readonly=False,
datatype=FloatRange(),
),
} }
# XXX: commands ???? auto deriving working well enough?
class Drivable(Writable): class Drivable(Writable):

16
secop/protocol/dispatcher.py
View File

@ -43,7 +43,7 @@ import threading
from secop.protocol.messages import Message, EVENTREPLY, IDENTREQUEST from secop.protocol.messages import Message, EVENTREPLY, IDENTREQUEST
from secop.protocol.errors import SECOPError, NoSuchModuleError, \ from secop.protocol.errors import SECOPError, NoSuchModuleError, \
NoSuchCommandError, NoSuchParamError, BadValueError, ReadonlyError NoSuchCommandError, NoSuchParameterError, BadValueError, ReadonlyError
from secop.lib import formatExtendedStack, formatException from secop.lib import formatExtendedStack, formatException
try: try:
@ -223,14 +223,14 @@ class Dispatcher(object):
res = func(*arguments) res = func(*arguments)
return res, dict(t=currenttime()) return res, dict(t=currenttime())
def _setParamValue(self, modulename, pname, value): def _setParameterValue(self, modulename, pname, value):
moduleobj = self.get_module(modulename) moduleobj = self.get_module(modulename)
if moduleobj is None: if moduleobj is None:
raise NoSuchModuleError(module=modulename) raise NoSuchModuleError(module=modulename)
pobj = moduleobj.parameters.get(pname, None) pobj = moduleobj.parameters.get(pname, None)
if pobj is None: if pobj is None:
raise NoSuchParamError(module=modulename, parameter=pname) raise NoSuchParameterError(module=modulename, parameter=pname)
if pobj.readonly: if pobj.readonly:
raise ReadonlyError(module=modulename, parameter=pname) raise ReadonlyError(module=modulename, parameter=pname)
@ -244,14 +244,14 @@ class Dispatcher(object):
return pobj.export_value(), dict(t=pobj.timestamp) return pobj.export_value(), dict(t=pobj.timestamp)
return pobj.export_value(), {} return pobj.export_value(), {}
def _getParamValue(self, modulename, pname): def _getParameterValue(self, modulename, pname):
moduleobj = self.get_module(modulename) moduleobj = self.get_module(modulename)
if moduleobj is None: if moduleobj is None:
raise NoSuchModuleError(module=modulename) raise NoSuchModuleError(module=modulename)
pobj = moduleobj.parameters.get(pname, None) pobj = moduleobj.parameters.get(pname, None)
if pobj is None: if pobj is None:
raise NoSuchParamError(module=modulename, parameter=pname) raise NoSuchParameterError(module=modulename, parameter=pname)
readfunc = getattr(moduleobj, u'read_%s' % pname, None) readfunc = getattr(moduleobj, u'read_%s' % pname, None)
if readfunc: if readfunc:
@ -335,7 +335,7 @@ class Dispatcher(object):
# XXX: trigger polling and force sending event # XXX: trigger polling and force sending event
if not msg.parameter: if not msg.parameter:
msg.parameter = u'value' msg.parameter = u'value'
msg.set_result(*self._getParamValue(msg.module, msg.parameter)) msg.set_result(*self._getParameterValue(msg.module, msg.parameter))
#if conn in self._active_connections: #if conn in self._active_connections:
# return None # already send to myself # return None # already send to myself
@ -349,7 +349,7 @@ class Dispatcher(object):
# just return the reply in that case # just return the reply in that case
if not msg.parameter: if not msg.parameter:
msg.parameter = u'target' msg.parameter = u'target'
msg.set_result(*self._setParamValue(msg.module, msg.parameter, msg.data)) msg.set_result(*self._setParameterValue(msg.module, msg.parameter, msg.data))
#if conn in self._active_connections: #if conn in self._active_connections:
# return None # already send to myself # return None # already send to myself
@ -403,7 +403,7 @@ class Dispatcher(object):
# XXX: should we send the cached values instead? (pbj.value) # XXX: should we send the cached values instead? (pbj.value)
# also: ignore errors here. # also: ignore errors here.
try: try:
res = self._getParamValue(modulename, pname) res = self._getParameterValue(modulename, pname)
if res[0] == Ellipsis: # means we do not have a value at all so skip this if res[0] == Ellipsis: # means we do not have a value at all so skip this
self.log.error( self.log.error(
u'activate: got no value for %s:%s!' % u'activate: got no value for %s:%s!' %

4
secop/protocol/errors.py
View File

@ -57,7 +57,7 @@ class NoSuchModuleError(SECOPError):
pass pass
class NoSuchParamError(SECOPError): class NoSuchParameterError(SECOPError):
pass pass
@ -100,7 +100,7 @@ class DisabledError(SECOPError):
EXCEPTIONS = dict( EXCEPTIONS = dict(
NoSuchModule=NoSuchModuleError, NoSuchModule=NoSuchModuleError,
NoSuchParam=NoSuchParamError, NoSuchParameter=NoSuchParameterError,
NoSuchCommand=NoSuchCommandError, NoSuchCommand=NoSuchCommandError,
CommandFailed=CommandFailedError, CommandFailed=CommandFailedError,
CommandRunning=CommandRunningError, CommandRunning=CommandRunningError,

4
secop/simulation.py
View File

@ -24,7 +24,7 @@
import random import random
from time import sleep from time import sleep
from secop.modules import Module, Readable, Writable, Drivable, Param from secop.modules import Module, Readable, Writable, Drivable, Parameter
from secop.lib import mkthread from secop.lib import mkthread
from secop.datatypes import FloatRange from secop.datatypes import FloatRange
@ -42,7 +42,7 @@ class SimBase(object):
self.parameters = dict((k, v.copy()) for k, v in self.parameters.items()) self.parameters = dict((k, v.copy()) for k, v in self.parameters.items())
for k in extra_params.split(','): for k in extra_params.split(','):
k = k.strip() k = k.strip()
self.parameters[k] = Param('extra_param: %s' % k.strip(), self.parameters[k] = Parameter('extra_param: %s' % k.strip(),
datatype=FloatRange(), datatype=FloatRange(),
default=0.0) default=0.0)
def reader(maxage=0, pname=k): def reader(maxage=0, pname=k):

40
secop_demo/cryo.py
View File

@ -24,7 +24,7 @@ from math import atan
import time import time
import random import random
from secop.modules import Drivable, Command, Param from secop.modules import Drivable, Command, Parameter
from secop.datatypes import FloatRange, EnumType, TupleOf from secop.datatypes import FloatRange, EnumType, TupleOf
from secop.lib import clamp, mkthread from secop.lib import clamp, mkthread
@ -41,82 +41,82 @@ class Cryostat(CryoBase):
- thermal transfer between regulation and samplen - thermal transfer between regulation and samplen
""" """
parameters = dict( parameters = dict(
jitter=Param("amount of random noise on readout values", jitter=Parameter("amount of random noise on readout values",
datatype=FloatRange(0, 1), unit="K", datatype=FloatRange(0, 1), unit="K",
default=0.1, readonly=False, export=False, default=0.1, readonly=False, export=False,
), ),
T_start=Param("starting temperature for simulation", T_start=Parameter("starting temperature for simulation",
datatype=FloatRange(0), default=10, datatype=FloatRange(0), default=10,
export=False, export=False,
), ),
looptime=Param("timestep for simulation", looptime=Parameter("timestep for simulation",
datatype=FloatRange(0.01, 10), unit="s", default=1, datatype=FloatRange(0.01, 10), unit="s", default=1,
readonly=False, export=False, readonly=False, export=False,
), ),
ramp=Param("ramping speed of the setpoint", ramp=Parameter("ramping speed of the setpoint",
datatype=FloatRange(0, 1e3), unit="K/min", default=1, datatype=FloatRange(0, 1e3), unit="K/min", default=1,
readonly=False, readonly=False,
), ),
setpoint=Param("current setpoint during ramping else target", setpoint=Parameter("current setpoint during ramping else target",
datatype=FloatRange(), default=1, unit='K', datatype=FloatRange(), default=1, unit='K',
), ),
maxpower=Param("Maximum heater power", maxpower=Parameter("Maximum heater power",
datatype=FloatRange(0), default=1, unit="W", datatype=FloatRange(0), default=1, unit="W",
readonly=False, readonly=False,
group='heater_settings', group='heater_settings',
), ),
heater=Param("current heater setting", heater=Parameter("current heater setting",
datatype=FloatRange(0, 100), default=0, unit="%", datatype=FloatRange(0, 100), default=0, unit="%",
group='heater_settings', group='heater_settings',
), ),
heaterpower=Param("current heater power", heaterpower=Parameter("current heater power",
datatype=FloatRange(0), default=0, unit="W", datatype=FloatRange(0), default=0, unit="W",
group='heater_settings', group='heater_settings',
), ),
target=Param("target temperature", target=Parameter("target temperature",
datatype=FloatRange(0), default=0, unit="K", datatype=FloatRange(0), default=0, unit="K",
readonly=False, readonly=False,
), ),
value=Param("regulation temperature", value=Parameter("regulation temperature",
datatype=FloatRange(0), default=0, unit="K", datatype=FloatRange(0), default=0, unit="K",
), ),
pid=Param("regulation coefficients", pid=Parameter("regulation coefficients",
datatype=TupleOf(FloatRange(0), FloatRange(0, 100), datatype=TupleOf(FloatRange(0), FloatRange(0, 100),
FloatRange(0, 100)), FloatRange(0, 100)),
default=(40, 10, 2), readonly=False, default=(40, 10, 2), readonly=False,
group='pid', group='pid',
), ),
p=Param("regulation coefficient 'p'", p=Parameter("regulation coefficient 'p'",
datatype=FloatRange(0), default=40, unit="%/K", readonly=False, datatype=FloatRange(0), default=40, unit="%/K", readonly=False,
group='pid', group='pid',
), ),
i=Param("regulation coefficient 'i'", i=Parameter("regulation coefficient 'i'",
datatype=FloatRange(0, 100), default=10, readonly=False, datatype=FloatRange(0, 100), default=10, readonly=False,
group='pid', group='pid',
), ),
d=Param("regulation coefficient 'd'", d=Parameter("regulation coefficient 'd'",
datatype=FloatRange(0, 100), default=2, readonly=False, datatype=FloatRange(0, 100), default=2, readonly=False,
group='pid', group='pid',
), ),
mode=Param("mode of regulation", mode=Parameter("mode of regulation",
datatype=EnumType('mode', ramp=None, pid=None, openloop=None), datatype=EnumType('mode', ramp=None, pid=None, openloop=None),
default='ramp', default='ramp',
readonly=False, readonly=False,
), ),
pollinterval=Param("polling interval", pollinterval=Parameter("polling interval",
datatype=FloatRange(0), default=5, datatype=FloatRange(0), default=5,
), ),
tolerance=Param("temperature range for stability checking", tolerance=Parameter("temperature range for stability checking",
datatype=FloatRange(0, 100), default=0.1, unit='K', datatype=FloatRange(0, 100), default=0.1, unit='K',
readonly=False, readonly=False,
group='stability', group='stability',
), ),
window=Param("time window for stability checking", window=Parameter("time window for stability checking",
datatype=FloatRange(1, 900), default=30, unit='s', datatype=FloatRange(1, 900), default=30, unit='s',
readonly=False, readonly=False,
group='stability', group='stability',
), ),
timeout=Param("max waiting time for stabilisation check", timeout=Parameter("max waiting time for stabilisation check",
datatype=FloatRange(1, 36000), default=900, unit='s', datatype=FloatRange(1, 36000), default=900, unit='s',
readonly=False, readonly=False,
group='stability', group='stability',

52
secop_demo/modules.py
View File

@ -25,7 +25,7 @@ import random
import threading import threading
from secop.lib.enum import Enum from secop.lib.enum import Enum
from secop.modules import Readable, Drivable, Param from secop.modules import Readable, Drivable, Parameter
from secop.datatypes import EnumType, FloatRange, IntRange, ArrayOf, StringType, TupleOf, StructOf, BoolType from secop.datatypes import EnumType, FloatRange, IntRange, ArrayOf, StringType, TupleOf, StructOf, BoolType
@ -33,18 +33,18 @@ class Switch(Drivable):
"""switch it on or off.... """switch it on or off....
""" """
parameters = { parameters = {
'value': Param('current state (on or off)', 'value': Parameter('current state (on or off)',
datatype=EnumType(on=1, off=0), default=0, datatype=EnumType(on=1, off=0), default=0,
), ),
'target': Param('wanted state (on or off)', 'target': Parameter('wanted state (on or off)',
datatype=EnumType(on=1, off=0), default=0, datatype=EnumType(on=1, off=0), default=0,
readonly=False, readonly=False,
), ),
'switch_on_time': Param('seconds to wait after activating the switch', 'switch_on_time': Parameter('seconds to wait after activating the switch',
datatype=FloatRange(0, 60), unit='s', datatype=FloatRange(0, 60), unit='s',
default=10, export=False, default=10, export=False,
), ),
'switch_off_time': Param('cool-down time in seconds', 'switch_off_time': Parameter('cool-down time in seconds',
datatype=FloatRange(0, 60), unit='s', datatype=FloatRange(0, 60), unit='s',
default=10, export=False, default=10, export=False,
), ),
@ -95,22 +95,22 @@ class MagneticField(Drivable):
"""a liquid magnet """a liquid magnet
""" """
parameters = { parameters = {
'value': Param('current field in T', 'value': Parameter('current field in T',
unit='T', datatype=FloatRange(-15, 15), default=0, unit='T', datatype=FloatRange(-15, 15), default=0,
), ),
'target': Param('target field in T', 'target': Parameter('target field in T',
unit='T', datatype=FloatRange(-15, 15), default=0, unit='T', datatype=FloatRange(-15, 15), default=0,
readonly=False, readonly=False,
), ),
'ramp': Param('ramping speed', 'ramp': Parameter('ramping speed',
unit='T/min', datatype=FloatRange(0, 1), default=0.1, unit='T/min', datatype=FloatRange(0, 1), default=0.1,
readonly=False, readonly=False,
), ),
'mode': Param('what to do after changing field', 'mode': Parameter('what to do after changing field',
default=1, datatype=EnumType(persistent=1, hold=0), default=1, datatype=EnumType(persistent=1, hold=0),
readonly=False, readonly=False,
), ),
'heatswitch': Param('name of heat switch device', 'heatswitch': Parameter('name of heat switch device',
datatype=StringType(), export=False, datatype=StringType(), export=False,
), ),
} }
@ -183,10 +183,10 @@ class CoilTemp(Readable):
"""a coil temperature """a coil temperature
""" """
parameters = { parameters = {
'value': Param('Coil temperatur', 'value': Parameter('Coil temperatur',
unit='K', datatype=FloatRange(), default=0, unit='K', datatype=FloatRange(), default=0,
), ),
'sensor': Param("Sensor number or calibration id", 'sensor': Parameter("Sensor number or calibration id",
datatype=StringType(), readonly=True, datatype=StringType(), readonly=True,
), ),
} }
@ -199,13 +199,13 @@ class SampleTemp(Drivable):
"""a sample temperature """a sample temperature
""" """
parameters = { parameters = {
'value': Param('Sample temperature', 'value': Parameter('Sample temperature',
unit='K', datatype=FloatRange(), default=10, unit='K', datatype=FloatRange(), default=10,
), ),
'sensor': Param("Sensor number or calibration id", 'sensor': Parameter("Sensor number or calibration id",
datatype=StringType(), readonly=True, datatype=StringType(), readonly=True,
), ),
'ramp': Param('moving speed in K/min', 'ramp': Parameter('moving speed in K/min',
datatype=FloatRange(0, 100), unit='K/min', default=0.1, datatype=FloatRange(0, 100), unit='K/min', default=0.1,
readonly=False, readonly=False,
), ),
@ -246,16 +246,16 @@ class Label(Readable):
modules. modules.
""" """
parameters = { parameters = {
'system': Param("Name of the magnet system", 'system': Parameter("Name of the magnet system",
datatype=StringType, export=False, datatype=StringType, export=False,
), ),
'subdev_mf': Param("name of subdevice for magnet status", 'subdev_mf': Parameter("name of subdevice for magnet status",
datatype=StringType, export=False, datatype=StringType, export=False,
), ),
'subdev_ts': Param("name of subdevice for sample temp", 'subdev_ts': Parameter("name of subdevice for sample temp",
datatype=StringType, export=False, datatype=StringType, export=False,
), ),
'value': Param("final value of label string", 'value': Parameter("final value of label string",
datatype=StringType, datatype=StringType,
), ),
} }
@ -291,20 +291,20 @@ class DatatypesTest(Readable):
"""for demoing all datatypes """for demoing all datatypes
""" """
parameters = { parameters = {
'enum': Param('enum', datatype=EnumType(boo=None, faar=None, z=9), 'enum': Parameter('enum', datatype=EnumType(boo=None, faar=None, z=9),
readonly=False, default=1), readonly=False, default=1),
'tupleof': Param('tuple of int, float and str', 'tupleof': Parameter('tuple of int, float and str',
datatype=TupleOf(IntRange(), FloatRange(), datatype=TupleOf(IntRange(), FloatRange(),
StringType()), StringType()),
readonly=False, default=(1, 2.3, 'a')), readonly=False, default=(1, 2.3, 'a')),
'arrayof': Param('array: 2..3 times bool', 'arrayof': Parameter('array: 2..3 times bool',
datatype=ArrayOf(BoolType(), 2, 3), datatype=ArrayOf(BoolType(), 2, 3),
readonly=False, default=[1, 0, 1]), readonly=False, default=[1, 0, 1]),
'intrange': Param('intrange', datatype=IntRange(2, 9), 'intrange': Parameter('intrange', datatype=IntRange(2, 9),
readonly=False, default=4), readonly=False, default=4),
'floatrange': Param('floatrange', datatype=FloatRange(-1, 1), 'floatrange': Parameter('floatrange', datatype=FloatRange(-1, 1),
readonly=False, default=0, ), readonly=False, default=0, ),
'struct': Param('struct(a=str, b=int, c=bool)', 'struct': Parameter('struct(a=str, b=int, c=bool)',
datatype=StructOf(a=StringType(), b=IntRange(), datatype=StructOf(a=StringType(), b=IntRange(),
c=BoolType()), c=BoolType()),
), ),
@ -313,6 +313,6 @@ class DatatypesTest(Readable):
class ArrayTest(Readable): class ArrayTest(Readable):
parameters = { parameters = {
"x": Param('value', datatype=ArrayOf(FloatRange(), 100000, 100000), "x": Parameter('value', datatype=ArrayOf(FloatRange(), 100000, 100000),
default = 100000 * [0]), default = 100000 * [0]),
} }

8
secop_demo/test.py
View File

@ -22,7 +22,7 @@
import random import random
from secop.modules import Readable, Drivable, Communicator, Param from secop.modules import Readable, Drivable, Communicator, Parameter
from secop.datatypes import FloatRange, StringType from secop.datatypes import FloatRange, StringType
@ -44,7 +44,7 @@ class Heater(Drivable):
but the implementation may do anything but the implementation may do anything
""" """
parameters = { parameters = {
'maxheaterpower': Param('maximum allowed heater power', 'maxheaterpower': Parameter('maximum allowed heater power',
datatype=FloatRange(0, 100), unit='W', datatype=FloatRange(0, 100), unit='W',
), ),
} }
@ -63,14 +63,14 @@ class Temp(Drivable):
but the implementation may do anything but the implementation may do anything
""" """
parameters = { parameters = {
'sensor': Param( 'sensor': Parameter(
"Sensor number or calibration id", "Sensor number or calibration id",
datatype=StringType( datatype=StringType(
8, 8,
16), 16),
readonly=True, readonly=True,
), ),
'target': Param( 'target': Parameter(
"Target temperature", "Target temperature",
default=300.0, default=300.0,
datatype=FloatRange(0), datatype=FloatRange(0),

28
secop_ess/epics.py
View File

@ -23,7 +23,7 @@
from __future__ import absolute_import from __future__ import absolute_import
from secop.datatypes import EnumType, FloatRange, StringType from secop.datatypes import EnumType, FloatRange, StringType
from secop.modules import Readable, Drivable, Param from secop.modules import Readable, Drivable, Parameter
try: try:
from pvaccess import Channel # import EPIVSv4 functionallity, PV access from pvaccess import Channel # import EPIVSv4 functionallity, PV access
@ -60,16 +60,16 @@ class EpicsReadable(Readable):
"""EpicsDrivable handles a Drivable interfacing to EPICS v4""" """EpicsDrivable handles a Drivable interfacing to EPICS v4"""
# Commmon parameter for all EPICS devices # Commmon parameter for all EPICS devices
parameters = { parameters = {
'value': Param('EPICS generic value', 'value': Parameter('EPICS generic value',
datatype=FloatRange(), datatype=FloatRange(),
default=300.0,), default=300.0,),
'epics_version': Param("EPICS version used, v3 or v4", 'epics_version': Parameter("EPICS version used, v3 or v4",
datatype=EnumType(v3=3, v4=4),), datatype=EnumType(v3=3, v4=4),),
# 'private' parameters: not remotely accessible # 'private' parameters: not remotely accessible
'value_pv': Param('EPICS pv_name of value', 'value_pv': Parameter('EPICS pv_name of value',
datatype=StringType(), datatype=StringType(),
default="unset", export=False), default="unset", export=False),
'status_pv': Param('EPICS pv_name of status', 'status_pv': Parameter('EPICS pv_name of status',
datatype=StringType(), datatype=StringType(),
default="unset", export=False), default="unset", export=False),
} }
@ -120,18 +120,18 @@ class EpicsDrivable(Drivable):
"""EpicsDrivable handles a Drivable interfacing to EPICS v4""" """EpicsDrivable handles a Drivable interfacing to EPICS v4"""
# Commmon parameter for all EPICS devices # Commmon parameter for all EPICS devices
parameters = { parameters = {
'target': Param('EPICS generic target', datatype=FloatRange(), 'target': Parameter('EPICS generic target', datatype=FloatRange(),
default=300.0, readonly=False), default=300.0, readonly=False),
'value': Param('EPICS generic value', datatype=FloatRange(), 'value': Parameter('EPICS generic value', datatype=FloatRange(),
default=300.0,), default=300.0,),
'epics_version': Param("EPICS version used, v3 or v4", 'epics_version': Parameter("EPICS version used, v3 or v4",
datatype=StringType(),), datatype=StringType(),),
# 'private' parameters: not remotely accessible # 'private' parameters: not remotely accessible
'target_pv': Param('EPICS pv_name of target', datatype=StringType(), 'target_pv': Parameter('EPICS pv_name of target', datatype=StringType(),
default="unset", export=False), default="unset", export=False),
'value_pv': Param('EPICS pv_name of value', datatype=StringType(), 'value_pv': Parameter('EPICS pv_name of value', datatype=StringType(),
default="unset", export=False), default="unset", export=False),
'status_pv': Param('EPICS pv_name of status', datatype=StringType(), 'status_pv': Parameter('EPICS pv_name of status', datatype=StringType(),
default="unset", export=False), default="unset", export=False),
} }
@ -194,13 +194,13 @@ class EpicsTempCtrl(EpicsDrivable):
parameters = { parameters = {
# TODO: restrict possible values with oneof datatype # TODO: restrict possible values with oneof datatype
'heaterrange': Param('Heater range', datatype=StringType(), 'heaterrange': Parameter('Heater range', datatype=StringType(),
default='Off', readonly=False,), default='Off', readonly=False,),
'tolerance': Param('allowed deviation between value and target', 'tolerance': Parameter('allowed deviation between value and target',
datatype=FloatRange(1e-6, 1e6), default=0.1, datatype=FloatRange(1e-6, 1e6), default=0.1,
readonly=False,), readonly=False,),
# 'private' parameters: not remotely accessible # 'private' parameters: not remotely accessible
'heaterrange_pv': Param('EPICS pv_name of heater range', 'heaterrange_pv': Parameter('EPICS pv_name of heater range',
datatype=StringType(), default="unset", export=False,), datatype=StringType(), default="unset", export=False,),
} }

22
secop_mlz/amagnet.py
View File

@ -30,7 +30,7 @@ import math
from secop.lib.sequence import SequencerMixin, Step from secop.lib.sequence import SequencerMixin, Step
from secop.datatypes import StringType, TupleOf, FloatRange, ArrayOf, StructOf from secop.datatypes import StringType, TupleOf, FloatRange, ArrayOf, StructOf
from secop.errors import DisabledError, ConfigError from secop.errors import DisabledError, ConfigError
from secop.modules import Param, Drivable from secop.modules import Parameter, Drivable
class GarfieldMagnet(SequencerMixin, Drivable): class GarfieldMagnet(SequencerMixin, Drivable):
@ -47,30 +47,30 @@ class GarfieldMagnet(SequencerMixin, Drivable):
""" """
parameters = { parameters = {
'subdev_currentsource': Param('(bipolar) Powersupply', datatype=StringType(), readonly=True, export=False), 'subdev_currentsource': Parameter('(bipolar) Powersupply', datatype=StringType(), readonly=True, export=False),
'subdev_enable': Param('Switch to set for on/off', datatype=StringType(), readonly=True, export=False), 'subdev_enable': Parameter('Switch to set for on/off', datatype=StringType(), readonly=True, export=False),
'subdev_polswitch': Param('Switch to set for polarity', datatype=StringType(), readonly=True, export=False), 'subdev_polswitch': Parameter('Switch to set for polarity', datatype=StringType(), readonly=True, export=False),
'subdev_symmetry': Param('Switch to read for symmetry', datatype=StringType(), readonly=True, export=False), 'subdev_symmetry': Parameter('Switch to read for symmetry', datatype=StringType(), readonly=True, export=False),
'userlimits': Param('User defined limits of device value', 'userlimits': Parameter('User defined limits of device value',
unit='main', datatype=TupleOf(FloatRange(), FloatRange()), unit='main', datatype=TupleOf(FloatRange(), FloatRange()),
default=(float('-Inf'), float('+Inf')), readonly=False, poll=10), default=(float('-Inf'), float('+Inf')), readonly=False, poll=10),
'abslimits': Param('Absolute limits of device value', 'abslimits': Parameter('Absolute limits of device value',
unit='main', datatype=TupleOf(FloatRange(), FloatRange()), unit='main', datatype=TupleOf(FloatRange(), FloatRange()),
default=(-0.5, 0.5), poll=True, default=(-0.5, 0.5), poll=True,
), ),
'precision': Param('Precision of the device value (allowed deviation ' 'precision': Parameter('Precision of the device value (allowed deviation '
'of stable values from target)', 'of stable values from target)',
unit='main', datatype=FloatRange(0.001), default=0.001, readonly=False, unit='main', datatype=FloatRange(0.001), default=0.001, readonly=False,
), ),
'ramp': Param('Target rate of field change per minute', readonly=False, 'ramp': Parameter('Target rate of field change per minute', readonly=False,
unit='main/min', datatype=FloatRange(), default=1.0), unit='main/min', datatype=FloatRange(), default=1.0),
'calibration': Param('Coefficients for calibration ' 'calibration': Parameter('Coefficients for calibration '
'function: [c0, c1, c2, c3, c4] calculates ' 'function: [c0, c1, c2, c3, c4] calculates '
'B(I) = c0*I + c1*erf(c2*I) + c3*atan(c4*I)' 'B(I) = c0*I + c1*erf(c2*I) + c3*atan(c4*I)'
' in T', poll=1, ' in T', poll=1,
datatype=ArrayOf(FloatRange(), 5, 5), datatype=ArrayOf(FloatRange(), 5, 5),
default=(1.0, 0.0, 0.0, 0.0, 0.0)), default=(1.0, 0.0, 0.0, 0.0, 0.0)),
'calibrationtable': Param('Map of Coefficients for calibration per symmetry setting', 'calibrationtable': Parameter('Map of Coefficients for calibration per symmetry setting',
datatype=StructOf(symmetric=ArrayOf(FloatRange(), 5, 5), datatype=StructOf(symmetric=ArrayOf(FloatRange(), 5, 5),
short=ArrayOf( short=ArrayOf(
FloatRange(), 5, 5), FloatRange(), 5, 5),

66
secop_mlz/entangle.py
View File

@ -41,7 +41,7 @@ from secop.datatypes import IntRange, FloatRange, StringType, TupleOf, \
ArrayOf, EnumType ArrayOf, EnumType
from secop.errors import ConfigError, ProgrammingError, CommunicationError, \ from secop.errors import ConfigError, ProgrammingError, CommunicationError, \
HardwareError HardwareError
from secop.modules import Param, Command, Override, Module, Readable, Drivable from secop.modules import Parameter, Command, Override, Module, Readable, Drivable
##### #####
@ -159,14 +159,14 @@ class PyTangoDevice(Module):
""" """
parameters = { parameters = {
'comtries': Param('Maximum retries for communication', 'comtries': Parameter('Maximum retries for communication',
datatype=IntRange(1, 100), default=3, readonly=False, datatype=IntRange(1, 100), default=3, readonly=False,
group='communication'), group='communication'),
'comdelay': Param('Delay between retries', datatype=FloatRange(0), 'comdelay': Parameter('Delay between retries', datatype=FloatRange(0),
unit='s', default=0.1, readonly=False, unit='s', default=0.1, readonly=False,
group='communication'), group='communication'),
'tangodevice': Param('Tango device name', 'tangodevice': Parameter('Tango device name',
datatype=StringType(), readonly=True, datatype=StringType(), readonly=True,
# export=True, # for testing only # export=True, # for testing only
export=False, export=False,
@ -426,25 +426,25 @@ class AnalogOutput(PyTangoDevice, Drivable):
""" """
parameters = { parameters = {
'userlimits': Param('User defined limits of device value', 'userlimits': Parameter('User defined limits of device value',
datatype=TupleOf(FloatRange(), FloatRange()), datatype=TupleOf(FloatRange(), FloatRange()),
default=(float('-Inf'), float('+Inf')), default=(float('-Inf'), float('+Inf')),
unit='main', readonly=False, poll=10, unit='main', readonly=False, poll=10,
), ),
'abslimits': Param('Absolute limits of device value', 'abslimits': Parameter('Absolute limits of device value',
datatype=TupleOf(FloatRange(), FloatRange()), datatype=TupleOf(FloatRange(), FloatRange()),
unit='main', unit='main',
), ),
'precision': Param('Precision of the device value (allowed deviation ' 'precision': Parameter('Precision of the device value (allowed deviation '
'of stable values from target)', 'of stable values from target)',
unit='main', datatype=FloatRange(1e-38), unit='main', datatype=FloatRange(1e-38),
readonly=False, group='stability', readonly=False, group='stability',
), ),
'window': Param('Time window for checking stabilization if > 0', 'window': Parameter('Time window for checking stabilization if > 0',
unit='s', default=60.0, readonly=False, unit='s', default=60.0, readonly=False,
datatype=FloatRange(0, 900), group='stability', datatype=FloatRange(0, 900), group='stability',
), ),
'timeout': Param('Timeout for waiting for a stable value (if > 0)', 'timeout': Parameter('Timeout for waiting for a stable value (if > 0)',
unit='s', default=60.0, readonly=False, unit='s', default=60.0, readonly=False,
datatype=FloatRange(0, 900), group='stability', datatype=FloatRange(0, 900), group='stability',
), ),
@ -599,10 +599,10 @@ class Actuator(AnalogOutput):
# for secop: support the speed and ramp parameters # for secop: support the speed and ramp parameters
parameters = { parameters = {
'speed': Param('The speed of changing the value', 'speed': Parameter('The speed of changing the value',
unit='main/s', readonly=False, datatype=FloatRange(0), unit='main/s', readonly=False, datatype=FloatRange(0),
), ),
'ramp': Param('The speed of changing the value', 'ramp': Parameter('The speed of changing the value',
unit='main/min', readonly=False, datatype=FloatRange(0), unit='main/min', readonly=False, datatype=FloatRange(0),
poll=30, poll=30,
), ),
@ -639,13 +639,13 @@ class Motor(Actuator):
""" """
parameters = { parameters = {
'refpos': Param('Reference position', 'refpos': Parameter('Reference position',
datatype=FloatRange(), unit='main', datatype=FloatRange(), unit='main',
), ),
'accel': Param('Acceleration', 'accel': Parameter('Acceleration',
datatype=FloatRange(), readonly=False, unit='main/s^2', datatype=FloatRange(), readonly=False, unit='main/s^2',
), ),
'decel': Param('Deceleration', 'decel': Parameter('Deceleration',
datatype=FloatRange(), readonly=False, unit='main/s^2', datatype=FloatRange(), readonly=False, unit='main/s^2',
), ),
} }
@ -679,24 +679,24 @@ class TemperatureController(Actuator):
""" """
parameters = { parameters = {
'p': Param('Proportional control Parameter', datatype=FloatRange(), 'p': Parameter('Proportional control Parameter', datatype=FloatRange(),
readonly=False, group='pid', readonly=False, group='pid',
), ),
'i': Param('Integral control Parameter', datatype=FloatRange(), 'i': Parameter('Integral control Parameter', datatype=FloatRange(),
readonly=False, group='pid', readonly=False, group='pid',
), ),
'd': Param('Derivative control Parameter', datatype=FloatRange(), 'd': Parameter('Derivative control Parameter', datatype=FloatRange(),
readonly=False, group='pid', readonly=False, group='pid',
), ),
'pid': Param('pid control Parameters', 'pid': Parameter('pid control Parameters',
datatype=TupleOf(FloatRange(), FloatRange(), FloatRange()), datatype=TupleOf(FloatRange(), FloatRange(), FloatRange()),
readonly=False, group='pid', poll=30, readonly=False, group='pid', poll=30,
), ),
'setpoint': Param('Current setpoint', datatype=FloatRange(), poll=1, 'setpoint': Parameter('Current setpoint', datatype=FloatRange(), poll=1,
), ),
'heateroutput': Param('Heater output', datatype=FloatRange(), poll=1, 'heateroutput': Parameter('Heater output', datatype=FloatRange(), poll=1,
), ),
'ramp': Param('Temperature ramp', unit='main/min', 'ramp': Parameter('Temperature ramp', unit='main/min',
datatype=FloatRange(), readonly=False, poll=30), datatype=FloatRange(), readonly=False, poll=30),
} }
@ -754,11 +754,11 @@ class PowerSupply(Actuator):
""" """
parameters = { parameters = {
'ramp': Param('Current/voltage ramp', unit='main/min', 'ramp': Parameter('Current/voltage ramp', unit='main/min',
datatype=FloatRange(), readonly=False, poll=30,), datatype=FloatRange(), readonly=False, poll=30,),
'voltage': Param('Actual voltage', unit='V', 'voltage': Parameter('Actual voltage', unit='V',
datatype=FloatRange(), poll=-5), datatype=FloatRange(), poll=-5),
'current': Param('Actual current', unit='A', 'current': Parameter('Actual current', unit='A',
datatype=FloatRange(), poll=-5), datatype=FloatRange(), poll=-5),
} }
@ -792,7 +792,7 @@ class NamedDigitalInput(DigitalInput):
""" """
parameters = { parameters = {
'mapping': Param('A dictionary mapping state names to integers', 'mapping': Parameter('A dictionary mapping state names to integers',
datatype=StringType(), export=False), # XXX:!!! datatype=StringType(), export=False), # XXX:!!!
} }
@ -815,9 +815,9 @@ class PartialDigitalInput(NamedDigitalInput):
""" """
parameters = { parameters = {
'startbit': Param('Number of the first bit', 'startbit': Parameter('Number of the first bit',
datatype=IntRange(0), default=0), datatype=IntRange(0), default=0),
'bitwidth': Param('Number of bits', 'bitwidth': Parameter('Number of bits',
datatype=IntRange(0), default=1), datatype=IntRange(0), default=1),
} }
@ -859,7 +859,7 @@ class NamedDigitalOutput(DigitalOutput):
""" """
parameters = { parameters = {
'mapping': Param('A dictionary mapping state names to integers', 'mapping': Parameter('A dictionary mapping state names to integers',
datatype=StringType(), export=False), datatype=StringType(), export=False),
} }
@ -885,9 +885,9 @@ class PartialDigitalOutput(NamedDigitalOutput):
""" """
parameters = { parameters = {
'startbit': Param('Number of the first bit', 'startbit': Parameter('Number of the first bit',
datatype=IntRange(0), default=0), datatype=IntRange(0), default=0),
'bitwidth': Param('Number of bits', 'bitwidth': Parameter('Number of bits',
datatype=IntRange(0), default=1), datatype=IntRange(0), default=1),
} }
@ -916,13 +916,13 @@ class StringIO(PyTangoDevice, Module):
""" """
parameters = { parameters = {
'bustimeout': Param('Communication timeout', 'bustimeout': Parameter('Communication timeout',
datatype=FloatRange(), readonly=False, datatype=FloatRange(), readonly=False,
unit='s', group='communication'), unit='s', group='communication'),
'endofline': Param('End of line', 'endofline': Parameter('End of line',
datatype=StringType(), readonly=False, datatype=StringType(), readonly=False,
group='communication'), group='communication'),
'startofline': Param('Start of line', 'startofline': Parameter('Start of line',
datatype=StringType(), readonly=False, datatype=StringType(), readonly=False,
group='communication'), group='communication'),
} }