class TuringMachine(Device):
blank_symbol = device_property(dtype=str, default_value=" ")
initial_state = device_property(dtype=str, default_value="init")
def init_device(self):
Device.init_device(self)
self.__tape = {}
self.__head = 0
self.__state = self.initial_state
self.__final_states = []
self.__transition_function = None
self.set_state(DevState.RUNNING)
@attribute(dtype=(str,))
def final_states(self):
return self.__final_states
@final_states.write
def final_states(self, final_states):
self.__final_states = final_states
@attribute(dtype=str)
def transition_function(self):
return self.__transition_function
@transition_function.write
def transition_function(self, func_str):
self.__transition_function = tf = {}
for k, v in json.loads(func_str).items():
tf[tuple(str(k).split(","))] = map(str, v)
print(tf)
@attribute(dtype=str)
def tape(self):
s, keys = "", self.__tape.keys()
min_used, max_used = min(keys), max(keys)
for i in range(min_used, max_used):
s += self.__tape.get(i, self.__blank_symbol)
return s
@command
def step(self):
char_under_head = self.__tape.get(self.__head, self.blank_symbol)
x = self.__state, char_under_head
if x in self.__transition_function:
y = self.__transition_function[x]
self.__tape[self.__head] = y[1]
if y[2] == "R":
self.__head += 1
elif y[2] == "L":
self.__head -= 1
self.__state = y[0]
print(self.__state)
def dev_state(self):
if self.__state in self.__final_states:
return DevState.ON
else:
return DevState.RUNNING
class PowerSupply(Device):
__metaclass__ = DeviceMeta
#attribute voltage only read
voltage = attribute(label="Voltage",
dtype=float,
display_level=DispLevel.OPERATOR,
access=AttrWriteType.READ,
unit="V",
format="8.4f",
doc="the power supply voltage")
#attribute current read and write both
current = attribute(label="Current",
dtype=float,
display_level=DispLevel.EXPERT,
access=AttrWriteType.READ_WRITE,
unit="A",
format="8.4f",
min_value=0.0,
max_value=8.5,
min_alarm=0.1,
max_alarm=8.4,
min_warning=0.5,
max_warning=8.0,
fget="get_current",
fset="set_current",
doc="the power supply current")
host = device_property(dtype=str)
port = device_property(dtype=int, default_value=9788)
def init_device(self):
Device.init_device(self)
self.__current = 0.0
self.set_state(DevState.STANDBY)
def read_voltage(self):
self.info_stream("read_voltage(%s, %d)", self.host, self.port)
return 9.99, time.time(), AttrQuality.ATTR_WARNING
def get_current(self):
return self.__current
def set_current(self, current):
# should set the power supply current
self.__current = current
@command
def TurnOn(self):
self.set_state(DevState.ON)
@command
def TurnOff(self):
# turn off the actual power supply here
self.set_state(DevState.OFF)
class TangoEspARS(Device):
__metaclass__ = DeviceMeta
host = device_property(dtype=str, doc="Host name or IP of the esp8266")
port = device_property(dtype=int, doc="socket port", default_value=23)
def init_device(self):
Device.init_device(self)
self.esp_device = TemperatureSensors(self.host, self.port)
# create dynamic attributes
attr_prop = UserDefaultAttrProp()
for i in range(self.esp_device.nr_sensors):
attr_name = 'T%d' % (i+1)
attr_unit = 'C'
attr_prop.set_display_unit(attr_unit)
attr_prop.set_standard_unit(attr_unit)
attr_prop.set_unit(attr_unit)
#attr_prop.set_event_rel_change(0.01)
attr = Attr(attr_name, PyTango.DevDouble)
attr.set_default_properties(attr_prop)
attr = self.add_attribute(attr, r_meth=self.read_attrs)
self.poll_attribute(attr_name, 200)
self.set_change_event(attr_name, False)
def read_attrs(self, attr):
value = getattr(self.esp_device, attr.get_name())
attr.set_value(value)
def always_executed_hook(self):
state, status = self.esp_device.state
if state == 'OK':
self.set_state(DevState.ON)
self.set_status("The PLC is ready to fill the IO Chambers")
elif state == 'ALARM':
self.set_state(DevState.ALARM)
self.set_status(status)
@attribute(label="Finding", dtype=bool)
def finding(self):
return self.esp_device.finding
@command
def StartSearch(self):
self.esp_device.finding = True
@command
def StopSearch(self):
self.esp_device.finding = False
class FileLogger(Device):
__metaclass__ = DeviceMeta
log_path = device_property(dtype=str, default_value="/tmp")
def __init__(self, cl, name):
super(FileLogger, self).__init__(cl, name)
print self.log_path
@command(dtype_in='DevVarStringArray', dtype_out=None)
def log(self, details):
# import ipdb; ipdb.set_trace()
source_device = details[2]
message = details[3]
timestamp = str(datetime.datetime.fromtimestamp(float(details[0]) / 1000))
logger = logger_dict.get(source_device)
if not logger:
logger = logging.getLogger(source_device)
logger.setLevel(logging.INFO)
# Add the log message handler to the logger
handler = logging.handlers.RotatingFileHandler(
self.log_path+ "/"+source_device.replace("/", "_"), maxBytes=3000000, backupCount=5)
logger.addHandler(handler)
logger_dict[source_device] = logger
logger.info("{}]\t{}".format(timestamp,message))
def update_class(self, key, dct):
"""Create properties, attribute and read method.
Also register useful informations in the property dictionary.
"""
# Parent method
logical_attribute.update_class(self, key, dct)
proxy.update_class(self, key, dct)
# Create device property
doc = "Attribute of '{0}' forwarded as {1}.".format(self.device, key)
if self.prop:
dct[self.prop] = device_property(dtype=str, doc=doc,
default_value=self.attr)
# Read-only
if not self.writable:
return
# Custom write
if dct.get("is_" + key + "_allowed") or \
set(self.kwargs) & set(["fwrite", "fset"]):
return
# Write method
def write(device, value):
proxy_name = device._device_dict[key]
device_proxy = device._proxy_dict[proxy_name]
proxy_attr = device._attribute_dict[key]
device_proxy.write_attribute(proxy_attr, value)
dct[key] = dct[key].setter(write)
class SKATelState(SKABaseDevice):
"""
A generic base device for Telescope State for SKA.
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(SKATelState.class_variable) ENABLED START #
# PROTECTED REGION END # // SKATelState.class_variable
# -----------------
# Device Properties
# -----------------
TelStateConfigFile = device_property(dtype='str', )
# ----------
# Attributes
# ----------
# ---------------
# General methods
# ---------------
def init_device(self):
SKABaseDevice.init_device(self)
# PROTECTED REGION ID(SKATelState.init_device) ENABLED START #
# PROTECTED REGION END # // SKATelState.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(SKATelState.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // SKATelState.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(SKATelState.delete_device) ENABLED START #
pass
class Rack(SKABaseDevice):
"""
Ref (Reference Elt) Rack device
"""
__metaclass__ = DeviceMeta
# -----------------
# Device Properties
# -----------------
pdus = device_property(dtype=('str', ), mandatory=True)
switches = device_property(dtype=('str', ), mandatory=True)
servers = device_property(dtype=('str', ), mandatory=True)
# ----------
# Attributes
# ----------
# ---------------
# General methods
# ---------------
def init_device(self):
SKABaseDevice.init_device(self)
def always_executed_hook(self):
pass
def delete_device(self):
pass
# ------------------
# Attributes methods
# ------------------
# --------
# Commands
# --------
@command()
@DebugIt()
def Reset(self):
pass
class EventsTest(Device):
"""
Switches beetwen valid and invalid attribute`s values.
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(EventsTest.class_variable) ENABLED START #
# PROTECTED REGION END # // EventsTest.class_variable
# -----------------
# Device Properties
# -----------------
DeviceName = device_property(dtype='str', )
# ----------
# Attributes
# ----------
Max = attribute(dtype='double', )
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(EventsTest.init_device) ENABLED START #
self.set_state(DevState.ON)
self.proxy = AttributeProxy(self.DeviceName)
# PROTECTED REGION END # // EventsTest.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(EventsTest.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // EventsTest.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(EventsTest.delete_device) ENABLED START #
pass
# PROTECTED REGION END # // EventsTest.delete_device
# ------------------
# Attributes methods
# ------------------
def read_Max(self):
# PROTECTED REGION ID(EventsTest.Attribute1_read) ENABLED START #
value = self.proxy.read().value
maximums = []
for row in value:
maximums.append(max(row))
value = max(maximums)
attr_quality = AttrQuality.ATTR_ALARM
self.push_change_event("Max", float(value), time(), attr_quality)
self.push_archive_event("Max", float(value), time(), attr_quality)
return float(value), time(), attr_quality
class PhaseshifterDS(Device):
__metaclass__ = DeviceMeta
phase = attribute(label="Phase",
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="deg",
format="3.2f",
min_value=0.0,
max_value=720.0,
fget="get_phase",
fset="set_phase",
doc="RF phase",
memorized=True,
hw_memorized=True)
dac_ds_name = device_property(
dtype=str, doc="Name of the underlying AD5370 DAC device server")
phase_volt_cal = device_property(dtype=float,
doc="Calibration factor in degrees/volt",
default_value=36.0)
dac_channel = device_property(dtype=int,
doc="Channel connected to the phase shifter",
default_value=39)
def init_device(self):
self.debug_stream("In init_device:")
Device.init_device(self)
self.phase_val = 0.0
self.dac_dev = pt.DeviceProxy(self.dac_ds_name)
self.set_state(pt.DevState.ON)
def get_phase(self):
self.debug_stream("In get_phase:")
return self.phase_val, time.time(), pt.AttrQuality.ATTR_VALID
def set_phase(self, new_phase):
self.debug_stream("In set_phase: New phase " + str(new_phase))
self.phase_val = new_phase
self.dac_dev.write_attribute(
"".join(("channel", str(self.dac_channel))),
new_phase / self.phase_volt_cal)
def update_docs(dct):
"""Update the documentation for device properties."""
# Get attributes
attrs_dct = {}
for attr, value in dct["_class_dict"]["devices"].items():
if isinstance(value, proxy_attribute):
attrs_dct.setdefault(value.device, []).append(attr)
# Generate doc
for device, attrs in attrs_dct.items():
doc = 's ' + ', '.join(attrs[:-1]) + ' and ' if attrs[:-1] else ' '
doc = 'Proxy device for attribute{0}.'.format(doc + attrs[-1])
dct[device] = device_property(dtype=str, doc=doc)
class SKAPowerSupplyGroup(SKABaseDevice):
"""
Description
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(SKAPowerSupplyGroup.class_variable) ENABLED START #
# PROTECTED REGION END # // SKAPowerSupplyGroup.class_variable
# -----------------
# Device Properties
# -----------------
PowerSupplyGroup = device_property(dtype='str', mandatory=True)
# ----------
# Attributes
# ----------
PowerSupplyList = attribute(
dtype=('str', ),
max_dim_x=2048,
)
Current = attribute(
dtype=('double', ),
max_dim_x=128,
)
Voltage = attribute(
dtype=('double', ),
access=AttrWriteType.READ_WRITE,
max_dim_x=128,
)
# ---------------
# General methods
# ---------------
def init_device(self):
SKABaseDevice.init_device(self)
# PROTECTED REGION ID(SKAPowerSupplyGroup.init_device) ENABLED START #
self.tg = tango.Group('power supplies')
self.setpoints = [0.0]
# name of the group for the Power Supplies
self.tg.add(self.PowerSupplyGroup)
# PROTECTED REGION END # // SKAPowerSupplyGroup.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(SKAPowerSupplyGroup.always_executed_hook) ENABLED START #
print(self.PowerSupplyGroup)
print(self.tg.get_device_list())
r = self.tg.read_attribute('State')
states = {}
try:
for b in r:
name = b.dev_name()
value = b.get_data(
).value if not b.has_failed() else DevState.FAULT
states[name] = value
self.set_status('\n'.join('%s: %s' % t for t in states.items()))
stateset = list(set(states.values()))
if not stateset:
self.set_state(DevState.INIT)
elif DevState.FAULT in stateset:
self.set_state(DevState.FAULT)
elif DevState.ALARM in stateset:
self.set_state(DevState.ALARM)
elif len(stateset) != 1:
self.set_state(DevState.UNKNOWN)
else:
self.set_state(stateset[0])
except:
self.logger.error(traceback.format_exc())
# PROTECTED REGION END # // SKAPowerSupplyGroup.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(SKAPowerSupplyGroup.delete_device) ENABLED START #
pass
# PROTECTED REGION END # // SKAPowerSupplyGroup.delete_device
# ------------------
# Attributes methods
# ------------------
def read_PowerSupplyList(self):
# PROTECTED REGION ID(SKAPowerSupplyGroup.PowerSupplyList_read) ENABLED START #
devs = list(self.tg.get_device_list())
if not len(devs):
self.set_state(DevState.FAULT)
raise Exception('No Power Supplies running?')
return list(sorted(devs))
# PROTECTED REGION END # // SKAPowerSupplyGroup.PowerSupplyList_read
def read_Current(self):
# PROTECTED REGION ID(SKAPowerSupplyGroup.Current_read) ENABLED START #
r = self.tg.read_attribute('Current')
currents = {}
try:
for b in r:
name = b.dev_name()
value = b.get_data().value if not b.has_failed() else math.nan
currents[name] = value
except:
self.logger.error(traceback.format_exc())
return list(v for k, v in sorted(currents.items()))
# PROTECTED REGION END # // SKAPowerSupplyGroup.Current_read
def read_Voltage(self):
# PROTECTED REGION ID(SKAPowerSupplyGroup.Voltage_read) ENABLED START #
r = self.tg.read_attribute('Voltage')
voltages = {}
try:
for b in r:
name = b.dev_name()
value = b.get_data().value if not b.has_failed() else math.nan
if value != self.setpoints[0]:
self.set_state(DevState.FAULT)
voltages[name] = value
except:
self.logger.error(traceback.format_exc())
return list(v for k, v in sorted(voltages.items()))
# PROTECTED REGION END # // SKAPowerSupplyGroup.Voltage_read
def write_Voltage(self, value):
# PROTECTED REGION ID(SKAPowerSupplyGroup.Voltage_write) ENABLED START #
r = self.tg.write_attribute('Voltage', value)
self.setpoints = value
# PROTECTED REGION END # // SKAPowerSupplyGroup.Voltage_write
# --------
# Commands
# --------
@command()
@DebugIt()
def On(self):
# PROTECTED REGION ID(SKAPowerSupplyGroup.On) ENABLED START #
self.tg.command_inout('On')
# PROTECTED REGION END # // SKAPowerSupplyGroup.On
@command()
@DebugIt()
def Off(self):
# PROTECTED REGION ID(SKAPowerSupplyGroup.Off) ENABLED START #
self.tg.command_inout('Off')
class CryoCon32(Device):
"""
Minimalistic driver for the Cryocon32 controller used in our Mossbauer transmission setup.
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(CryoCon32.class_variable) ENABLED START #
# PROTECTED REGION END # // CryoCon32.class_variable
# -----------------
# Device Properties
# -----------------
SerialPort = device_property(dtype='str', default_value="/dev/ttyS0")
SerialSpeed = device_property(dtype='uint16', default_value=9600)
# ----------
# Attributes
# ----------
TemperatureA = attribute(
dtype='double',
unit="K",
standard_unit="K",
display_unit="K",
format="%4.1f",
max_value=1000.0,
min_value=0.0,
)
SetPoint = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
label="SetPoint",
unit="K",
standard_unit="K",
display_unit="K",
format="%4.1f",
max_value=1000.0,
min_value=0.0,
)
TemperatureB = attribute(
dtype='double',
unit="K",
)
HeaterLevel = attribute(
dtype='DevEnum',
access=AttrWriteType.READ_WRITE,
enum_labels=[
"LOW",
"MID",
"HIGH",
],
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(CryoCon32.init_device) ENABLED START #
try:
self.ser = serial.Serial(self.SerialPort,
self.SerialSpeed,
bytesize=8,
parity="N",
stopbits=1,
timeout=0.5)
self.ser.write("*IDN?\n")
idn = self.ser.readline()
if (idn[0:16] != "Cryocon Model 32"):
self.set_status("Not a CryoCon32 on serial port")
self.debug_stream("Not a CryoCon32 on serial port")
return
self.ser.write("INPUT A:UNITS K\n")
self.ser.write("LOOP 1:TYPE PID\n")
self.ser.write("CONTROL?\n")
mode = self.ser.readline()
if mode[0:3] == "OFF":
self.set_state(PyTango.DevState.OFF)
else:
self.set_state(PyTango.DevState.ON)
except:
self.set_state(PyTango.DevState.FAULT)
self.set_status("Can't connect to CryoCon32")
self.debug_stream("Can't connect to CryoCon32")
return
self.set_status("Connected to CryoCon32")
self.debug_stream("Connected to CryoCon32")
# PROTECTED REGION END # // CryoCon32.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(CryoCon32.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // CryoCon32.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(CryoCon32.delete_device) ENABLED START #
self.ser.close()
# PROTECTED REGION END # // CryoCon32.delete_device
# ------------------
# Attributes methods
# ------------------
def read_TemperatureA(self):
# PROTECTED REGION ID(CryoCon32.TemperatureA_read) ENABLED START #
self.ser.write("INPUT? A\n")
temperature = float(self.ser.readline())
return (temperature)
# PROTECTED REGION END # // CryoCon32.TemperatureA_read
def read_SetPoint(self):
# PROTECTED REGION ID(CryoCon32.SetPoint_read) ENABLED START #
self.ser.write("LOOP 1:SETPT?\n")
temperature = float(self.ser.readline()
[:-2]) # Remove \n and units (assume we are in K!)
return (temperature)
# PROTECTED REGION END # // CryoCon32.SetPoint_read
def write_SetPoint(self, value):
# PROTECTED REGION ID(CryoCon32.SetPoint_write) ENABLED START #
self.ser.write("LOOP 1:SETPT %f \n" % (value))
# PROTECTED REGION END # // CryoCon32.SetPoint_write
def read_TemperatureB(self):
# PROTECTED REGION ID(CryoCon32.TemperatureB_read) ENABLED START #
self.ser.write("INPUT? B\n")
temperature = float(self.ser.readline())
return (temperature)
# PROTECTED REGION END # // CryoCon32.TemperatureB_read
def read_HeaterLevel(self):
# PROTECTED REGION ID(CryoCon32.HeaterLevel_read) ENABLED START #
self.ser.write("LOOP 1:RANGE?\n")
res = self.ser.readline()
if (res[:-1] == "LOW"):
return 0
elif (res[:-1] == "MID"):
return 1
else:
return 2
# PROTECTED REGION END # // CryoCon32.HeaterLevel_read
def write_HeaterLevel(self, value):
# PROTECTED REGION ID(CryoCon32.HeaterLevel_write) ENABLED START #
if (value == 0):
self.ser.write("LOOP 1:RANGE LOW\n")
elif (value == 1):
self.ser.write("LOOP 1:RANGE MID\n")
elif (value == 2):
self.ser.write("LOOP 1:RANGE HI\n")
return
# PROTECTED REGION END # // CryoCon32.HeaterLevel_write
# --------
# Commands
# --------
@command()
@DebugIt()
def On(self):
# PROTECTED REGION ID(CryoCon32.On) ENABLED START #
self.ser.write("CONTROL ON\n")
self.set_state(PyTango.DevState.ON)
pass
# PROTECTED REGION END # // CryoCon32.On
@command()
@DebugIt()
def Off(self):
# PROTECTED REGION ID(CryoCon32.Off) ENABLED START #
self.ser.write("STOP\n")
self.set_state(PyTango.DevState.OFF)
pass
# PROTECTED REGION END # // CryoCon32.Off
@command(
dtype_in='str', )
@DebugIt()
def SendCmd(self, argin):
# PROTECTED REGION ID(CryoCon32.SendCmd) ENABLED START #
self.ser.write(argin + "\n")
return ""
# PROTECTED REGION END # // CryoCon32.SendCmd
@command(
dtype_in='str',
dtype_out='str',
)
@DebugIt()
def SendQuery(self, argin):
# PROTECTED REGION ID(CryoCon32.SendQuery) ENABLED START #
self.ser.write(argin + "\n")
return self.ser.readline()
class TangoTest(Device):
"""
A device to test generic clients. It offers a \``echo\`` like command for
each TANGO data type (i.e. each command returns an exact copy of <argin>).
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(TangoTest.class_variable) ENABLED START #
# PROTECTED REGION END # // TangoTest.class_variable
# ----------------
# Class Properties
# ----------------
# -----------------
# Device Properties
# -----------------
Mthreaded_impl = device_property(dtype='int16', )
Sleep_period = device_property(dtype='int', )
UShort_image_ro_size = device_property(dtype='int', default_value=251)
# ----------
# Attributes
# ----------
ampli = attribute(
dtype='double',
access=AttrWriteType.WRITE,
)
boolean_scalar = attribute(
dtype='bool',
access=AttrWriteType.READ_WRITE,
label="boolean_scalar",
doc="A boolean scalar attribute",
)
double_scalar = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
)
double_scalar_rww = attribute(
dtype='double',
access=AttrWriteType.READ_WITH_WRITE,
)
double_scalar_w = attribute(
dtype='double',
access=AttrWriteType.WRITE,
)
float_scalar = attribute(
dtype='float',
access=AttrWriteType.READ_WRITE,
label="float_scalar",
doc="A float attribute",
)
long64_scalar = attribute(
dtype='int64',
access=AttrWriteType.READ_WRITE,
)
long_scalar = attribute(
dtype='int',
access=AttrWriteType.READ_WRITE,
)
long_scalar_rww = attribute(
dtype='int',
access=AttrWriteType.READ_WITH_WRITE,
)
long_scalar_w = attribute(
dtype='int',
access=AttrWriteType.WRITE,
)
no_value = attribute(dtype='int', )
short_scalar = attribute(
dtype='int16',
access=AttrWriteType.READ_WRITE,
)
short_scalar_ro = attribute(dtype='int16', )
short_scalar_rww = attribute(
dtype='int16',
access=AttrWriteType.READ_WITH_WRITE,
)
short_scalar_w = attribute(
dtype='int16',
access=AttrWriteType.WRITE,
)
string_scalar = attribute(
dtype='str',
access=AttrWriteType.READ_WRITE,
)
throw_exception = attribute(dtype='int', )
uchar_scalar = attribute(
dtype='char',
access=AttrWriteType.READ_WRITE,
label="uchar_scalar",
)
ulong64_scalar = attribute(
dtype='uint64',
access=AttrWriteType.READ_WRITE,
)
ushort_scalar = attribute(
dtype='uint16',
access=AttrWriteType.READ_WRITE,
label="ushort_scalar",
)
ulong_scalar = attribute(
dtype='uint',
access=AttrWriteType.READ_WRITE,
)
boolean_spectrum = attribute(
dtype=('bool', ),
access=AttrWriteType.READ_WRITE,
max_dim_x=4096,
label="boolean_spectrum",
)
boolean_spectrum_ro = attribute(
dtype=('bool', ),
max_dim_x=4096,
)
double_spectrum = attribute(
dtype=('double', ),
access=AttrWriteType.READ_WRITE,
max_dim_x=4096,
)
double_spectrum_ro = attribute(
dtype=('double', ),
max_dim_x=4096,
)
float_spectrum = attribute(
dtype=('float', ),
access=AttrWriteType.READ_WRITE,
max_dim_x=4096,
label="float_spectrum",
doc="A float spectrum attribute",
)
float_spectrum_ro = attribute(
dtype=('float', ),
max_dim_x=4096,
)
long64_spectrum_ro = attribute(
dtype=('int64', ),
max_dim_x=4096,
)
long_spectrum = attribute(
dtype=('int', ),
access=AttrWriteType.READ_WRITE,
max_dim_x=4096,
)
long_spectrum_ro = attribute(
dtype=('int', ),
max_dim_x=4096,
)
short_spectrum = attribute(
dtype=('int16', ),
access=AttrWriteType.READ_WRITE,
max_dim_x=4096,
)
short_spectrum_ro = attribute(
dtype=('int16', ),
max_dim_x=4096,
)
string_spectrum = attribute(
dtype=('str', ),
access=AttrWriteType.READ_WRITE,
max_dim_x=256,
)
string_spectrum_ro = attribute(
dtype=('str', ),
max_dim_x=256,
)
uchar_spectrum = attribute(
dtype=('char', ),
access=AttrWriteType.READ_WRITE,
max_dim_x=4096,
label="uchar_spectrum",
max_value=255,
min_value=0,
doc="An unsigned char spectrum attribute",
)
uchar_spectrum_ro = attribute(
dtype=('char', ),
max_dim_x=4096,
)
ulong64_spectrum_ro = attribute(
dtype=('uint64', ),
max_dim_x=4096,
)
ulong_spectrum_ro = attribute(
dtype=('uint', ),
max_dim_x=4096,
)
ushort_spectrum = attribute(
dtype=('uint16', ),
access=AttrWriteType.READ_WRITE,
max_dim_x=4096,
label="ushort_spectrum",
doc="An unsigned short spectrum attribute",
)
ushort_spectrum_ro = attribute(
dtype=('uint16', ),
max_dim_x=4096,
)
wave = attribute(
dtype=('double', ),
max_dim_x=4096,
)
boolean_image = attribute(
dtype=(('bool', ), ),
access=AttrWriteType.READ_WRITE,
max_dim_x=251,
max_dim_y=251,
)
boolean_image_ro = attribute(
dtype=(('bool', ), ),
max_dim_x=251,
max_dim_y=251,
label="boolean_image",
)
double_image = attribute(
dtype=(('double', ), ),
access=AttrWriteType.READ_WRITE,
max_dim_x=251,
max_dim_y=251,
)
double_image_ro = attribute(
dtype=(('double', ), ),
max_dim_x=251,
max_dim_y=251,
)
float_image = attribute(
dtype=(('float', ), ),
access=AttrWriteType.READ_WRITE,
max_dim_x=251,
max_dim_y=251,
)
float_image_ro = attribute(
dtype=(('float', ), ),
max_dim_x=251,
max_dim_y=251,
label="float_image",
max_value=255,
min_value=0,
doc="A float image attribute",
)
long64_image_ro = attribute(
dtype=(('int64', ), ),
max_dim_x=251,
max_dim_y=251,
)
long_image = attribute(
dtype=(('int', ), ),
access=AttrWriteType.READ_WRITE,
max_dim_x=251,
max_dim_y=251,
)
long_image_ro = attribute(
dtype=(('int', ), ),
max_dim_x=251,
max_dim_y=251,
)
short_image = attribute(
dtype=(('int16', ), ),
access=AttrWriteType.READ_WRITE,
max_dim_x=251,
max_dim_y=251,
)
short_image_ro = attribute(
dtype=(('int16', ), ),
max_dim_x=251,
max_dim_y=251,
)
string_image = attribute(
dtype=(('str', ), ),
access=AttrWriteType.READ_WRITE,
max_dim_x=256,
max_dim_y=256,
)
string_image_ro = attribute(
dtype=(('str', ), ),
max_dim_x=256,
max_dim_y=256,
)
uchar_image = attribute(
dtype=(('char', ), ),
access=AttrWriteType.READ_WRITE,
max_dim_x=251,
max_dim_y=251,
)
uchar_image_ro = attribute(
dtype=(('char', ), ),
max_dim_x=251,
max_dim_y=251,
label="uchar_image",
max_value=255,
min_value=0,
doc="An unsigned char image attribute",
)
ulong64_image_ro = attribute(
dtype=(('uint64', ), ),
max_dim_x=251,
max_dim_y=251,
)
ulong_image_ro = attribute(
dtype=(('uint', ), ),
max_dim_x=251,
max_dim_y=251,
)
ushort_image = attribute(
dtype=(('uint16', ), ),
access=AttrWriteType.READ_WRITE,
max_dim_x=251,
max_dim_y=251,
)
ushort_image_ro = attribute(
dtype=(('uint16', ), ),
max_dim_x=8192,
max_dim_y=8192,
label="ushort_image_ro",
max_value=255,
min_value=0,
doc="An unsigned short image attribute",
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(TangoTest.init_device) ENABLED START #
# PROTECTED REGION END # // TangoTest.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(TangoTest.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(TangoTest.delete_device) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.delete_device
# ------------------
# Attributes methods
# ------------------
def write_ampli(self, value):
# PROTECTED REGION ID(TangoTest.ampli_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.ampli_write
def read_boolean_scalar(self):
# PROTECTED REGION ID(TangoTest.boolean_scalar_read) ENABLED START #
return False
# PROTECTED REGION END # // TangoTest.boolean_scalar_read
def write_boolean_scalar(self, value):
# PROTECTED REGION ID(TangoTest.boolean_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.boolean_scalar_write
def read_double_scalar(self):
# PROTECTED REGION ID(TangoTest.double_scalar_read) ENABLED START #
return 0.0
# PROTECTED REGION END # // TangoTest.double_scalar_read
def write_double_scalar(self, value):
# PROTECTED REGION ID(TangoTest.double_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.double_scalar_write
def read_double_scalar_rww(self):
# PROTECTED REGION ID(TangoTest.double_scalar_rww_read) ENABLED START #
return 0.0
# PROTECTED REGION END # // TangoTest.double_scalar_rww_read
def write_double_scalar_rww(self, value):
# PROTECTED REGION ID(TangoTest.double_scalar_rww_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.double_scalar_rww_write
def write_double_scalar_w(self, value):
# PROTECTED REGION ID(TangoTest.double_scalar_w_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.double_scalar_w_write
def read_float_scalar(self):
# PROTECTED REGION ID(TangoTest.float_scalar_read) ENABLED START #
return 0.0
# PROTECTED REGION END # // TangoTest.float_scalar_read
def write_float_scalar(self, value):
# PROTECTED REGION ID(TangoTest.float_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.float_scalar_write
def read_long64_scalar(self):
# PROTECTED REGION ID(TangoTest.long64_scalar_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.long64_scalar_read
def write_long64_scalar(self, value):
# PROTECTED REGION ID(TangoTest.long64_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.long64_scalar_write
def read_long_scalar(self):
# PROTECTED REGION ID(TangoTest.long_scalar_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.long_scalar_read
def write_long_scalar(self, value):
# PROTECTED REGION ID(TangoTest.long_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.long_scalar_write
def read_long_scalar_rww(self):
# PROTECTED REGION ID(TangoTest.long_scalar_rww_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.long_scalar_rww_read
def write_long_scalar_rww(self, value):
# PROTECTED REGION ID(TangoTest.long_scalar_rww_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.long_scalar_rww_write
def write_long_scalar_w(self, value):
# PROTECTED REGION ID(TangoTest.long_scalar_w_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.long_scalar_w_write
def read_no_value(self):
# PROTECTED REGION ID(TangoTest.no_value_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.no_value_read
def read_short_scalar(self):
# PROTECTED REGION ID(TangoTest.short_scalar_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.short_scalar_read
def write_short_scalar(self, value):
# PROTECTED REGION ID(TangoTest.short_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.short_scalar_write
def read_short_scalar_ro(self):
# PROTECTED REGION ID(TangoTest.short_scalar_ro_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.short_scalar_ro_read
def read_short_scalar_rww(self):
# PROTECTED REGION ID(TangoTest.short_scalar_rww_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.short_scalar_rww_read
def write_short_scalar_rww(self, value):
# PROTECTED REGION ID(TangoTest.short_scalar_rww_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.short_scalar_rww_write
def write_short_scalar_w(self, value):
# PROTECTED REGION ID(TangoTest.short_scalar_w_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.short_scalar_w_write
def read_string_scalar(self):
# PROTECTED REGION ID(TangoTest.string_scalar_read) ENABLED START #
return ''
# PROTECTED REGION END # // TangoTest.string_scalar_read
def write_string_scalar(self, value):
# PROTECTED REGION ID(TangoTest.string_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.string_scalar_write
def read_throw_exception(self):
# PROTECTED REGION ID(TangoTest.throw_exception_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.throw_exception_read
def read_uchar_scalar(self):
# PROTECTED REGION ID(TangoTest.uchar_scalar_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.uchar_scalar_read
def write_uchar_scalar(self, value):
# PROTECTED REGION ID(TangoTest.uchar_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.uchar_scalar_write
def read_ulong64_scalar(self):
# PROTECTED REGION ID(TangoTest.ulong64_scalar_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.ulong64_scalar_read
def write_ulong64_scalar(self, value):
# PROTECTED REGION ID(TangoTest.ulong64_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.ulong64_scalar_write
def read_ushort_scalar(self):
# PROTECTED REGION ID(TangoTest.ushort_scalar_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.ushort_scalar_read
def write_ushort_scalar(self, value):
# PROTECTED REGION ID(TangoTest.ushort_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.ushort_scalar_write
def read_ulong_scalar(self):
# PROTECTED REGION ID(TangoTest.ulong_scalar_read) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.ulong_scalar_read
def write_ulong_scalar(self, value):
# PROTECTED REGION ID(TangoTest.ulong_scalar_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.ulong_scalar_write
def read_boolean_spectrum(self):
# PROTECTED REGION ID(TangoTest.boolean_spectrum_read) ENABLED START #
return [False]
# PROTECTED REGION END # // TangoTest.boolean_spectrum_read
def write_boolean_spectrum(self, value):
# PROTECTED REGION ID(TangoTest.boolean_spectrum_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.boolean_spectrum_write
def read_boolean_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.boolean_spectrum_ro_read) ENABLED START #
return [False]
# PROTECTED REGION END # // TangoTest.boolean_spectrum_ro_read
def read_double_spectrum(self):
# PROTECTED REGION ID(TangoTest.double_spectrum_read) ENABLED START #
return [0.0]
# PROTECTED REGION END # // TangoTest.double_spectrum_read
def write_double_spectrum(self, value):
# PROTECTED REGION ID(TangoTest.double_spectrum_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.double_spectrum_write
def read_double_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.double_spectrum_ro_read) ENABLED START #
return [0.0]
# PROTECTED REGION END # // TangoTest.double_spectrum_ro_read
def read_float_spectrum(self):
# PROTECTED REGION ID(TangoTest.float_spectrum_read) ENABLED START #
return [0.0]
# PROTECTED REGION END # // TangoTest.float_spectrum_read
def write_float_spectrum(self, value):
# PROTECTED REGION ID(TangoTest.float_spectrum_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.float_spectrum_write
def read_float_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.float_spectrum_ro_read) ENABLED START #
return [0.0]
# PROTECTED REGION END # // TangoTest.float_spectrum_ro_read
def read_long64_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.long64_spectrum_ro_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.long64_spectrum_ro_read
def read_long_spectrum(self):
# PROTECTED REGION ID(TangoTest.long_spectrum_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.long_spectrum_read
def write_long_spectrum(self, value):
# PROTECTED REGION ID(TangoTest.long_spectrum_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.long_spectrum_write
def read_long_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.long_spectrum_ro_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.long_spectrum_ro_read
def read_short_spectrum(self):
# PROTECTED REGION ID(TangoTest.short_spectrum_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.short_spectrum_read
def write_short_spectrum(self, value):
# PROTECTED REGION ID(TangoTest.short_spectrum_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.short_spectrum_write
def read_short_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.short_spectrum_ro_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.short_spectrum_ro_read
def read_string_spectrum(self):
# PROTECTED REGION ID(TangoTest.string_spectrum_read) ENABLED START #
return ['']
# PROTECTED REGION END # // TangoTest.string_spectrum_read
def write_string_spectrum(self, value):
# PROTECTED REGION ID(TangoTest.string_spectrum_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.string_spectrum_write
def read_string_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.string_spectrum_ro_read) ENABLED START #
return ['']
# PROTECTED REGION END # // TangoTest.string_spectrum_ro_read
def read_uchar_spectrum(self):
# PROTECTED REGION ID(TangoTest.uchar_spectrum_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.uchar_spectrum_read
def write_uchar_spectrum(self, value):
# PROTECTED REGION ID(TangoTest.uchar_spectrum_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.uchar_spectrum_write
def read_uchar_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.uchar_spectrum_ro_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.uchar_spectrum_ro_read
def read_ulong64_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.ulong64_spectrum_ro_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.ulong64_spectrum_ro_read
def read_ulong_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.ulong_spectrum_ro_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.ulong_spectrum_ro_read
def read_ushort_spectrum(self):
# PROTECTED REGION ID(TangoTest.ushort_spectrum_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.ushort_spectrum_read
def write_ushort_spectrum(self, value):
# PROTECTED REGION ID(TangoTest.ushort_spectrum_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.ushort_spectrum_write
def read_ushort_spectrum_ro(self):
# PROTECTED REGION ID(TangoTest.ushort_spectrum_ro_read) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.ushort_spectrum_ro_read
def read_wave(self):
# PROTECTED REGION ID(TangoTest.wave_read) ENABLED START #
return [0.0]
# PROTECTED REGION END # // TangoTest.wave_read
def read_boolean_image(self):
# PROTECTED REGION ID(TangoTest.boolean_image_read) ENABLED START #
return [[False]]
# PROTECTED REGION END # // TangoTest.boolean_image_read
def write_boolean_image(self, value):
# PROTECTED REGION ID(TangoTest.boolean_image_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.boolean_image_write
def read_boolean_image_ro(self):
# PROTECTED REGION ID(TangoTest.boolean_image_ro_read) ENABLED START #
return [[False]]
# PROTECTED REGION END # // TangoTest.boolean_image_ro_read
def read_double_image(self):
# PROTECTED REGION ID(TangoTest.double_image_read) ENABLED START #
return [[0.0]]
# PROTECTED REGION END # // TangoTest.double_image_read
def write_double_image(self, value):
# PROTECTED REGION ID(TangoTest.double_image_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.double_image_write
def read_double_image_ro(self):
# PROTECTED REGION ID(TangoTest.double_image_ro_read) ENABLED START #
return [[0.0]]
# PROTECTED REGION END # // TangoTest.double_image_ro_read
def read_float_image(self):
# PROTECTED REGION ID(TangoTest.float_image_read) ENABLED START #
return [[0.0]]
# PROTECTED REGION END # // TangoTest.float_image_read
def write_float_image(self, value):
# PROTECTED REGION ID(TangoTest.float_image_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.float_image_write
def read_float_image_ro(self):
# PROTECTED REGION ID(TangoTest.float_image_ro_read) ENABLED START #
return [[0.0]]
# PROTECTED REGION END # // TangoTest.float_image_ro_read
def read_long64_image_ro(self):
# PROTECTED REGION ID(TangoTest.long64_image_ro_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.long64_image_ro_read
def read_long_image(self):
# PROTECTED REGION ID(TangoTest.long_image_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.long_image_read
def write_long_image(self, value):
# PROTECTED REGION ID(TangoTest.long_image_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.long_image_write
def read_long_image_ro(self):
# PROTECTED REGION ID(TangoTest.long_image_ro_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.long_image_ro_read
def read_short_image(self):
# PROTECTED REGION ID(TangoTest.short_image_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.short_image_read
def write_short_image(self, value):
# PROTECTED REGION ID(TangoTest.short_image_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.short_image_write
def read_short_image_ro(self):
# PROTECTED REGION ID(TangoTest.short_image_ro_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.short_image_ro_read
def read_string_image(self):
# PROTECTED REGION ID(TangoTest.string_image_read) ENABLED START #
return [['']]
# PROTECTED REGION END # // TangoTest.string_image_read
def write_string_image(self, value):
# PROTECTED REGION ID(TangoTest.string_image_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.string_image_write
def read_string_image_ro(self):
# PROTECTED REGION ID(TangoTest.string_image_ro_read) ENABLED START #
return [['']]
# PROTECTED REGION END # // TangoTest.string_image_ro_read
def read_uchar_image(self):
# PROTECTED REGION ID(TangoTest.uchar_image_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.uchar_image_read
def write_uchar_image(self, value):
# PROTECTED REGION ID(TangoTest.uchar_image_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.uchar_image_write
def read_uchar_image_ro(self):
# PROTECTED REGION ID(TangoTest.uchar_image_ro_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.uchar_image_ro_read
def read_ulong64_image_ro(self):
# PROTECTED REGION ID(TangoTest.ulong64_image_ro_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.ulong64_image_ro_read
def read_ulong_image_ro(self):
# PROTECTED REGION ID(TangoTest.ulong_image_ro_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.ulong_image_ro_read
def read_ushort_image(self):
# PROTECTED REGION ID(TangoTest.ushort_image_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.ushort_image_read
def write_ushort_image(self, value):
# PROTECTED REGION ID(TangoTest.ushort_image_write) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.ushort_image_write
def read_ushort_image_ro(self):
# PROTECTED REGION ID(TangoTest.ushort_image_ro_read) ENABLED START #
return [[0]]
# PROTECTED REGION END # // TangoTest.ushort_image_ro_read
# --------
# Commands
# --------
@command
@DebugIt()
def CrashFromDevelopperThread(self):
# PROTECTED REGION ID(TangoTest.CrashFromDevelopperThread) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.CrashFromDevelopperThread
@command
@DebugIt()
def CrashFromOmniThread(self):
# PROTECTED REGION ID(TangoTest.CrashFromOmniThread) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.CrashFromOmniThread
@command(dtype_in='bool',
doc_in="Any boolean value",
dtype_out='bool',
doc_out="Echo of the argin value")
@DebugIt()
def DevBoolean(self, argin):
# PROTECTED REGION ID(TangoTest.DevBoolean) ENABLED START #
return False
# PROTECTED REGION END # // TangoTest.DevBoolean
@command(dtype_in='double',
doc_in="Any DevDouble value",
dtype_out='double',
doc_out="Echo of the argin value")
@DebugIt()
def DevDouble(self, argin):
# PROTECTED REGION ID(TangoTest.DevDouble) ENABLED START #
return 0.0
# PROTECTED REGION END # // TangoTest.DevDouble
@command(dtype_in='float',
doc_in="Any DevFloat value",
dtype_out='float',
doc_out="Echo of the argin value")
@DebugIt()
def DevFloat(self, argin):
# PROTECTED REGION ID(TangoTest.DevFloat) ENABLED START #
return 0.0
# PROTECTED REGION END # // TangoTest.DevFloat
@command(dtype_in='int',
doc_in="Any DevLong value",
dtype_out='int',
doc_out="Echo of the argin value")
@DebugIt()
def DevLong(self, argin):
# PROTECTED REGION ID(TangoTest.DevLong) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.DevLong
@command(dtype_in='int64',
doc_in="Any DevLong64 value",
dtype_out='int64',
doc_out="Echo of the argin value")
@DebugIt()
def DevLong64(self, argin):
# PROTECTED REGION ID(TangoTest.DevLong64) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.DevLong64
@command(dtype_in='int16',
doc_in="Any DevShort value",
dtype_out='int16',
doc_out="Echo of the argin value")
@DebugIt()
def DevShort(self, argin):
# PROTECTED REGION ID(TangoTest.DevShort) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.DevShort
@command(dtype_in='str', doc_in="-", dtype_out='str', doc_out="-")
@DebugIt()
def DevString(self, argin):
# PROTECTED REGION ID(TangoTest.DevString) ENABLED START #
return ""
# PROTECTED REGION END # // TangoTest.DevString
@command(dtype_in='uint',
doc_in="Any DevULong",
dtype_out='uint',
doc_out="Echo of the argin value")
@DebugIt()
def DevULong(self, argin):
# PROTECTED REGION ID(TangoTest.DevULong) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.DevULong
@command(dtype_in='uint64',
doc_in="Any DevULong64 value",
dtype_out='uint64',
doc_out="Echo of the argin value")
@DebugIt()
def DevULong64(self, argin):
# PROTECTED REGION ID(TangoTest.DevULong64) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.DevULong64
@command(dtype_in='uint16',
doc_in="Any DevUShort value",
dtype_out='uint16',
doc_out="Echo of the argin value")
@DebugIt()
def DevUShort(self, argin):
# PROTECTED REGION ID(TangoTest.DevUShort) ENABLED START #
return 0
# PROTECTED REGION END # // TangoTest.DevUShort
@command(dtype_in=('char', ),
doc_in="-",
dtype_out=('char', ),
doc_out="-")
@DebugIt()
def DevVarCharArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarCharArray) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.DevVarCharArray
@command(dtype_in=('double', ),
doc_in="-",
dtype_out=('double', ),
doc_out="-")
@DebugIt()
def DevVarDoubleArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarDoubleArray) ENABLED START #
return [0.0]
# PROTECTED REGION END # // TangoTest.DevVarDoubleArray
@command(dtype_in='DevVarDoubleStringArray',
doc_in="-",
dtype_out='DevVarDoubleStringArray',
doc_out="-")
@DebugIt()
def DevVarDoubleStringArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarDoubleStringArray) ENABLED START #
return [[0.0], [""]]
# PROTECTED REGION END # // TangoTest.DevVarDoubleStringArray
@command(dtype_in=('float', ),
doc_in="-",
dtype_out=('float', ),
doc_out="-")
@DebugIt()
def DevVarFloatArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarFloatArray) ENABLED START #
return [0.0]
# PROTECTED REGION END # // TangoTest.DevVarFloatArray
@command(
dtype_in=('int64', ),
dtype_out=('int64', ),
)
@DebugIt()
def DevVarLong64Array(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarLong64Array) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.DevVarLong64Array
@command(dtype_in=('int', ), doc_in="-", dtype_out=('int', ), doc_out="-")
@DebugIt()
def DevVarLongArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarLongArray) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.DevVarLongArray
@command(dtype_in='DevVarLongStringArray',
doc_in="-",
dtype_out='DevVarLongStringArray',
doc_out="-")
@DebugIt()
def DevVarLongStringArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarLongStringArray) ENABLED START #
return [[0], [""]]
# PROTECTED REGION END # // TangoTest.DevVarLongStringArray
@command(dtype_in=('int16', ),
doc_in="-",
dtype_out=('int16', ),
doc_out="-")
@DebugIt()
def DevVarShortArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarShortArray) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.DevVarShortArray
@command(dtype_in=('str', ), doc_in="-", dtype_out=('str', ), doc_out="-")
@DebugIt()
def DevVarStringArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarStringArray) ENABLED START #
return [""]
# PROTECTED REGION END # // TangoTest.DevVarStringArray
@command(
dtype_in=('uint64'),
dtype_out=('uint64'),
)
@DebugIt()
def DevVarULong64Array(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarULong64Array) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.DevVarULong64Array
@command(dtype_in=('uint', ),
doc_in="-",
dtype_out=('uint', ),
doc_out="-")
@DebugIt()
def DevVarULongArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarULongArray) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.DevVarULongArray
@command(dtype_in=('uint16', ),
doc_in="-",
dtype_out=('uint16', ),
doc_out="-")
@DebugIt()
def DevVarUShortArray(self, argin):
# PROTECTED REGION ID(TangoTest.DevVarUShortArray) ENABLED START #
return [0]
# PROTECTED REGION END # // TangoTest.DevVarUShortArray
@command
@DebugIt()
def DevVoid(self):
# PROTECTED REGION ID(TangoTest.DevVoid) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.DevVoid
@command
@DebugIt()
def DumpExecutionState(self):
# PROTECTED REGION ID(TangoTest.DumpExecutionState) ENABLED START #
pass
# PROTECTED REGION END # // TangoTest.DumpExecutionState
@command
@DebugIt()
def SwitchStates(self):
# PROTECTED REGION ID(TangoTest.SwitchStates) ENABLED START #
pass
class Keithley2100(Device):
"""
Server for Keithley DVMM 61/2 digits
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(Keithley2100.class_variable) ENABLED START #
# PROTECTED REGION END # // Keithley2100.class_variable
# -----------------
# Device Properties
# -----------------
idProduct = device_property(
dtype='uint', default_value=8448
)
idVendor = device_property(
dtype='uint', default_value=1510
)
# ----------
# Attributes
# ----------
Field = attribute(
dtype='double',
unit="T",
format="%5.4f",
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(Keithley2100.init_device) ENABLED START #
#instr=usbtmc.Instrument(idVendor,idProduct)
self.instr=usbtmc.Instrument(0x05e6,0x2100)
self.set_status("Connected to DVMM Keithley 2100")
self.debug_stream("Connected to DVMM Keithley 2100")
self.set_state(PyTango.DevState.ON)
# PROTECTED REGION END # // Keithley2100.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(Keithley2100.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // Keithley2100.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(Keithley2100.delete_device) ENABLED START #
pass
# PROTECTED REGION END # // Keithley2100.delete_device
# ------------------
# Attributes methods
# ------------------
def read_Field(self):
# PROTECTED REGION ID(Keithley2100.Field_read) ENABLED START #
return float(self.instr.ask("MEAS:VOLT:DC?"))*10.0
# PROTECTED REGION END # // Keithley2100.Field_read
# --------
# Commands
# --------
@command(
dtype_in='str',
dtype_out='str',
)
@DebugIt()
def sendCommand(self, argin):
# PROTECTED REGION ID(Keithley2100.sendCommand) ENABLED START #
return self.instr.ask(argin)
class SecondOrderImpulseResponse(Device):
"""
This is a sample DS for simulating a impulse response of a second-order intertial object.
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(SecondOrderImpulseResponse.class_variable) ENABLED START #
amplification = 1.0
time_constant_1 = 1.0
time_constant_2 = 1.0
output = [0.0]
# PROTECTED REGION END # // SecondOrderImpulseResponse.class_variable
# ----------------
# Class Properties
# ----------------
# -----------------
# Device Properties
# -----------------
TimeRange = device_property(dtype='str', )
# ----------
# Attributes
# ----------
TimeConstant_1 = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
)
Amplification = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
)
TimeConstant_2 = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
)
Output = attribute(
dtype=('double', ),
max_dim_x=10000,
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(SecondOrderImpulseResponse.init_device) ENABLED START #
self.set_state(DevState.ON)
self.set_status("Second Order working!")
# PROTECTED REGION END # // SecondOrderImpulseResponse.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(SecondOrderImpulseResponse.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // SecondOrderImpulseResponse.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(SecondOrderImpulseResponse.delete_device) ENABLED START #
pass
# PROTECTED REGION END # // SecondOrderImpulseResponse.delete_device
# ------------------
# Attributes methods
# ------------------
def read_TimeConstant_1(self):
# PROTECTED REGION ID(SecondOrderImpulseResponse.TimeConstant_1_read) ENABLED START #
return self.time_constant_1
# PROTECTED REGION END # // SecondOrderImpulseResponse.TimeConstant_1_read
def write_TimeConstant_1(self, value):
# PROTECTED REGION ID(SecondOrderImpulseResponse.TimeConstant_1_write) ENABLED START #
self.time_constant_1 = value
# PROTECTED REGION END # // SecondOrderImpulseResponse.TimeConstant_1_write
def read_Amplification(self):
# PROTECTED REGION ID(SecondOrderImpulseResponse.Amplification_read) ENABLED START #
return self.amplification
# PROTECTED REGION END # // SecondOrderImpulseResponse.Amplification_read
def write_Amplification(self, value):
# PROTECTED REGION ID(SecondOrderImpulseResponse.Amplification_write) ENABLED START #
self.amplification = value
# PROTECTED REGION END # // SecondOrderImpulseResponse.Amplification_write
def read_TimeConstant_2(self):
# PROTECTED REGION ID(SecondOrderImpulseResponse.TimeConstant_2_read) ENABLED START #
return self.time_constant_2
# PROTECTED REGION END # // SecondOrderImpulseResponse.TimeConstant_2_read
def write_TimeConstant_2(self, value):
# PROTECTED REGION ID(SecondOrderImpulseResponse.TimeConstant_2_write) ENABLED START #
self.time_constant_2 = value
# PROTECTED REGION END # // SecondOrderImpulseResponse.TimeConstant_2_write
def read_Output(self):
# PROTECTED REGION ID(SecondOrderImpulseResponse.Output_read) ENABLED START #
return self.output
# PROTECTED REGION END # // SecondOrderImpulseResponse.Output_read
# --------
# Commands
# --------
@command
@DebugIt()
def CalculateResponse(self):
# PROTECTED REGION ID(SecondOrderImpulseResponse.CalculateResponse) ENABLED START #
try:
h_times = arange(0.0, float(self.TimeRange), 1)
sys = signal.lti(self.amplification,
[1, self.time_constant_1, self.time_constant_2])
impulse_response = sys.impulse(T=h_times)[1]
self.output = impulse_response
except Exception as e:
self.set_state(DevState.FAULT)
self.set_status("Exception caught in CalculateResponse:\n%s" % e)
class V4L2Camera(Device):
"""
A simple driver to obtain frames from a V4L2 Camera.
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(V4L2Camera.class_variable) ENABLED START #
# PROTECTED REGION END # // V4L2Camera.class_variable
# -----------------
# Device Properties
# -----------------
CaptureDevice = device_property(dtype='str', default_value="/dev/video0")
# ----------
# Attributes
# ----------
width = attribute(
dtype='char',
access=AttrWriteType.READ_WRITE,
)
Height = attribute(
dtype='char',
access=AttrWriteType.READ_WRITE,
)
View = attribute(
dtype=(('float', ), ),
max_dim_x=640,
max_dim_y=480,
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(V4L2Camera.init_device) ENABLED START #
self.video_capture = cv2.VideoCapture(0)
if not self.video_capture.isOpened():
self.set_status("Cannnot connect to camera")
self.debug_stream("Cannot connet to camera")
self.set_state(PyTango.DevState.FAULT)
self.set_status("Connected to camera")
self.set_state(PyTango.DevState.ON)
self.video_capture.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
self.video_capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
# PROTECTED REGION END # // V4L2Camera.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(V4L2Camera.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // V4L2Camera.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(V4L2Camera.delete_device) ENABLED START #
video_capture.release()
# PROTECTED REGION END # // V4L2Camera.delete_device
# ------------------
# Attributes methods
# ------------------
def read_width(self):
# PROTECTED REGION ID(V4L2Camera.width_read) ENABLED START #
return 0
# PROTECTED REGION END # // V4L2Camera.width_read
def write_width(self, value):
# PROTECTED REGION ID(V4L2Camera.width_write) ENABLED START #
pass
# PROTECTED REGION END # // V4L2Camera.width_write
def read_Height(self):
# PROTECTED REGION ID(V4L2Camera.Height_read) ENABLED START #
return 0
# PROTECTED REGION END # // V4L2Camera.Height_read
def write_Height(self, value):
# PROTECTED REGION ID(V4L2Camera.Height_write) ENABLED START #
pass
# PROTECTED REGION END # // V4L2Camera.Height_write
def read_View(self):
# PROTECTED REGION ID(V4L2Camera.View_read) ENABLED START #
ret, frame = self.video_capture.read()
#img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
return gray
class SKASubarray(SKAObsDevice):
"""
SubArray handling device
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(SKASubarray.class_variable) ENABLED START #
def _is_command_allowed(self, command_name):
"""Determine whether the command specified by the command_name parameter should
be allowed to execute or not.
Parameters
----------
command_name: str
The name of the command which is to be executed.
Returns
-------
True or False: boolean
A True is returned when the device is in the allowed states and modes to
execute the command. Returns False if the command name is not in the list of
commands with rules specified for them.
Raises
------
PyTango.DevFailed: If the device is not in the allowed states and/modes to
execute the command.
"""
dp = DeviceProxy(self.get_name())
obstate_labels = list(dp.attribute_query('obsState').enum_labels)
obs_idle = obstate_labels.index('IDLE')
obs_ready = obstate_labels.index('READY')
admin_labels = list(dp.attribute_query('adminMode').enum_labels)
admin_online = admin_labels.index('ON-LINE')
admin_maintenance = admin_labels.index('MAINTENANCE')
admin_offline = admin_labels.index('OFF-LINE')
admin_not_fitted = admin_labels.index('NOT-FITTED')
current_admin_mode = self.read_adminMode()
if command_name in ["ReleaseResources", "AssignResources"]:
if current_admin_mode in [admin_offline, admin_not_fitted]:
Except.throw_exception("Command failed!", "Subarray adminMode is"
" 'OFF-LINE' or 'NOT-FITTED'.",
command_name, ErrSeverity.ERR)
if self.read_obsState() == obs_idle:
if current_admin_mode in [admin_online, admin_maintenance]:
return True
else:
Except.throw_exception("Command failed!", "Subarray adminMode not"
"'ON-LINE' or not in 'MAINTENANCE'.",
command_name, ErrSeverity.ERR)
else:
Except.throw_exception("Command failed!", "Subarray obsState not 'IDLE'.",
command_name, ErrSeverity.ERR)
elif command_name in ['ConfigureCapability', 'DeconfigureCapability',
'DeconfigureAllCapabilities']:
if self.get_state() == DevState.ON and self.read_adminMode() == admin_online:
if self.read_obsState() in [obs_idle, obs_ready]:
return True
else:
Except.throw_exception(
"Command failed!", "Subarray obsState not 'IDLE' or 'READY'.",
command_name, ErrSeverity.ERR)
else:
Except.throw_exception(
"Command failed!", "Subarray State not 'ON' and/or adminMode not"
" 'ON-LINE'.", command_name, ErrSeverity.ERR)
return False
def _validate_capability_types(self, command_name, capability_types):
"""Check the validity of the input parameter passed on to the command specified
by the command_name parameter.
Parameters
----------
command_name: str
The name of the command which is to be executed.
capability_types: list
A list strings representing capability types.
Raises
------
PyTango.DevFailed: If any of the capabilities requested are not valid.
"""
invalid_capabilities = list(
set(capability_types) - set(self._configured_capabilities))
if invalid_capabilities:
Except.throw_exception(
"Command failed!", "Invalid capability types requested {}".format(
invalid_capabilities), command_name, ErrSeverity.ERR)
def _validate_input_sizes(self, command_name, argin):
"""Check the validity of the input parameters passed on to the command specified
by the command_name parameter.
Parameters
----------
command_name: str
The name of the command which is to be executed.
argin: PyTango.DevVarLongStringArray
A tuple of two lists representing [number of instances][capability types]
Raises
------
PyTango.DevFailed: If the two lists are not equal in length.
"""
capabilities_instances, capability_types = argin
if len(capabilities_instances) != len(capability_types):
Except.throw_exception("Command failed!", "Argin value lists size mismatch.",
command_name, ErrSeverity.ERR)
def is_AssignResources_allowed(self):
return self._is_command_allowed("AssignResources")
def is_ReleaseResources_allowed(self):
return self._is_command_allowed("ReleaseResources")
def is_ReleaseAllResources_allowed(self):
return self._is_command_allowed("ReleaseResources")
def is_ConfigureCapability_allowed(self):
return self._is_command_allowed('ConfigureCapability')
def is_DeconfigureCapability_allowed(self):
return self._is_command_allowed('DeconfigureCapability')
def is_DeconfigureAllCapabilities_allowed(self):
return self._is_command_allowed('DeconfigureAllCapabilities')
# PROTECTED REGION END # // SKASubarray.class_variable
# -----------------
# Device Properties
# -----------------
CapabilityTypes = device_property(
dtype=('str',),
)
SubID = device_property(
dtype='str',
)
# ----------
# Attributes
# ----------
activationTime = attribute(
dtype='double',
unit="s",
standard_unit="s",
display_unit="s",
doc="Time of activation in seconds since Unix epoch.",
)
assignedResources = attribute(
dtype=('str',),
max_dim_x=100,
doc="The list of resources assigned to the subarray.",
)
configuredCapabilities = attribute(
dtype=('str',),
max_dim_x=10,
doc="A list of capability types with no. of instances in use on this subarray; e.g.\nCorrelators:512, PssBeams:4, PstBeams:4, VlbiBeams:0.",
)
# ---------------
# General methods
# ---------------
def init_device(self):
SKAObsDevice.init_device(self)
# PROTECTED REGION ID(SKASubarray.init_device) ENABLED START #
# Initialize attribute values.
self._activation_time = 0.0
self._assigned_resources = [""]
# self._configured_capabilities is gonna be kept as a dictionary internally. The
# keys and value will represent the capability type name and the number of
# instances, respectively.
try:
self._configured_capabilities = dict.fromkeys(self.CapabilityTypes, 0)
except TypeError:
# Might need to have the device property be mandatory in the database.
self._configured_capabilities = {}
# When Subarray in not in use it reports:
self.set_state(DevState.DISABLE)
# PROTECTED REGION END # // SKASubarray.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(SKASubarray.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // SKASubarray.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(SKASubarray.delete_device) ENABLED START #
pass
# PROTECTED REGION END # // SKASubarray.delete_device
# ------------------
# Attributes methods
# ------------------
def read_activationTime(self):
# PROTECTED REGION ID(SKASubarray.activationTime_read) ENABLED START #
return self._activation_time
# PROTECTED REGION END # // SKASubarray.activationTime_read
def read_assignedResources(self):
# PROTECTED REGION ID(SKASubarray.assignedResources_read) ENABLED START #
return self._assigned_resources
# PROTECTED REGION END # // SKASubarray.assignedResources_read
def read_configuredCapabilities(self):
# PROTECTED REGION ID(SKASubarray.configuredCapabilities_read) ENABLED START #
configured_capabilities = []
for capability_type, capability_instances in (
self._configured_capabilities.items()):
configured_capabilities.append(
"{}:{}".format(capability_type, capability_instances))
return sorted(configured_capabilities)
# PROTECTED REGION END # // SKASubarray.configuredCapabilities_read
# --------
# Commands
# --------
@command(
)
@DebugIt()
def Abort(self):
# PROTECTED REGION ID(SKASubarray.Abort) ENABLED START #
pass
# PROTECTED REGION END # // SKASubarray.Abort
@command(
dtype_in='DevVarLongStringArray',
doc_in="[Number of instances to add][Capability types]",
)
@DebugIt()
def ConfigureCapability(self, argin):
# PROTECTED REGION ID(SKASubarray.ConfigureCapability) ENABLED START #
command_name = 'ConfigureCapability'
dp = DeviceProxy(self.get_name())
obstate_labels = list(dp.attribute_query('obsState').enum_labels)
obs_configuring = obstate_labels.index('CONFIGURING')
capabilities_instances, capability_types = argin
self._validate_capability_types(command_name, capability_types)
self._validate_input_sizes(command_name, argin)
# Set obsState to 'CONFIGURING'.
self._obs_state = obs_configuring
# Perform the configuration.
for capability_instances, capability_type in izip(
capabilities_instances, capability_types):
self._configured_capabilities[capability_type] += capability_instances
# Change the obsState to 'READY'.
obs_ready = obstate_labels.index('READY')
self._obs_state = obs_ready
# PROTECTED REGION END # // SKASubarray.ConfigureCapability
@command(
dtype_in='str',
doc_in="Capability type",
)
@DebugIt()
def DeconfigureAllCapabilities(self, argin):
# PROTECTED REGION ID(SKASubarray.DeconfigureAllCapabilities) ENABLED START #i
self._validate_capability_types('DeconfigureAllCapabilities', [argin])
self._configured_capabilities[argin] = 0
# PROTECTED REGION END # // SKASubarray.DeconfigureAllCapabilities
@command(
dtype_in='DevVarLongStringArray',
doc_in="[Number of instances to remove][Capability types]",
)
@DebugIt()
def DeconfigureCapability(self, argin):
# PROTECTED REGION ID(SKASubarray.DeconfigureCapability) ENABLED START #
command_name = 'DeconfigureCapability'
capabilities_instances, capability_types = argin
self._validate_capability_types(command_name, capability_types)
self._validate_input_sizes(command_name, argin)
# Perform the deconfiguration
for capability_instances, capability_type in izip(
capabilities_instances, capability_types):
if self._configured_capabilities[capability_type] < int(capability_instances):
self._configured_capabilities[capability_type] = 0
else:
self._configured_capabilities[capability_type] -= (
int(capability_instances))
# PROTECTED REGION END # // SKASubarray.DeconfigureCapability
@command(
dtype_in=('str',),
doc_in="List of Resources to add to subarray.",
dtype_out=('str',),
doc_out="A list of Resources added to the subarray.",
)
@DebugIt()
def AssignResources(self, argin):
# PROTECTED REGION ID(SKASubarray.AssignResources) ENABLED START #
argout = []
resources = self._assigned_resources[:]
for resource in argin:
if resource not in resources:
self._assigned_resources.append(resource)
argout.append(resource)
return argout
@command(
dtype_in=('str',),
doc_in="List of resources to remove from the subarray.",
dtype_out=('str',),
doc_out="List of resources removed from the subarray.",
)
@DebugIt()
def ReleaseResources(self, argin):
# PROTECTED REGION ID(SKASubarray.ReleaseResources) ENABLED START #
argout = []
# Release resources...
resources = self._assigned_resources[:]
for resource in argin:
if resource in resources:
self._assigned_resources.remove(resource)
argout.append(resource)
return argout
# PROTECTED REGION END # // SKASubarray.ReleaseResources
@command(
)
@DebugIt()
def EndSB(self):
# PROTECTED REGION ID(SKASubarray.EndSB) ENABLED START #
pass
# PROTECTED REGION END # // SKASubarray.EndSB
@command(
)
@DebugIt()
def EndScan(self):
# PROTECTED REGION ID(SKASubarray.EndScan) ENABLED START #
pass
# PROTECTED REGION END # // SKASubarray.EndScan
@command(
)
@DebugIt()
def Pause(self):
# PROTECTED REGION ID(SKASubarray.Pause) ENABLED START #
pass
# PROTECTED REGION END # // SKASubarray.Pause
@command(
dtype_out=('str',),
doc_out="List of resources removed from the subarray.",
)
@DebugIt()
def ReleaseAllResources(self):
# PROTECTED REGION ID(SKASubarray.ReleaseAllResources) ENABLED START #
resources = self._assigned_resources[:]
released_resources = self.ReleaseResources(resources)
return released_resources
# PROTECTED REGION END # // SKASubarray.ReleaseAllResources
@command(
dtype_in=('str',),
doc_in="List of resources to remove from the subarray.",
dtype_out=('str',),
doc_out="List of resources removed from the subarray.",
)
@DebugIt()
def ReleaseResources(self, argin):
# PROTECTED REGION ID(SKASubarray.ReleaseResources) ENABLED START #
return [""]
# PROTECTED REGION END # // SKASubarray.ReleaseResources
@command(
)
@DebugIt()
def Resume(self):
# PROTECTED REGION ID(SKASubarray.Resume) ENABLED START #
pass
# PROTECTED REGION END # // SKASubarray.Resume
@command(
dtype_in=('str',),
)
@DebugIt()
def Scan(self, argin):
# PROTECTED REGION ID(SKASubarray.Scan) ENABLED START #
pass
class SpectrometerCameraDS(Device):
__metaclass__ = DeviceMeta
exposuretime = attribute(
label='ExposureTime',
dtype=float,
access=tango.AttrWriteType.READ_WRITE,
unit="us",
format="%8.1f",
min_value=0.0,
max_value=1e7,
fget="get_exposuretime",
fset="set_exposuretime",
doc="Camera exposure time in us",
memorized=True,
)
gain = attribute(
label='Gain',
dtype=float,
access=tango.AttrWriteType.READ_WRITE,
unit="dB",
format="%3.2f",
min_value=0.0,
max_value=1e2,
fget="get_gain",
fset="set_gain",
doc="Camera gain in dB",
memorized=True,
)
wavelengthvector = attribute(
label='WavelengthVector',
dtype=[np.double],
access=tango.AttrWriteType.READ,
max_dim_x=16384,
display_level=tango.DispLevel.OPERATOR,
unit="m",
format="%5.2e",
fget="get_wavelengthvector",
doc="Wavelength vector",
)
spectrum = attribute(
label='Spectrum',
dtype=[np.double],
access=tango.AttrWriteType.READ,
max_dim_x=16384,
display_level=tango.DispLevel.OPERATOR,
unit="a.u.",
format="%5.2f",
fget="get_spectrum",
doc="Spectrum",
)
width = attribute(
label='Spectrum width FWHM',
dtype=np.double,
access=tango.AttrWriteType.READ,
display_level=tango.DispLevel.OPERATOR,
unit="m",
format="%5.2e",
fget="get_width",
doc=
"FWHM for the peak in spectrum. Basic thresholding and peak detection is used.",
)
peak = attribute(
label='Spectrum peak',
dtype=np.double,
access=tango.AttrWriteType.READ,
display_level=tango.DispLevel.OPERATOR,
unit="m",
format="%5.2e",
fget="get_peak",
doc=
"Wavelength for the peak in spectrum. Basic thresholding and peak detection is used.",
)
sat_lvl = attribute(
label='Saturation level',
dtype=np.double,
access=tango.AttrWriteType.READ,
display_level=tango.DispLevel.OPERATOR,
unit="relative",
format="%2.2e",
fget="get_satlvl",
doc=
"Relative amount of pixels that are saturated. This should be zero.",
)
camera_name = device_property(
dtype=str,
doc="Tango name of the camera device",
default_value="gunlaser/cameras/spectrometer_camera")
watchdog_timeout = device_property(
dtype=float,
doc="Timeout for the watchdog resetting the hardware in s",
default_value="2.0")
dispersion = device_property(
dtype=float,
doc="Dispersion of the spectrometer in nm/px. "
"Positive if wavelength increases to the right",
default_value="0.056")
central_wavelength = device_property(
dtype=float,
doc="Wavelength of the central pixel of the ROI in nm",
default_value="2.0")
roi = device_property(
dtype=[int],
doc="Pixel coordinates for the ROI: [left, top, width, height]",
default_value=[0, 0, 100, 100])
saturation_level = device_property(
dtype=int,
doc="Saturation pixel value, used for estimating overexposure",
default_value=65536)
def __init__(self, klass, name):
self.wavelengthvector_data = np.array([])
self.max_value = 1.0
self.controller = None # type: SpectrometerCameraController
self.state_dispatcher = None # type: StateDispatcher
self.db = None
Device.__init__(self, klass, name)
def init_device(self):
self.debug_stream("In init_device:")
Device.init_device(self)
self.db = tango.Database()
self.set_state(tango.DevState.UNKNOWN)
try:
if self.state_dispatcher is not None:
self.state_dispatcher.stop()
except Exception as e:
self.error_info("Error stopping state dispatcher: {0}".format(e))
try:
self.controller = SpectrometerCameraController(self.camera_name)
self.controller.add_state_notifier(self.change_state)
except Exception as e:
self.error_stream(
"Error creating camera controller: {0}".format(e))
return
self.setup_params()
self.setup_spectrometer()
self.state_dispatcher = StateDispatcher(self.controller)
self.state_dispatcher.start()
self.debug_stream("init_device finished")
def setup_params(self):
params = dict()
params["imageoffsetx"] = self.roi[0]
params["imageoffsety"] = self.roi[1]
params["imagewidth"] = self.roi[2]
params["imageheight"] = self.roi[3]
params["triggermode"] = "Off"
self.controller.setup_params = params
def setup_spectrometer(self):
self.info_stream("Entering setup_camera")
self.wavelengthvector_data = (self.central_wavelength + np.arange(
-self.roi[2] / 2, self.roi[2] / 2) * self.dispersion) * 1e-9
self.max_value = self.saturation_level
wavelength_attr = tango.DeviceAttribute()
wavelength_attr.name = "wavelengths"
wavelength_attr.quality = tango.AttrQuality.ATTR_VALID
wavelength_attr.value = self.wavelengthvector_data
# wavelength_attr.data_format = tango.AttrDataFormat.SPECTRUM
wavelength_attr.time = tango.time_val.TimeVal(time.time())
max_value_attr = tango.DeviceAttribute()
max_value_attr.name = "max_value"
max_value_attr.quality = tango.AttrQuality.ATTR_VALID
max_value_attr.value = self.max_value
# max_value_attr.data_format = tango.AttrDataFormat.SCALAR
max_value_attr.time = tango.time_val.TimeVal(time.time())
with self.controller.state_lock:
self.controller.camera_result["wavelengths"] = wavelength_attr
self.controller.camera_result["max_value"] = max_value_attr
def change_state(self, new_state, new_status=None):
self.info_stream("Change state: {0}, status {1}".format(
new_state, new_status))
# Map new_state string to tango state
if new_state in ["running"]:
tango_state = tango.DevState.RUNNING
elif new_state in ["on"]:
tango_state = tango.DevState.ON
elif new_state in ["device_connect", "setup_attributes"]:
tango_state = tango.DevState.INIT
elif new_state in ["fault"]:
tango_state = tango.DevState.FAULT
else:
tango_state = tango.DevState.UNKNOWN
# Set memorized attributes when entering init from unknown state:
if self.get_state(
) is tango.DevState.INIT and new_state is not tango.DevState.UNKNOWN:
self.debug_stream("Set memorized attributes")
try:
data = self.db.get_device_attribute_property(
self.get_name(), "gain")
self.debug_stream(
"Database returned data for \"gain\": {0}".format(
data["gain"]))
except TypeError as e:
self.warn_stream("Gain not found in database. {0}".format(e))
try:
new_value = float(data["gain"]["__value"][0])
self.debug_stream("{0}".format(new_value))
self.controller.write_attribute("gain", "camera", new_value)
except (KeyError, TypeError, IndexError, ValueError):
pass
try:
data = self.db.get_device_attribute_property(
self.get_name(), "exposuretime")
self.debug_stream(
"Database returned data for \"exposuretime\": {0}".format(
data["exposuretime"]))
except TypeError as e:
self.warn_stream(
"Exposuretime not found in database. {0}".format(e))
try:
new_value = float(data["exposuretime"]["__value"][0])
self.controller.write_attribute("exposuretime", "camera",
new_value)
except (KeyError, TypeError, IndexError, ValueError):
pass
if tango_state != self.get_state():
self.debug_stream("Change state from {0} to {1}".format(
self.get_state(), new_state))
self.set_state(tango_state)
if new_status is not None:
self.debug_stream("Setting status {0}".format(new_status))
self.set_status(new_status)
def get_spectrum(self):
attr = self.controller.get_attribute("spectrum")
try:
self.debug_stream("get_spectrum: {0}".format(attr.value.shape))
except Exception as e:
self.warn_stream("Could not format attribute: {0}".format(e))
return attr.value, attr.time.totime(), attr.quality
def get_wavelengthvector(self):
self.debug_stream("get_wavelengthvector: size {0}".format(
self.wavelengthvector_data.shape))
attr = self.controller.get_attribute("wavelengths")
return attr.value, attr.time.totime(), attr.quality
def get_exposuretime(self):
attr = self.controller.get_attribute("exposuretime")
try:
self.debug_stream("get_exposuretime: {0}".format(attr))
except Exception as e:
self.warn_stream("Could not format attribute: {0}".format(e))
return attr.value, attr.time.totime(), attr.quality
def set_exposuretime(self, new_exposuretime):
self.debug_stream(
"In set_exposuretime: New value {0}".format(new_exposuretime))
# self.controller.write_attribute("exposuretime", "camera", new_exposuretime)
try:
old_exposure = self.controller.get_attribute("exposuretime").value
except AttributeError:
old_exposure = 0.0
tol = np.abs(new_exposuretime - old_exposure) * 0.1
self.controller.check_attribute("exposuretime",
"camera",
new_exposuretime,
tolerance=tol,
write=True)
def get_gain(self):
attr = self.controller.get_attribute("gain")
return attr.value, attr.time.totime(), attr.quality
def set_gain(self, new_gain):
self.debug_stream("In set_gain: New value {0}".format(new_gain))
self.controller.write_attribute("gain", "camera", new_gain)
self.controller.read_attribute("gain", "camera")
def get_width(self):
attr = self.controller.get_attribute("width")
return attr.value, attr.time.totime(), attr.quality
def get_peak(self):
attr = self.controller.get_attribute("peak")
return attr.value, attr.time.totime(), attr.quality
def get_satlvl(self):
attr = self.controller.get_attribute("satlvl")
return attr.value, attr.time.totime(), attr.quality
@command(doc_in="Start spectrometer.")
def start(self):
"""Start spectrometer camera"""
self.info_stream("Starting spectrometer")
self.state_dispatcher.send_command("start")
@command(doc_in="Stop spectrometer.")
def stop(self):
"""Stop spectrometer camera"""
self.info_stream("Stopping spectrometer")
self.state_dispatcher.send_command("stop")
class SKACapability(SKAObsDevice):
"""
Subarray handling device
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(SKACapability.class_variable) ENABLED START #
# PROTECTED REGION END # // SKACapability.class_variable
# -----------------
# Device Properties
# -----------------
CapType = device_property(dtype='str', )
CapID = device_property(dtype='str', )
subID = device_property(dtype='str', )
# ----------
# Attributes
# ----------
activationTime = attribute(
dtype='double',
unit="s",
standard_unit="s",
display_unit="s",
doc="Time of activation in seconds since Unix epoch.",
)
configuredInstances = attribute(
dtype='uint16',
doc=
"Number of instances of this Capability Type currently in use on this subarray.",
)
usedComponents = attribute(
dtype=('str', ),
max_dim_x=100,
doc=
"A list of components with no. of instances in use on this Capability.",
)
# ---------------
# General methods
# ---------------
def init_device(self):
SKAObsDevice.init_device(self)
# PROTECTED REGION ID(SKACapability.init_device) ENABLED START #
self._activation_time = 0.0
self._configured_instances = 0
self._used_components = [""]
# PROTECTED REGION END # // SKACapability.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(SKACapability.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // SKACapability.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(SKACapability.delete_device) ENABLED START #
pass
# PROTECTED REGION END # // SKACapability.delete_device
# ------------------
# Attributes methods
# ------------------
def read_activationTime(self):
# PROTECTED REGION ID(SKACapability.activationTime_read) ENABLED START #
return self._activation_time
# PROTECTED REGION END # // SKACapability.activationTime_read
def read_configuredInstances(self):
# PROTECTED REGION ID(SKACapability.configuredInstances_read) ENABLED START #
return self._configured_instances
# PROTECTED REGION END # // SKACapability.configuredInstances_read
def read_usedComponents(self):
# PROTECTED REGION ID(SKACapability.usedComponents_read) ENABLED START #
return self._used_components
# PROTECTED REGION END # // SKACapability.usedComponents_read
# --------
# Commands
# --------
@command(
dtype_in='uint16',
doc_in="The number of instances to configure for this Capability.",
)
@DebugIt()
def ConfigureInstances(self, argin):
# PROTECTED REGION ID(SKACapability.ConfigureInstances) ENABLED START #
self._configured_instances = argin
class TangoTestDeviceServerBase(Device):
__metaclass__ = DeviceMeta
instances = weakref.WeakValueDictionary()
model_key = device_property(
dtype=str,
doc=
"Simulator model key, usually the TANGO name of the simulated device.")
def __init__(self, dev_class, name):
super(TangoTestDeviceServerBase, self).__init__(dev_class, name)
self.model = None
self._attribute_name = ''
self.model_quantity = None
self._pause_active = False
self.sim_device_attributes = None
self.init_device()
def init_device(self):
super(TangoTestDeviceServerBase, self).init_device()
name = self.get_name()
self.instances[name] = self
try:
self.model = model.model_registry[self.model_key]
except KeyError:
raise RuntimeError(
'Could not find model with device name or key '
'{}. Set the "model_key" device property to the '
'correct value.'.format(self.model_key))
self.sim_device_attributes = self.model.sim_quantities.keys()
self.set_state(DevState.ON)
def initialize_dynamic_attributes(self):
"""The device method that sets up attributes during run time"""
# Get attributes to control the device model quantities
# from class variables of the quantities included in the device model.
models = set(
[quant.__class__ for quant in self.model.sim_quantities.values()])
control_attributes = []
for cls in models:
control_attributes += [attr for attr in cls.adjustable_attributes]
# Add a list of float attributes from the list of Guassian variables
for attribute_name in control_attributes:
model.MODULE_LOGGER.info(
"Added weather {} attribute control".format(attribute_name))
attr_props = UserDefaultAttrProp()
attr = Attr(attribute_name, DevDouble, AttrWriteType.READ_WRITE)
attr.set_default_properties(attr_props)
self.add_attribute(attr, self.read_attributes,
self.write_attributes)
# Static attributes of the device
@attribute(dtype=bool)
def pause_active(self):
return self._pause_active
@pause_active.write
def pause_active(self, is_active):
self._pause_active = is_active
setattr(self.model, 'paused', is_active)
def read_attributes(self, attr):
"""Method reading an attribute value
Parameters
----------
attr : PyTango.DevAttr
The attribute to read from.
"""
name = attr.get_name()
self.info_stream("Reading attribute %s", name)
attr.set_value(getattr(self.model_quantity, name))
def write_attributes(self, attr):
"""Method writing an attribute value
Parameters
----------
attr : PyTango.DevAttr
The attribute to write to.
"""
name = attr.get_name()
data = attr.get_write_value()
self.info_stream("Writing attribute {} with value: {}".format(
name, data))
if name == 'last_val':
self.model_quantity.set_val(data, self.model.time_func())
else:
setattr(self.model_quantity, name, data)
class ElmitecLEEM2k(Device):
"""
Device server for accessing the settings of the LEEM2000 program from Elmitec.
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(ElmitecLEEM2k.class_variable) ENABLED START #
ElmitecLEEM2kConnected = False
def TCPBlockingReceive(self):
Bytereceived = '0'
szData = ''
while ord(Bytereceived) != 0:
ReceivedLength = 0
while ReceivedLength == 0:
Bytereceived = self.s.recv(1)
#print 'Bytereceived=',Bytereceived,'ord(Bytereceived)=',ord(Bytereceived)
ReceivedLength = len(Bytereceived)
if ord(Bytereceived) != 0:
szData = szData + Bytereceived
return szData
def connect(self):
if self.ElmitecLEEM2kConnected:
return
else:
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
#self.s.connect((self.IP, self.Port))
self.s.connect(("leem.labo", 5566))
except:
self.ElmitecLEEM2kConnected = False
self.set_state(PyTango.DevState.FAULT)
self.set_status("Can't connect to ElmitecLEEM2k")
self.debug_stream("Can't connect to ElmitecLEEM2k")
return
#Start string communication
TCPString = 'asc'
self.s.send(TCPString)
data = self.TCPBlockingReceive()
self.ElmitecLEEM2kConnected = True
self.set_state(PyTango.DevState.ON)
self.set_status("Connected to ElmitecLEEM2k")
self.debug_stream("Connected to ElmitecLEEM2k")
def disconnect(self):
if self.ElmitecLEEM2kConnected:
self.s.send('clo')
self.s.close()
self.ElmitecLEEM2kConnected = False
self.debug_stream("Disconnected!")
# PROTECTED REGION END # // ElmitecLEEM2k.class_variable
# -----------------
# Device Properties
# -----------------
IP = device_property(dtype='str', )
Port = device_property(dtype='uint16', )
# ----------
# Attributes
# ----------
Objective = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
standard_unit="mA",
)
Preset = attribute(
dtype='str',
access=AttrWriteType.READ_WRITE,
)
StartVoltage = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
standard_unit="V",
)
TransferLens = attribute(
dtype='double',
standard_unit="mA",
)
FieldLens = attribute(
dtype='double',
standard_unit="mA",
)
IntermLens = attribute(
dtype='double',
standard_unit="mA",
)
P1Lens = attribute(
dtype='double',
standard_unit="mA",
)
P2Lens = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
standard_unit="mA",
)
SampleTemperature = attribute(
dtype='double',
standard_unit="ºC",
)
ChannelPlateVoltage = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
standard_unit="kV",
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(ElmitecLEEM2k.init_device) ENABLED START #
self.connect()
# PROTECTED REGION END # // ElmitecLEEM2k.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(ElmitecLEEM2k.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // ElmitecLEEM2k.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(ElmitecLEEM2k.delete_device) ENABLED START #
self.disconnect()
self.set_state(PyTango.DevState.OFF)
# PROTECTED REGION END # // ElmitecLEEM2k.delete_device
# ------------------
# Attributes methods
# ------------------
def read_Objective(self):
# PROTECTED REGION ID(ElmitecLEEM2k.Objective_read) ENABLED START #
self.s.send("val 11")
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.Objective_read
def write_Objective(self, value):
# PROTECTED REGION ID(ElmitecLEEM2k.Objective_write) ENABLED START #
self.s.send("val 11 " + str(value))
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.Objective_write
def read_Preset(self):
# PROTECTED REGION ID(ElmitecLEEM2k.Preset_read) ENABLED START #
self.s.send("prl")
data = self.TCPBlockingReceive()
return data
# PROTECTED REGION END # // ElmitecLEEM2k.Preset_read
def write_Preset(self, value):
# PROTECTED REGION ID(ElmitecLEEM2k.Preset_write) ENABLED START #
#self.s.send("sep "+str(value))
#data = self.TCPBlockingReceive()
#return data
pass
# PROTECTED REGION END # // ElmitecLEEM2k.Preset_write
def read_StartVoltage(self):
# PROTECTED REGION ID(ElmitecLEEM2k.StartVoltage_read) ENABLED START #
self.s.send("val 38")
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.StartVoltage_read
def write_StartVoltage(self, value):
# PROTECTED REGION ID(ElmitecLEEM2k.StartVoltage_write) ENABLED START #
self.s.send("val 38 " + str(value))
data = self.TCPBlockingReceive()
# PROTECTED REGION END # // ElmitecLEEM2k.StartVoltage_write
def read_TransferLens(self):
# PROTECTED REGION ID(ElmitecLEEM2k.TransferLens_read) ENABLED START #
self.s.send("val 14")
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.TransferLens_read
def read_FieldLens(self):
# PROTECTED REGION ID(ElmitecLEEM2k.FieldLens_read) ENABLED START #
self.s.send("val 19")
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.FieldLens_read
def read_IntermLens(self):
# PROTECTED REGION ID(ElmitecLEEM2k.IntermLens_read) ENABLED START #
self.s.send("val 21")
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.IntermLens_read
def read_P1Lens(self):
# PROTECTED REGION ID(ElmitecLEEM2k.P1Lens_read) ENABLED START #
self.s.send("val 24")
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.P1Lens_read
def read_P2Lens(self):
# PROTECTED REGION ID(ElmitecLEEM2k.P2Lens_read) ENABLED START #
self.s.send("val 27")
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.P2Lens_read
def write_P2Lens(self, value):
# PROTECTED REGION ID(ElmitecLEEM2k.P2Lens_write) ENABLED START #
self.s.send("val 27 " + str(value))
data = self.TCPBlockingReceive()
# PROTECTED REGION END # // ElmitecLEEM2k.P2Lens_write
def read_SampleTemperature(self):
# PROTECTED REGION ID(ElmitecLEEM2k.SampleTemperature_read) ENABLED START #
self.s.send("val 39")
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.SampleTemperature_read
def read_ChannelPlateVoltage(self):
# PROTECTED REGION ID(ElmitecLEEM2k.ChannelPlateVoltage_read) ENABLED START #
self.s.send("val 105")
data = self.TCPBlockingReceive()
return float(data)
# PROTECTED REGION END # // ElmitecLEEM2k.ChannelPlateVoltage_read
def write_ChannelPlateVoltage(self, value):
# PROTECTED REGION ID(ElmitecLEEM2k.ChannelPlateVoltage_write) ENABLED START #
#self.s.send("val 105 "+str(value))
#data = self.TCPBlockingReceive()
pass
# PROTECTED REGION END # // ElmitecLEEM2k.ChannelPlateVoltage_write
# --------
# Commands
# --------
@command(
dtype_in='str',
dtype_out='str',
display_level=DispLevel.EXPERT,
)
@DebugIt()
def sendCommand(self, argin):
# PROTECTED REGION ID(ElmitecLEEM2k.sendCommand) ENABLED START #
self.s.send(argin)
data = self.TCPBlockingReceive()
return data
class HuttingerPFGDC(Device):
"""
Driver for the Huttinger DC generators, such as the PFG-DC1500, a 1500W 1KV power supply for magnetron sputtering growth.
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(HuttingerPFGDC.class_variable) ENABLED START #
def sendcommand(self, address, command, data):
# Asume command is an string in hexadecimal, say C4
# address is 0 for generator, 1 for matchbox
cmd = struct.pack(">BBH", address, int(command, 16), data)
cmd_string = cmd + self.crc_code(cmd)
self.ser.write(cmd_string)
return (self.ser.read(5))
def parse_response(self, resp):
(address, cmd, data, crc) = struct.unpack(">BBHB", resp)
cmd = ord(resp[1])
if (cmd == 21):
command = "NACK"
elif (cmd == 6):
command = "ACK"
else:
command = "%x" % ord(resp[1])
return (address, command, data)
def byte_hex(self, a):
return ("%02x" % ord(a))
def crc_code(self, a):
result = 0
for i in range(0, len(a)):
result = result ^ ord(a[i])
return (struct.pack(">B", result))
# PROTECTED REGION END # // HuttingerPFGDC.class_variable
# -----------------
# Device Properties
# -----------------
SerialPort = device_property(dtype='str', mandatory=True)
# ----------
# Attributes
# ----------
NominalPower = attribute(
dtype='uint16',
access=AttrWriteType.READ_WRITE,
label="Nominal Power",
unit="W",
standard_unit="W",
display_unit="W",
max_value=150,
min_value=0,
)
NominalVoltage = attribute(
dtype='uint16',
access=AttrWriteType.READ_WRITE,
label="Nominal Voltage",
unit="V",
standard_unit="V",
display_unit="V",
format="%d",
max_value=1000,
min_value=0,
)
NominalCurrent = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
label="Nominal Current",
unit="A",
standard_unit="A",
display_unit="A",
format="%4.2f",
max_value=3.5,
min_value=0,
)
InitialPower = attribute(
dtype='uint16',
access=AttrWriteType.READ_WRITE,
label="Initial Power",
unit="W",
standard_unit="W",
display_unit="W",
max_value=1500,
min_value=0,
)
InitialVoltage = attribute(
dtype='uint16',
access=AttrWriteType.READ_WRITE,
label="Initial Voltage",
unit="V",
standard_unit="V",
display_unit="V",
max_value=1000,
min_value=0,
)
InitialCurrent = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
label="Initial Current",
unit="A",
standard_unit="A",
display_unit="A",
format="%4.2f",
)
VoltageRange = attribute(
dtype='uint16',
label="Voltage Range",
max_value=4,
min_value=1,
doc="(1=375V, 2=500V, 3=750V, 4=1000V)",
)
ArcDetection = attribute(
dtype='char',
access=AttrWriteType.READ_WRITE,
display_level=DispLevel.EXPERT,
label="ArcDetection",
)
RampTime = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
label="RampTime",
unit="s",
standard_unit="s",
display_unit="s",
format="%4.1f",
max_value=3200.0,
min_value=0.0,
doc="(1=power, 2=voltage, 3=current)",
)
ArcDetectionLevel = attribute(
dtype='char',
access=AttrWriteType.READ_WRITE,
display_level=DispLevel.EXPERT,
label="Level",
max_value=3,
min_value=1,
)
ArcDetectionPause = attribute(
dtype='char',
access=AttrWriteType.READ_WRITE,
display_level=DispLevel.EXPERT,
label="ArcDetectionPause",
max_value=3,
min_value=1,
)
RampType = attribute(
dtype='char',
access=AttrWriteType.READ_WRITE,
label="RampType",
max_value=3,
min_value=1,
doc="(1=power, 2=voltage, 3=current)",
)
Power = attribute(
dtype='double',
label="Power",
unit="W",
standard_unit="W",
display_unit="W",
)
Voltage = attribute(
dtype='double',
label="Voltage",
unit="V",
standard_unit="V",
display_unit="V",
)
Current = attribute(
dtype='double',
label="Current",
unit="A",
standard_unit="A",
display_unit="A",
)
Arcs = attribute(
dtype='double',
display_level=DispLevel.EXPERT,
label="Arcs",
)
OperationMode = attribute(
dtype='uint16',
access=AttrWriteType.READ_WRITE,
display_level=DispLevel.EXPERT,
label="OperationMode",
max_value=2,
min_value=0,
doc="(0=OFF;1=On;\n2=On+Ramp)",
)
Control = attribute(
dtype='uint16',
access=AttrWriteType.READ_WRITE,
display_level=DispLevel.EXPERT,
max_value=5,
min_value=1,
doc="(1=LOCAL, 2=REALTIME,\n3=REMOTE, 4=RS232,\n5=RS485)",
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(HuttingerPFGDC.init_device) ENABLED START #
self.ser = serial.Serial(self.SerialPort,
baudrate=9600,
bytesize=8,
parity="N",
stopbits=1,
timeout=0.5)
(address, command,
data) = self.parse_response(self.sendcommand(0, "4E", 4))
(address, command,
data) = self.parse_response(self.sendcommand(0, "4F", 0))
self.set_state(PyTango.DevState.OFF)
if (command != "ACK"):
self.set_state(PyTango.DevState.FAULT)
# PROTECTED REGION END # // HuttingerPFGDC.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(HuttingerPFGDC.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // HuttingerPFGDC.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(HuttingerPFGDC.delete_device) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "4F", 0))
self.ser.close()
# PROTECTED REGION END # // HuttingerPFGDC.delete_device
# ------------------
# Attributes methods
# ------------------
def read_NominalPower(self):
# PROTECTED REGION ID(HuttingerPFGDC.NominalPower_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "C1", 0))
return data * 10
# PROTECTED REGION END # // HuttingerPFGDC.NominalPower_read
def write_NominalPower(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.NominalPower_write) ENABLED START #
(address, command, data) = self.parse_response(
self.sendcommand(0, "41", int(value / 10.0)))
# PROTECTED REGION END # // HuttingerPFGDC.NominalPower_write
def read_NominalVoltage(self):
# PROTECTED REGION ID(HuttingerPFGDC.NominalVoltage_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "C2", 4))
return data
# PROTECTED REGION END # // HuttingerPFGDC.NominalVoltage_read
def write_NominalVoltage(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.NominalVoltage_write) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "42", int(value)))
# PROTECTED REGION END # // HuttingerPFGDC.NominalVoltage_write
def read_NominalCurrent(self):
# PROTECTED REGION ID(HuttingerPFGDC.NominalCurrent_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "C3", 4))
return data / 100.0
# PROTECTED REGION END # // HuttingerPFGDC.NominalCurrent_read
def write_NominalCurrent(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.NominalCurrent_write) ENABLED START #
(address, command, data) = self.parse_response(
self.sendcommand(0, "43", int(value * 100.0)))
# PROTECTED REGION END # // HuttingerPFGDC.NominalCurrent_write
def read_InitialPower(self):
# PROTECTED REGION ID(HuttingerPFGDC.InitialPower_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "C4", 4))
return data * 10
# PROTECTED REGION END # // HuttingerPFGDC.InitialPower_read
def write_InitialPower(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.InitialPower_write) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "44",
int(value / 10)))
# PROTECTED REGION END # // HuttingerPFGDC.InitialPower_write
def read_InitialVoltage(self):
# PROTECTED REGION ID(HuttingerPFGDC.InitialVoltage_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "C5", 4))
return data
# PROTECTED REGION END # // HuttingerPFGDC.InitialVoltage_read
def write_InitialVoltage(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.InitialVoltage_write) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "45", int(value)))
# PROTECTED REGION END # // HuttingerPFGDC.InitialVoltage_write
def read_InitialCurrent(self):
# PROTECTED REGION ID(HuttingerPFGDC.InitialCurrent_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "C6", 4))
return data / 100.0
# PROTECTED REGION END # // HuttingerPFGDC.InitialCurrent_read
def write_InitialCurrent(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.InitialCurrent_write) ENABLED START #
(address, command, data) = self.parse_response(
self.sendcommand(0, "46", int(value * 100)))
# PROTECTED REGION END # // HuttingerPFGDC.InitialCurrent_write
def read_VoltageRange(self):
# PROTECTED REGION ID(HuttingerPFGDC.VoltageRange_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "C8", 4))
return data
# PROTECTED REGION END # // HuttingerPFGDC.VoltageRange_read
def read_ArcDetection(self):
# PROTECTED REGION ID(HuttingerPFGDC.ArcDetection_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "C9", 4))
return data
# PROTECTED REGION END # // HuttingerPFGDC.ArcDetection_read
def write_ArcDetection(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.ArcDetection_write) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "49", value))
# PROTECTED REGION END # // HuttingerPFGDC.ArcDetection_write
def read_RampTime(self):
# PROTECTED REGION ID(HuttingerPFGDC.RampTime_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "CA", 0))
return data / 10.0
# PROTECTED REGION END # // HuttingerPFGDC.RampTime_read
def write_RampTime(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.RampTime_write) ENABLED START #
(address, command, data) = self.parse_response(
self.sendcommand(0, "4A", int(value * 10.0)))
# PROTECTED REGION END # // HuttingerPFGDC.RampTime_write
def read_ArcDetectionLevel(self):
# PROTECTED REGION ID(HuttingerPFGDC.ArcDetectionLevel_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "CB", 4))
return data
# PROTECTED REGION END # // HuttingerPFGDC.ArcDetectionLevel_read
def write_ArcDetectionLevel(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.ArcDetectionLevel_write) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "4B", value))
# PROTECTED REGION END # // HuttingerPFGDC.ArcDetectionLevel_write
def read_ArcDetectionPause(self):
# PROTECTED REGION ID(HuttingerPFGDC.ArcDetectionPause_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "CC", 4))
return data
# PROTECTED REGION END # // HuttingerPFGDC.ArcDetectionPause_read
def write_ArcDetectionPause(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.ArcDetectionPause_write) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "4C", value))
# PROTECTED REGION END # // HuttingerPFGDC.ArcDetectionPause_write
def read_RampType(self):
# PROTECTED REGION ID(HuttingerPFGDC.RampType_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "CD", 4))
return data
# PROTECTED REGION END # // HuttingerPFGDC.RampType_read
def write_RampType(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.RampType_write) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "4D", value))
# PROTECTED REGION END # // HuttingerPFGDC.RampType_write
def read_Power(self):
# PROTECTED REGION ID(HuttingerPFGDC.Power_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "D1", 4))
return data * 10.0
# PROTECTED REGION END # // HuttingerPFGDC.Power_read
def read_Voltage(self):
# PROTECTED REGION ID(HuttingerPFGDC.Voltage_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "D2", 4))
return data
# PROTECTED REGION END # // HuttingerPFGDC.Voltage_read
def read_Current(self):
# PROTECTED REGION ID(HuttingerPFGDC.Current_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "D3", 4))
return data / 100.0
# PROTECTED REGION END # // HuttingerPFGDC.Current_read
def read_Arcs(self):
# PROTECTED REGION ID(HuttingerPFGDC.Arcs_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "D9", 4))
return data
# PROTECTED REGION END # // HuttingerPFGDC.Arcs_read
def read_OperationMode(self):
# PROTECTED REGION ID(HuttingerPFGDC.OperationMode_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "CF", 0))
return data
# PROTECTED REGION END # // HuttingerPFGDC.OperationMode_read
def write_OperationMode(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.OperationMode_write) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "4F", value))
# PROTECTED REGION END # // HuttingerPFGDC.OperationMode_write
def read_Control(self):
# PROTECTED REGION ID(HuttingerPFGDC.Control_read) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "CE", 0))
return data
# PROTECTED REGION END # // HuttingerPFGDC.Control_read
def write_Control(self, value):
# PROTECTED REGION ID(HuttingerPFGDC.Control_write) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "4E", value))
# PROTECTED REGION END # // HuttingerPFGDC.Control_write
# --------
# Commands
# --------
@command()
@DebugIt()
def On(self):
# PROTECTED REGION ID(HuttingerPFGDC.On) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "4F", 2))
self.set_state(PyTango.DevState.ON)
# PROTECTED REGION END # // HuttingerPFGDC.On
@command()
@DebugIt()
def Off(self):
# PROTECTED REGION ID(HuttingerPFGDC.Off) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "4F", 0))
self.set_state(PyTango.DevState.OFF)
# PROTECTED REGION END # // HuttingerPFGDC.Off
@command(
dtype_in=('str', ),
dtype_out=('str', ),
display_level=DispLevel.EXPERT,
)
@DebugIt()
def SendCmd(self, argin):
# PROTECTED REGION ID(HuttingerPFGDC.SendCmd) ENABLED START #
(address, command, data) = self.parse_response(
self.sendcommand(0, argin[0], int(argin[1])))
return ([command + " %d" % data])
# PROTECTED REGION END # // HuttingerPFGDC.SendCmd
@command()
@DebugIt()
def reset_arc_counter(self):
# PROTECTED REGION ID(HuttingerPFGDC.reset_arc_counter) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "59", 0))
# PROTECTED REGION END # // HuttingerPFGDC.reset_arc_counter
@command(
display_level=DispLevel.EXPERT, )
@DebugIt()
def On_with_ramp(self):
# PROTECTED REGION ID(HuttingerPFGDC.On_with_ramp) ENABLED START #
(address, command,
data) = self.parse_response(self.sendcommand(0, "4F", 1))
self.set_state(PyTango.DevState.ON)
class VarianMultiGauge(Device):
"""
Simple devicer server for the Varian Multigauge controller. Asumes it has a hot cathode gauge.
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(VarianMultiGauge.class_variable) ENABLED START #
# PROTECTED REGION END # // VarianMultiGauge.class_variable
# -----------------
# Device Properties
# -----------------
SerialPort = device_property(
dtype='str',
)
Speed = device_property(
dtype='uint16',
)
# ----------
# Attributes
# ----------
Pressure_IG1 = attribute(
dtype='double',
unit="mbar",
format="%.1e",
)
Pressure_IG2 = attribute(
dtype='double',
unit="mbar",
format="%.1e",
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(VarianMultiGauge.init_device) ENABLED START #
try:
self.ser=serial.Serial(self.SerialPort,baudrate=self.Speed,bytesize=8,parity="N",stopbits=1,timeout=1)
self.ser.write("#0011\r") # Set units to mbar
self.ser.inWaiting()
resp=self.ser.readline()
self.ser.write("#0032I1\r") # Check emission on IC1
self.ser.inWaiting()
resp=self.ser.readline()
except:
self.set_state(PyTango.DevState.FAULT)
self.set_status("Can't connect to Varian MultiGauge")
self.debug_stream("Can't connect to Varian MultiGauge")
return
self.set_status("Connected to Varian MultiGauge")
self.debug_stream("Connected to Varian MultiGauge")
if (resp==">01\r"): # Only check first gauge to set device status
self.set_state(PyTango.DevState.ON)
else:
self.set_state(PyTango.DevState.OFF)
# PROTECTED REGION END # // VarianMultiGauge.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(VarianMultiGauge.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // VarianMultiGauge.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(VarianMultiGauge.delete_device) ENABLED START #
self.ser.close()
# PROTECTED REGION END # // VarianMultiGauge.delete_device
# ------------------
# Attributes methods
# ------------------
def read_Pressure_IG1(self):
# PROTECTED REGION ID(VarianMultiGauge.Pressure_IG1_read) ENABLED START #
self.ser.write("#0002I1\r")
self.ser.inWaiting()
a=self.ser.readline()
return(float(a[1:]))
# PROTECTED REGION END # // VarianMultiGauge.Pressure_IG1_read
def read_Pressure_IG2(self):
# PROTECTED REGION ID(VarianMultiGauge.Pressure_IG2_read) ENABLED START #
self.ser.write("#0002I2\r")
self.ser.inWaiting()
a=self.ser.readline()
return(float(a[1:]))
# PROTECTED REGION END # // VarianMultiGauge.Pressure_IG2_read
# --------
# Commands
# --------
@command(
dtype_in='str',
dtype_out='str',
display_level=DispLevel.EXPERT,
)
@DebugIt()
def SendCommand(self, argin):
# PROTECTED REGION ID(VarianMultiGauge.SendCommand) ENABLED START #
self.ser.write(argin+"\r")
self.ser.inWaiting()
res=self.ser.readline()
return(res)
class MVC3GaugeControllerTango(Device, metaclass=DeviceMeta):
serial_address = device_property(dtype=int, # store address in decimal (can be 1 - 126)
default_value=1,
doc="this is the devices serial address in decimal. Connection on this device is "
"not done by asking for the serial number (not supported by device) but by "
"asking for the RS485 Serial Address (can also be set/requested in the here "
"used RS232 mode). These were manually set with SSA (e.g. 'RSA46\r' sets this "
"to hex value 46 which is 70 in decimal) command and are labeled on the case "
"of each device. IMPORTANT: after setting the serial address the device must "
"be switched to RS485 and can then be switched back to RS232 immediately. "
"Otherwise the address will reset on next device restart")
pressure_decimal_places = device_property(dtype=int,
default_value=2,
doc="number of displayed decimal places on pressure readings")
def init_device(self):
sys.stdout = StoreStdOut()
self.get_device_properties() # otherwise self.serial will be None
self.mvc3 = MVC3GaugeController(self.serial_address)
self.set_state(DevState.OFF)
self.connect() # try to auto connect on server start. can also be done manually
def delete_device(self):
self.mvc3.disconnect()
print('device deleted')
@attribute(dtype=str)
def server_message(self):
return sys.stdout.read_stored_message()
@command
def connect(self):
self.get_device_properties()
self.set_state(DevState.INIT)
if self.mvc3.connect():
self.set_state(DevState.ON)
else:
self.set_state(DevState.FAULT)
cmd_connect = attribute(access=AttrWriteType.WRITE)
def write_cmd_connect(self, _):
self.connect()
@command
def disconnect(self):
self.mvc3.disconnect()
self.set_state(DevState.OFF)
cmd_disconnect = attribute(access=AttrWriteType.WRITE)
def write_cmd_disconnect(self, _):
self.disconnect()
cmd_reconnect = attribute(access=AttrWriteType.WRITE)
def write_cmd_reconnect(self, _):
self.disconnect()
self.connect()
@attribute(dtype=str, #unit='mBar',
access=AttrWriteType.READ)
def P1(self):
"""writes out errors and info too"""
try:
pressure = self.mvc3.read_pressure(1, decimal_places=self.pressure_decimal_places)
if self.get_state() == DevState.FAULT:
self.set_state(DevState.ON)
return pressure
# yes, general exception catching is not good but cs studio otherwise hides this completely (even worse)
except Exception as e:
self.set_state(DevState.FAULT)
return "ERROR: %s" % e
@attribute(dtype=str, unit='mBar', access=AttrWriteType.READ)
def P2(self):
"""writes out errors and info too"""
try:
pressure = self.mvc3.read_pressure(2, decimal_places=self.pressure_decimal_places)
if self.get_state() == DevState.FAULT:
self.set_state(DevState.ON)
return pressure
# yes, general exception catching is not good but cs studio otherwise hides this completely (even worse)
except Exception as e:
self.set_state(DevState.FAULT)
return "ERROR: %s" % e
@attribute(dtype=str, unit='mBar', access=AttrWriteType.READ)
def P3(self):
"""writes out errors and info too"""
try:
pressure = self.mvc3.read_pressure(3, decimal_places=self.pressure_decimal_places)
if self.get_state() == DevState.FAULT:
self.set_state(DevState.ON)
return pressure
# yes, general exception catching is not good but cs studio otherwise hides this completely (even worse)
except Exception as e:
self.set_state(DevState.FAULT)
return "ERROR: %s" % e
def update_class(self, key, dct):
"""Register proxy and create device property."""
if not self.device:
self.device = key
dct["_class_dict"]["devices"][key] = self
dct[self.device] = device_property(dtype=str, doc="Proxy device.")
class RaspberryButton(Device, metaclass=DeviceMeta):
"""
Simple interface to turn on and off a GPIO pin in a Raspberry PI.
"""
#__metaclass__ = DeviceMeta
# PROTECTED REGION ID(RaspberryButton.class_variable) ENABLED START #
# PROTECTED REGION END # // RaspberryButton.class_variable
# -----------------
# Device Properties
# -----------------
Pin = device_property(dtype='uint16', )
TrueHigh = device_property(dtype='bool', )
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(RaspberryButton.init_device) ENABLED START #
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.Pin, GPIO.OUT)
if (self.TrueHigh == True):
GPIO.output(self.Pin, 0)
else:
GPIO.output(self.Pin, 1)
self.set_state(PyTango.DevState.OFF)
# PROTECTED REGION END # // RaspberryButton.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(RaspberryButton.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // RaspberryButton.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(RaspberryButton.delete_device) ENABLED START #
GPIO.cleanup()
# PROTECTED REGION END # // RaspberryButton.delete_device
# --------
# Commands
# --------
@command()
@DebugIt()
def On(self):
# PROTECTED REGION ID(RaspberryButton.On) ENABLED START #
if (self.TrueHigh == True):
GPIO.output(self.Pin, 1)
else:
GPIO.output(self.Pin, 0)
self.set_state(PyTango.DevState.ON)
# PROTECTED REGION END # // RaspberryButton.On
@command()
@DebugIt()
def Off(self):
# PROTECTED REGION ID(RaspberryButton.Off) ENABLED START #
if (self.TrueHigh == True):
GPIO.output(self.Pin, 0)
else:
GPIO.output(self.Pin, 1)
self.set_state(PyTango.DevState.OFF)
def update_class(self, key, dct):
"""Create the command, methods and device properties."""
# Register
proxy.update_class(self, key, dct)
dct["_class_dict"]["commands"][key] = self
# Command method
def run_command(device, arg=None):
"""Write the attribute of the remote device with the value."""
# Get data
name, is_attr, value, reset, delay = device._command_dict[key]
# Get value
if self.dtype_in:
value = arg
# Check attribute
if name.strip().lower() == NONE_STRING:
if is_attr:
msg = "No attribute to write for commmand {0}"
else:
msg = "No sub-command to run for command {0}"
raise ValueError(msg.format(key))
# Prepare
proxy_name = device._device_dict[key]
device_proxy = device._proxy_dict[proxy_name]
if is_attr:
write = device_proxy.write_attribute
else:
write = device_proxy.command_inout
# Write
result = write(name, value)
# Reset
if reset is not None:
time.sleep(delay)
result = write(name, reset)
# Return
if not self.dtype_out:
return
if not is_attr:
return result
# Read attribute
result = device_proxy.read_attribute(name)
return result.value
# Set command
cmd = patched_command(**self.kwargs)
run_command.__name__ = key
if self.is_attr:
doc = "Write the attribute '{0}' of '{1}' with value {2}"
run_command.__doc__ = doc.format(self.prop or self.attr,
self.device, self.value)
else:
doc = "Run the command '{0}' of '{1}' with value {2}"
run_command.__doc__ = doc.format(self.prop or self.cmd,
self.device, self.value)
dct[key] = cmd(run_command)
# Is allowed method
def is_allowed(device):
"""The method is allowed if the device is connected."""
return device.connected
# Set is allowed method
method_name = "is_" + key + "_allowed"
if method_name not in dct:
is_allowed.__name__ = method_name
dct[method_name] = is_allowed
# Create properties
if self.prop:
default = self.attr if self.is_attr else self.cmd
if not isinstance(default, basestring):
default = None
if self.is_attr:
doc = "Attribute of '{0}' to write "
else:
doc = "Command of '{0}' to run "
doc += "when command {1} is executed"
dct[self.prop] = device_property(dtype=str, default_value=default,
doc=doc.format(self.device, key))
class PowerSupply(Device):
"""
Dummy Power Supply for testing
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(PowerSupply.class_variable) ENABLED START #
# PROTECTED REGION END # // PowerSupply.class_variable
# -----------------
# Device Properties
# -----------------
LoadImpedance = device_property(dtype='double', mandatory=True)
HWUpdatetime = device_property(dtype='double', default_value=1)
# ----------
# Attributes
# ----------
Voltage = attribute(
dtype='double',
access=AttrWriteType.READ_WRITE,
label="PSV",
unit="V",
max_value=100,
min_value=0,
max_alarm=50,
max_warning=30,
memorized=True,
)
Current = attribute(
dtype='double',
unit="A",
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(PowerSupply.init_device) ENABLED START #
self.voltage = 0.
self.current = 0.
self.set_state(DevState.OFF)
# PROTECTED REGION END # // PowerSupply.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(PowerSupply.always_executed_hook) ENABLED START #
t = '%s state is %s\n' % (self.get_name(), self.get_state())
t += 'Voltage = %s, Current = %s' % (self.voltage, self.current)
self.set_status(t)
print(t)
# PROTECTED REGION END # // PowerSupply.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(PowerSupply.delete_device) ENABLED START #
self.set_state(DevState.UNKNOWN)
# PROTECTED REGION END # // PowerSupply.delete_device
# ------------------
# Attributes methods
# ------------------
def read_Voltage(self):
# PROTECTED REGION ID(PowerSupply.Voltage_read) ENABLED START #
return self.voltage
# PROTECTED REGION END # // PowerSupply.Voltage_read
def write_Voltage(self, value):
# PROTECTED REGION ID(PowerSupply.Voltage_write) ENABLED START #
self.voltage = value
self.current = self.voltage / self.LoadImpedance
# PROTECTED REGION END # // PowerSupply.Voltage_write
def read_Current(self):
# PROTECTED REGION ID(PowerSupply.Current_read) ENABLED START #
return self.current
# PROTECTED REGION END # // PowerSupply.Current_read
# --------
# Commands
# --------
@command()
@DebugIt()
def On(self):
# PROTECTED REGION ID(PowerSupply.On) ENABLED START #
self.set_state(DevState.ON)
# PROTECTED REGION END # // PowerSupply.On
@command()
@DebugIt()
def Off(self):
# PROTECTED REGION ID(PowerSupply.Off) ENABLED START #
self.set_state(DevState.OFF)
self.attr_ok.append(a)
elif v[1] is None:
# Value is readable but not from DB
self.attr_err.append(a)
else:
self.attr_ok.append(a)
return
# PROTECTED REGION END # // SchemaManager.class_variable
# -----------------
# Device Properties
# -----------------
Schemas = device_property(
dtype=('str',),
)
Threaded = device_property(
dtype='bool', default_value=False
)
ValuesFile = device_property(
dtype='str',
)
CacheTime = device_property(
dtype='int', default_value=600
)
# ----------
class MicosPollux(PTS.Device, metaclass=PTS.DeviceMeta):
# Device properties
proxy = PTS.device_property(dtype=str,
doc="Proxy device for serial communication")
polling = PTS.device_property(dtype=np.uint32, doc="Polling period in ms")
axis = PTS.device_property(dtype=np.uint32, doc="Axis number")
# Attributes
Position = PTS.attribute(label="Position",
dtype=PT.DevDouble,
format="%.4f",
access=PT.AttrWriteType.READ_WRITE,
unit="mm",
doc="")
Velocity = PTS.attribute(label="Velocity",
dtype=PT.DevDouble,
format="%.2f",
access=PT.AttrWriteType.READ_WRITE,
unit="mm/s",
memorized=True,
hw_memorized=True,
doc="")
Acceleration = PTS.attribute(label="Acceleration",
dtype=PT.DevDouble,
format="%.2f",
access=PT.AttrWriteType.READ_WRITE,
unit="mm/s^2",
memorized=True,
hw_memorized=True,
doc="")
def init_device(self):
""" Initialize device
"""
# Set INIT state
self.set_state(PT.DevState.INIT)
# Call parent init
PTS.Device.init_device(self)
# Set polling on State
self.poll_command("State", 500)
# Start monitor thread
self.monitor = PolluxPolling(self)
def delete_device(self):
if self.monitor:
self.monitor.terminate()
self.monitor.join()
def read_Position(self):
return self.monitor.getPosition()
def write_Position(self, value):
self.monitor.moveTo(value)
def read_Velocity(self):
return self.monitor.getVelocity()
def write_Velocity(self, value):
self.monitor.setVelocity(value)
def read_Acceleration(self):
return self.monitor.getAcceleration()
def write_Acceleration(self, value):
self.monitor.setAcceleration(value)
@PTS.command()
def setHome(self):
self.monitor.setHome()
@PTS.command()
def goHome(self):
self.monitor.moveTo(0.0)
class MyDevice(Device):
"""
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(MyDevice.class_variable) ENABLED START #
image_maximum = 0.0
polled_ds = 0.0
quality_counter = 0
quality_list = [
AttrQuality.ATTR_VALID, AttrQuality.ATTR_INVALID,
AttrQuality.ATTR_ALARM, AttrQuality.ATTR_CHANGING,
AttrQuality.ATTR_WARNING
]
# PROTECTED REGION END # // MyDevice.class_variable
# ----------------
# Class Properties
# ----------------
# -----------------
# Device Properties
# -----------------
DeviceToRead = device_property(dtype='str', default_value="sys/tg_test/1")
# ----------
# Attributes
# ----------
PolledDoubleScalar = attribute(dtype='double', )
ImagineMaximum = attribute(dtype='double', )
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(MyDevice.init_device) ENABLED START #
self.set_state(DevState.ON)
# PROTECTED REGION END # // MyDevice.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(MyDevice.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // MyDevice.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(MyDevice.delete_device) ENABLED START #
pass
# PROTECTED REGION END # // MyDevice.delete_device
# ------------------
# Attributes methods
# ------------------
def read_PolledDoubleScalar(self):
# PROTECTED REGION ID(MyDevice.PolledDoubleScalar_read) ENABLED START #
attr_proxy = PyTango.AttributeProxy(self.DeviceToRead +
'/double_scalar')
self.polled_ds = attr_proxy.read().value
self.debug_stream(str(self.polled_ds))
return self.polled_ds
# PROTECTED REGION END # // MyDevice.PolledDoubleScalar_read
def read_ImagineMaximum(self):
# PROTECTED REGION ID(MyDevice.ImagineMaximum_read) ENABLED START #
attr_proxy = PyTango.AttributeProxy(self.DeviceToRead +
'/double_image_ro')
value = attr_proxy.read().value
maximums = []
for row in value:
maximums.append(max(row))
self.image_maximum = max(maximums)
attr_quality = AttrQuality.ATTR_VALID
self.push_change_event("ImagineMaximum", self.image_maximum, time(),
attr_quality)
self.push_archive_event("ImagineMaximum", self.image_maximum, time(),
attr_quality)
if (self.image_maximum < 20):
self.set_state(DevState.OFF)
else:
if (self.image_maximum < 30):
self.set_state(DevState.WARNING)
else:
self.set_state(DevState.ON)
return float(self.image_maximum), time(), attr_quality
# PROTECTED REGION END # // MyDevice.ImagineMaximum_read
# --------
# Commands
# --------
@command
@DebugIt()
def ChangeDoubleScalarQuality(self):
# PROTECTED REGION ID(MyDevice.ChangeDoubleScalarQuality) ENABLED START #
self.quality_counter = (self.quality_counter + 1) % 5
self.PolledDoubleScalar.set_quality(
self.quality_list[self.quality_counter])
class PfeifferDCU002(Device):
"""
This is a server that provides the same funcionality as the Pfeiffer DCU display unit.
"""
__metaclass__ = DeviceMeta
# PROTECTED REGION ID(PfeifferDCU002.class_variable) ENABLED START #
def sendcommand(self, address, action, parameter, data):
cmd_string = address + action + parameter + "%02d" % len(data) + data
cmd = cmd_string + "%03d" % self.crc_code(cmd_string) + "\r"
self.ser.write(cmd)
resp = self.ser.read_until(terminator="\r")
raddress = resp[0:3]
raction = resp[3:5]
rparameter = resp[5:8]
rdata = resp[10:10 + int(resp[8:10])]
rcrc = resp[-4:-1]
return (raddress, raction, rparameter, rdata, rcrc)
def crc_code(self, a):
result = 0
for i in range(0, len(a)):
result = result + ord(a[i])
result %= 256
return (result)
# PROTECTED REGION END # // PfeifferDCU002.class_variable
# -----------------
# Device Properties
# -----------------
SerialPort = device_property(dtype='str', )
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(PfeifferDCU002.init_device) ENABLED START #
self.ser = serial.Serial(self.SerialPort,
9600,
bytesize=8,
parity="N",
stopbits=1)
# PROTECTED REGION END # // PfeifferDCU002.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(PfeifferDCU002.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // PfeifferDCU002.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(PfeifferDCU002.delete_device) ENABLED START #
self.ser.close()
# PROTECTED REGION END # // PfeifferDCU002.delete_device
# --------
# Commands
# --------
@command(
dtype_in='str',
dtype_out='str',
)
@DebugIt()
def readParameter(self, argin):
# PROTECTED REGION ID(PfeifferDCU002.readParameter) ENABLED START #
(radd, raction, rparameter, rdata,
rcrc) = self.sendcommand("001", "00", argin[0:3], "=?")
return rdata
# PROTECTED REGION END # // PfeifferDCU002.readParameter
@command(
dtype_in=('str', ),
dtype_out='str',
)
@DebugIt()
def setParameter(self, argin):
# PROTECTED REGION ID(PfeifferDCU002.setParameter) ENABLED START #
parameter = argin[0]
data = argin[1]
parameter = parameter[0:3]
(radd, raction, rparameter, rdata,
rcrc) = self.sendcommand("001", "10", parameter, data)
return rdata
class SpectrometerCameraDS(Device):
__metaclass__ = DeviceMeta
exposuretime = attribute(
label='ExposureTime',
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="us",
format="%8.1f",
min_value=0.0,
max_value=1e7,
fget="get_exposuretime",
fset="set_exposuretime",
doc="Camera exposure time in us",
memorized=True,
)
# hw_memorized=True)
gain = attribute(
label='Gain',
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="dB",
format="%3.2f",
min_value=0.0,
max_value=1e2,
fget="get_gain",
fset="set_gain",
doc="Camera gain in dB",
memorized=True,
)
# hw_memorized=True)
wavelengthvector = attribute(
label='WavelengthVector',
dtype=[np.double],
access=pt.AttrWriteType.READ,
max_dim_x=16384,
display_level=pt.DispLevel.OPERATOR,
unit="m",
format="%5.2e",
fget="get_wavelengthvector",
doc="Wavelength vector",
)
spectrum = attribute(
label='Spectrum',
dtype=[np.double],
access=pt.AttrWriteType.READ,
max_dim_x=16384,
display_level=pt.DispLevel.OPERATOR,
unit="a.u.",
format="%5.2f",
fget="get_spectrum",
doc="Spectrum",
)
width = attribute(
label='Spectrum width FWHM',
dtype=np.double,
access=pt.AttrWriteType.READ,
display_level=pt.DispLevel.OPERATOR,
unit="m",
format="%5.2e",
fget="get_width",
doc=
"FWHM for the peak in spectrum. Basic thresholding and peak detection is used.",
)
peak = attribute(
label='Spectrum peak',
dtype=np.double,
access=pt.AttrWriteType.READ,
display_level=pt.DispLevel.OPERATOR,
unit="m",
format="%5.2e",
fget="get_peak",
doc=
"Wavelength for the peak in spectrum. Basic thresholding and peak detection is used.",
)
sat_lvl = attribute(
label='Saturation level',
dtype=np.double,
access=pt.AttrWriteType.READ,
display_level=pt.DispLevel.OPERATOR,
unit="relative",
format="%2.2e",
fget="get_satlvl",
doc=
"Relative amount of pixels that are saturated. This should be zero.",
)
camera_name = device_property(
dtype=str,
doc="Tango name of the camera device",
default_value="gunlaser/cameras/spectrometer_camera")
watchdog_timeout = device_property(
dtype=float,
doc="Timeout for the watchdog resetting the hardware in s",
default_value="2.0")
dispersion = device_property(
dtype=float,
doc="Dispersion of the spectrometer in nm/px. "
"Positive if wavelength increases to the right",
default_value="0.056")
central_wavelength = device_property(
dtype=float,
doc="Wavelength of the central pixel of the ROI in nm",
default_value="2.0")
roi = device_property(
dtype=[int],
doc="Pixel coordinates for the ROI: [left, top, width, height]",
default_value=[0, 0, 100, 100])
saturation_level = device_property(
dtype=int,
doc="Saturation pixel value, used for estimating overexposure",
default_value=65536)
def __init__(self, klass, name):
self.wavelengthvector_data = np.array([])
self.max_value = 1.0
self.dev_controller = None
self.db = None
Device.__init__(self, klass, name)
def init_device(self):
self.debug_stream("In init_device:")
Device.init_device(self)
self.db = pt.Database()
self.set_state(pt.DevState.UNKNOWN)
self.debug_stream("Init camera controller {0}".format(
self.camera_name))
params = dict()
params["imageoffsetx"] = self.roi[0]
params["imageoffsety"] = self.roi[1]
params["imagewidth"] = self.roi[2]
params["imageheight"] = self.roi[3]
params["triggermode"] = "Off"
try:
if self.dev_controller is not None:
self.dev_controller.stop_thread()
except Exception as e:
self.error_info("Error stopping camera controller: {0}".format(e))
try:
self.setup_spectrometer()
self.dev_controller = SpectrometerCameraDeviceController(
self.camera_name, params, self.wavelengthvector_data,
self.max_value)
# self.dev_controller = CameraDeviceController(self.camera_name, params)
except Exception as e:
self.error_stream(
"Error creating camera controller: {0}".format(e))
return
self.debug_stream("init_device finished")
# self.set_state(pt.DevState.ON)
self.dev_controller.add_state_callback(self.change_state)
def setup_spectrometer(self):
self.info_stream("Entering setup_camera")
self.wavelengthvector_data = (self.central_wavelength + np.arange(
-self.roi[2] / 2, self.roi[2] / 2) * self.dispersion) * 1e-9
self.max_value = self.saturation_level
def change_state(self, new_state, new_status=None):
self.debug_stream("Change state from {0} to {1}".format(
self.get_state(), new_state))
if self.get_state(
) is pt.DevState.INIT and new_state is not pt.DevState.UNKNOWN:
self.debug_stream("Set memorized attributes")
data = self.db.get_device_attribute_property(
self.get_name(), "gain")
self.debug_stream(
"Database returned data for \"gain\": {0}".format(
data["gain"]))
try:
new_value = float(data["gain"]["__value"][0])
self.debug_stream("{0}".format(new_value))
self.dev_controller.write_attribute("gain", new_value)
except (KeyError, TypeError, IndexError, ValueError):
pass
data = self.db.get_device_attribute_property(
self.get_name(), "exposuretime")
self.debug_stream(
"Database returned data for \"exposuretime\": {0}".format(
data["exposuretime"]))
try:
new_value = float(data["exposuretime"]["__value"][0])
self.dev_controller.write_attribute("exposuretime", new_value)
except (KeyError, TypeError, IndexError, ValueError):
pass
self.set_state(new_state)
if new_status is not None:
self.debug_stream("Setting status {0}".format(new_status))
self.set_status(new_status)
def get_spectrum(self):
attr = self.dev_controller.get_attribute("image")
try:
spectrum = attr.value.sum(0)
except AttributeError:
spectrum = []
return spectrum, attr.time.totime(), attr.quality
def get_wavelengthvector(self):
self.debug_stream("get_wavelengthvector: size {0}".format(
self.wavelengthvector_data.shape))
return self.wavelengthvector_data, time.time(
), pt.AttrQuality.ATTR_VALID
def get_exposuretime(self):
attr = self.dev_controller.get_attribute("exposuretime")
return attr.value, attr.time.totime(), attr.quality
def set_exposuretime(self, new_exposuretime):
self.debug_stream(
"In set_exposuretime: New value {0}".format(new_exposuretime))
self.debug_stream("Type dev_controller: {0}".format(
type(self.dev_controller)))
self.dev_controller.write_attribute("exposuretime", new_exposuretime)
def get_gain(self):
attr = self.dev_controller.get_attribute("gain")
return attr.value, attr.time.totime(), attr.quality
def set_gain(self, new_gain):
self.debug_stream("In set_gain: New value {0}".format(new_gain))
self.dev_controller.write_attribute("gain", new_gain)
def get_width(self):
attr = self.dev_controller.get_attribute("width")
return attr
def get_peak(self):
attr = self.dev_controller.get_attribute("peak")
return attr
def get_satlvl(self):
attr = self.dev_controller.get_attribute("satlvl")
return attr
class TMCM6110MotoraxisDS(Device):
__metaclass__ = DeviceMeta
# --- Operator attributes
#
Position = attribute(label="position",
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="mm",
format="%6.2f",
min_value=-100000.0,
max_value=100000.0,
fget="get_position",
fset="set_position",
doc="Motor position in mm",
memorized=True,
hw_memorized=True)
Velocity = attribute(label="velocity",
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="mm / s",
format="%6.2f",
min_value=-100000.0,
max_value=100000.0,
fget="get_velocity",
fset="set_velocity",
doc="Motor velocity in mm/s",
memorized=True,
hw_memorized=True)
DialPosition = attribute(
label="dial position",
dtype=float,
access=pt.AttrWriteType.READ,
unit="mm",
format="%6.2f",
min_value=-100000.0,
max_value=100000.0,
fget="get_dialposition",
fset="set_dialposition",
doc="Absolute motor position in mm with offset applied",
)
Offset = attribute(label="offset",
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="mm",
format="%6.2f",
min_value=-100000.0,
max_value=100000.0,
fget="get_offset",
fset="set_offset",
doc="Motor offset in mm",
memorized=True,
hw_memorized=True)
Acceleration = attribute(label="acceleration",
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="mm / s**2",
format="%6.2f",
min_value=-1000000.0,
max_value=1000000.0,
fget="get_acceleration",
fset="set_acceleration",
doc="Motor acceleration in mm/s**2",
memorized=True,
hw_memorized=True)
Deceleration = attribute(label="deceleration",
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="mm / s**2",
format="%6.2f",
min_value=-1000000.0,
max_value=1000000.0,
fget="get_deceleration",
fset="set_deceleration",
doc="Motor deceleration in mm/s**2",
memorized=True,
hw_memorized=True)
Base_rate = attribute(
label="base rate",
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="a.u.",
format="%6.2f",
min_value=-1000000.0,
max_value=1000000.0,
fget="get_baserate",
fset="set_baserate",
doc="Motor base rate... whatever that is",
memorized=True,
)
SimulationMode = attribute(
label="simulation mode",
dtype=bool,
access=pt.AttrWriteType.READ,
unit="",
fget="get_simulationmode",
doc="Motor simulation mode",
)
Step_per_unit = attribute(label="step per unit",
dtype=float,
access=pt.AttrWriteType.READ_WRITE,
unit="steps/mm",
format="%6.2f",
min_value=-1000000.0,
max_value=1000000.0,
fget="get_stepperunit",
fset="set_stepperunit",
doc="Motor steps per unit",
memorized=True,
hw_memorized=True)
Backlash = attribute(label="backlash",
dtype=bool,
access=pt.AttrWriteType.READ_WRITE,
unit="",
format="%d",
fget="get_backlash",
fset="set_backlash",
doc="Motor backlash",
memorized=True,
hw_memorized=True)
Limit_switches = attribute(
label="limit switches",
dtype=(bool, ),
max_dim_x=3,
access=pt.AttrWriteType.READ,
unit="",
format="%d",
fget="get_limitswitches",
doc="Limit switches state",
)
Load_level = attribute(
label="load level",
dtype=float,
access=pt.AttrWriteType.READ,
unit="",
format="%6.2f",
min_value=-1000000.0,
max_value=1000000.0,
fget="get_loadlevel",
doc="Motor load level in normalized units",
)
# --- Device properties
#
TMCM6110_device = device_property(
dtype=str,
doc="Tango name of mother Trinamic_TMCM6110_DS",
)
Axis = device_property(
dtype=int,
doc="Motor axis",
)
Motor_current = device_property(
dtype=float,
doc="Motor maxiumum current",
)
Microsteps = device_property(
dtype=int,
doc="Microstep resolution: 1, 2, 4, 8, or 16",
)
Limit0Enable = device_property(
dtype=bool,
doc="Enable limit switch 0?",
)
Limit1Enable = device_property(
dtype=bool,
doc="Enable limit switch 1?",
)
def __init__(self, klass, name):
self.controller = None # type: TMCM6110MotoraxisController
self.setup_attr_params = dict()
self.state_dispatcher = None # type: StateDispatcher
self.state_thread = None # type: threading.Thread
self.stop_state_thread = False
self.offset_value = 0
self.baserate_value = 0
self.backlash_value = False
self.simulation_value = False
Device.__init__(self, klass, name)
def init_device(self):
self.debug_stream("In init_device:")
Device.init_device(self)
if self.controller is not None:
self.stop_state_thread = True
self.state_thread.join(1.0)
self.controller.close()
self.debug_stream(
"Device: {0}, axis {1}, motor_current {2}, microsteps {3}".format(
self.TMCM6110_device, self.Axis, self.Motor_current,
self.Microsteps))
self.controller = TMCM6110MotoraxisController(
self.TMCM6110_device, self.Axis, self.Motor_current, 1,
self.Microsteps, self.Limit0Enable, self.Limit1Enable)
self.state_thread = threading.Thread(target=self._read_state)
self.state_thread.daemon = True
self.state_thread.start()
def get_position(self):
# self.debug_stream("In get_position:")
if self.controller is None:
self.error_stream("No controller")
return None
data = self.controller.get_position()
try:
value = data.value
t = data.time.totime()
quality = pt.AttrQuality.ATTR_VALID
except AttributeError:
value = 0
quality = pt.AttrQuality.ATTR_INVALID
t = time.time()
return value, t, quality
def set_position(self, pos):
self.debug_stream("In set_position: {0}".format(pos))
if self.controller is None:
self.error_stream("set_position: NO CONTROLLER")
return
self.controller.set_position(pos)
return 0
def get_velocity(self):
# self.debug_stream("In get_velocity:")
data = self.controller.get_speed()
try:
value = data.value
t = data.time.totime()
quality = pt.AttrQuality.ATTR_VALID
except AttributeError:
value = 0
quality = pt.AttrQuality.ATTR_INVALID
t = time.time()
return value, t, quality
def set_velocity(self, value):
self.debug_stream("In set_velocity: {0}".format(value))
if self.controller is None:
self.error_stream("set_velocity: NO CONTROLLER")
return
self.controller.set_speed(value)
return 0
def get_dialposition(self):
# self.debug_stream("In get_dialposition:")
data = self.controller.get_position()
try:
value = data.value - self.offset_value
t = data.time.totime()
quality = pt.AttrQuality.ATTR_VALID
except AttributeError:
value = 0
quality = pt.AttrQuality.ATTR_INVALID
t = time.time()
return value, t, quality
def get_offset(self):
# self.debug_stream("In get_offset:")
value = self.offset_value
quality = pt.AttrQuality.ATTR_VALID
t = time.time()
return value, t, quality
def set_offset(self, value):
self.debug_stream("In set_offset: {0}".format(value))
self.offset_value = value
return 0
def get_acceleration(self):
# self.debug_stream("In get_acceleration:")
data = self.controller.get_acceleration()
try:
value = data.value
t = data.time.totime()
quality = pt.AttrQuality.ATTR_VALID
except AttributeError:
value = 0
quality = pt.AttrQuality.ATTR_INVALID
t = time.time()
return value, t, quality
def set_acceleration(self, value):
self.debug_stream("In set_acceleration: {0}".format(value))
if self.controller is None:
self.error_stream("set_acceleration: NO CONTROLLER")
return
self.controller.set_acceleration(value)
return 0
def get_deceleration(self):
# self.debug_stream("In get_deceleration:")
data = self.controller.get_acceleration()
try:
value = data.value
t = data.time.totime()
quality = pt.AttrQuality.ATTR_VALID
except AttributeError:
value = 0
quality = pt.AttrQuality.ATTR_INVALID
t = time.time()
return value, t, quality
def set_deceleration(self, value):
self.debug_stream("In set_deceleration: {0}".format(value))
if self.controller is None:
self.error_stream("set_deceleration: NO CONTROLLER")
return
self.controller.set_acceleration(value)
return 0
def get_baserate(self):
# self.debug_stream("In get_baserate:")
value = self.baserate_value
quality = pt.AttrQuality.ATTR_VALID
t = time.time()
return value, t, quality
def set_baserate(self, value):
self.debug_stream("In set_baserate: {0}".format(value))
self.baserate_value = value
return 0
def get_simulationmode(self):
# self.debug_stream("In get_simulationmode:")
value = self.simulation_value
quality = pt.AttrQuality.ATTR_VALID
t = time.time()
return value, t, quality
def set_simulationmode(self, value):
self.debug_stream("In set_simulationmode: {0}".format(value))
self.simulation_value = value
return 0
def get_stepperunit(self):
# self.debug_stream("In get_stepperunit:")
if self.controller is None:
return None
value = self.controller.get_stepperunit()
quality = pt.AttrQuality.ATTR_VALID
t = time.time()
return value, t, quality
def set_stepperunit(self, value):
self.debug_stream("In set_stepperunit: {0}".format(value))
if self.controller is None:
return
self.controller.set_stepperunit(value)
return 0
def get_backlash(self):
# self.debug_stream("In get_backlash:")
value = self.backlash_value
quality = pt.AttrQuality.ATTR_VALID
t = time.time()
return value, t, quality
def set_backlash(self, value):
self.debug_stream("In set_backlash: {0}".format(value))
self.backlash_value = value
return 0
def get_limitswitches(self):
# self.debug_stream("In get_limitswitches:")
data = self.controller.get_limitswitches()
try:
value = [data[0].value, data[1].value]
t = data[0].time.totime()
quality = pt.AttrQuality.ATTR_VALID
except AttributeError:
value = [False, False]
quality = pt.AttrQuality.ATTR_INVALID
t = time.time()
return value, t, quality
def get_loadlevel(self):
# self.debug_stream("In get_loadlevel:")
data = self.controller.get_loadlevel()
try:
value = data.value
t = data.time.totime()
quality = pt.AttrQuality.ATTR_VALID
except AttributeError:
value = 0
quality = pt.AttrQuality.ATTR_INVALID
t = time.time()
return value, t, quality
def _read_state(self):
self.debug_stream("Starting read state thread")
old_state = "--"
while not self.stop_state_thread:
state, status = self.controller.get_state()
if state in ["unknown"]:
if old_state != state:
self.info_stream("Changing state to UNKNOWN")
self.set_state(pt.DevState.UNKNOWN)
self.set_status(status)
elif state in ["init"]:
if old_state != state:
self.info_stream("Changing state to INIT")
self.set_state(pt.DevState.INIT)
self.set_status(status)
elif state in ["on"]:
if old_state != state:
self.info_stream("Changing state to ON")
self.set_state(pt.DevState.ON)
self.set_status(status)
elif state in ["moving"]:
if old_state != state:
self.info_stream("Changing state to MOVING")
self.set_state(pt.DevState.MOVING)
self.set_status(status)
elif state in ["fault"]:
if old_state != state:
self.info_stream("Changing state to FAULT")
self.set_state(pt.DevState.FAULT)
self.set_status(status)
elif state in ["alarm"]:
if old_state != state:
self.info_stream("Changing state to ALARM")
self.set_state(pt.DevState.ALARM)
self.set_status(status)
else:
self.info_stream("Unknown state,setting UNKNOWN")
self.set_state(pt.DevState.UNKNOWN)
old_state = state
time.sleep(0.1)
class SEAWaterflowmeter(Device,metaclass=DeviceMeta):
"""
Device server to interface a Raspberry PI using the GPIO to the SEA YF-S201 water flow sensor.
"""
# PROTECTED REGION ID(SEAWaterflowmeter.class_variable) ENABLED START #
# PROTECTED REGION END # // SEAWaterflowmeter.class_variable
# -----------------
# Device Properties
# -----------------
channels = device_property(
dtype='str', default_value="6,13,19,26"
)
channelnames = device_property(
dtype='str', default_value="turbo,xraygun,doser,p2lens"
)
calibration = device_property(
dtype='double', default_value=7.5
)
time = device_property(
dtype='double', default_value=1.0
)
# ----------
# Attributes
# ----------
channel0 = attribute(
dtype='double',
label="turbo",
unit="l/min",
format="%3.1f",
)
channel1 = attribute(
dtype='double',
label="xray gun",
unit="l/min",
format="%3.1f",
)
channel2 = attribute(
dtype='double',
label="doser",
unit="l/min",
format="%3.1f",
)
channel3 = attribute(
dtype='double',
label="p2 lens",
unit="l/min",
format="%3.1f",
)
# ---------------
# General methods
# ---------------
def init_device(self):
Device.init_device(self)
# PROTECTED REGION ID(SEAWaterflowmeter.init_device) ENABLED START #
self.channel0data=0.0
self.channel1data=0.0
self.channel2data=0.0
self.channel3data=0.0
for i in self.channels.split(","):
count[int(i)]=0.0
self.listofnames=self.channelnames.split(",")
#print(self.channel0.get_attribute_list)
#self.channel0.set_label(listofnames[0])
#self.channel1.set_label(listofnames[1])
#self.channel2.set_label(listofnames[2])
#self.channel3.set_label(listofnames[3])
GPIO.setmode(GPIO.BCM) # set up BCM GPIO numbering
for i in count:
GPIO.setup(i,GPIO.IN)
for i in count:
GPIO.add_event_detect(i, GPIO.RISING, callback=my_callback)
self.set_state(PyTango.DevState.ON)
self.set_status("Measurement thread is running")
self.stop_ctrloop = 0
ctrlloop = ControlThread(self)
ctrlloop.start()
# PROTECTED REGION END # // SEAWaterflowmeter.init_device
def always_executed_hook(self):
# PROTECTED REGION ID(SEAWaterflowmeter.always_executed_hook) ENABLED START #
pass
# PROTECTED REGION END # // SEAWaterflowmeter.always_executed_hook
def delete_device(self):
# PROTECTED REGION ID(SEAWaterflowmeter.delete_device) ENABLED START #
self.ds.stop_ctrloop = 0
GPIO.cleanup()
# PROTECTED REGION END # // SEAWaterflowmeter.delete_device
# ------------------
# Attributes methods
# ------------------
def read_channel0(self):
# PROTECTED REGION ID(SEAWaterflowmeter.channel0_read) ENABLED START #
return self.channel0data
# PROTECTED REGION END # // SEAWaterflowmeter.channel0_read
def read_channel1(self):
# PROTECTED REGION ID(SEAWaterflowmeter.channel1_read) ENABLED START #
return self.channel1data
# PROTECTED REGION END # // SEAWaterflowmeter.channel1_read
def read_channel2(self):
# PROTECTED REGION ID(SEAWaterflowmeter.channel2_read) ENABLED START #
return self.channel2data
# PROTECTED REGION END # // SEAWaterflowmeter.channel2_read
def read_channel3(self):
# PROTECTED REGION ID(SEAWaterflowmeter.channel3_read) ENABLED START #
return self.channel3data
# PROTECTED REGION END # // SEAWaterflowmeter.channel3_read
# --------
# Commands
# --------
@command(
)
@DebugIt()
def turnON(self):
# PROTECTED REGION ID(SEAWaterflowmeter.turnON) ENABLED START #
state=self.get_state()
if (state==PyTango.DevState.ON):
return
elif (state==PyTango.DevState.OFF):
self.stop_ctrloop = 0
ctrlloop = ControlThread(self)
ctrlloop.start()
self.set_state(PyTango.DevState.ON)
self.set_status("Measurement thread is running")
# PROTECTED REGION END # // SEAWaterflowmeter.turnON
@command(
)
@DebugIt()
def turnOFF(self):
# PROTECTED REGION ID(SEAWaterflowmeter.turnOFF) ENABLED START #
state=self.get_state()
if (state==PyTango.DevState.OFF):
return
elif (state==PyTango.DevState.ON):
self.stop_ctrloop = 1
self.set_state(PyTango.DevState.OFF)
self.set_status("Measurement thread is NOT running")
