def _set_closed_loop(self, axis, onoff = True):
"""
Sets Closed loop status (Servo state) (SVO command)
"""
axis.closed_loop = onoff
self.send_no_ans(axis, "SVO %s %d" % (axis.channel, onoff))
elog.debug("Piezo Servo %r" % onoff)
# Only when closing loop: waits to be ON-Target.
if onoff:
_t0 = time.time()
cl_timeout = 2
_ont_state = self._get_on_target_status(axis)
elog.info(u'axis {0:s} waiting to be ONTARGET'.format(axis.name))
while((not _ont_state) or (time.time() - _t0) > cl_timeout):
time.sleep(0.01)
print ".",
_ont_state = self._get_on_target_status(axis)
if not _ont_state:
elog.error('axis {0:s} NOT on-target'.format(axis.name))
raise RuntimeError("Unable to close the loop : not ON-TARGET after %gs :( " % cl_timeout)
else:
elog.info('axis {0:s} ONT ok after {1:g} s'.format(axis.name, time.time() - _t0))
# Updates emotion setting (internal cached) position.
axis._position() # "POS?"
def __init__(self, name, config, axes, encoders):
Controller.__init__(self, name, config, axes, encoders)
self._axis_moves = {}
self.factor = 1
# config
_target_attribute_name = self.config.get("target_attribute")
_gating_ds = self.config.get("gating_ds")
try:
self.target_attribute = AttributeProxy(_target_attribute_name)
except:
elog.error("Unable to connect to attrtribute %s " % _target_attribute_name)
# External DS to use for gating.
# ex: PI-E517 for zap of HPZ.
if _gating_ds is not None:
self.gating_ds = DeviceProxy(_gating_ds)
self.external_gating = True
elog.info("external gating True ; gating ds= %s " % _gating_ds)
else:
# No external gating by default.
self.external_gating = False
# _pos0 must be in controller unit.
self._pos0 = self.target_attribute.read().value * self.factor
elog.info("initial position : %g (in ctrl units)" % self._pos0)
def initialize_axis(self, axis):
axis.channel = axis.config.get("channel")
if axis.channel == "X":
self.ctrl_axis = axis
axis.target_radius = axis.config.get("target_radius", int)
axis.target_time = axis.config.get("target_time", int)
axis.min_dead_zone = axis.config.get("min_dead_zone", int)
axis.max_dead_zone = axis.config.get("max_dead_zone", int)
axis.smoothing = axis.config.get("smoothing", int)
axis.deceleration = axis.config.get("deceleration", float)
add_axis_method(axis, self.get_id)
# Enabling servo mode.
self._flexdc_query("%sMO=1" % axis.channel)
# Sets "point to point" motion mode.
# 0 -> point to point
# ( 1 -> jogging ; 2 -> position based gearing )
# ( 5 -> position based ECAM ; 8 -> Step command (no profile) )
self._flexdc_query("%sMM=0" % axis.channel)
# Special motion mode attribute parameter
# 0 -> no special mode
# ( 1 -> repetitive motion )
self._flexdc_query("%sSM=0" % axis.channel)
# Defines smoothing (typically 4).
self._flexdc_query("%sWW=%d" % (axis.channel, axis.smoothing))
# Target Time (settling time?)
self.flexdc_parameter(axis, "TT", axis.target_time)
# Target Radius (target window ?)
self.flexdc_parameter(axis, "TR", axis.target_radius)
# Checks if closed loop parameters have been set.
_ans = self._flexdc_query("%sTT" % axis.channel)
if _ans == "0":
elog.error("Missing closed loop param TT (Target Time)!!")
_ans = self._flexdc_query("%sTR" % axis.channel)
if _ans == "0":
elog.error("Missing closed loop param TR (Target Radius)!!")
# Minimum dead zone
self.flexdc_parameter(axis, "CA[36]", axis.min_dead_zone)
# Maximum dead zone
self.flexdc_parameter(axis, "CA[37]", axis.max_dead_zone)
def init_device(self):
self.debug_stream("In init_device() of axis")
self.get_device_properties(self.get_device_class())
# -v1
self.info_stream("INFO STREAM ON ++++++++++++++++++++++++++")
self.warn_stream("WARN STREAM ON ++++++++++++++++++++++++++")
self.error_stream("ERROR STREAM ON ++++++++++++++++++++++++++")
self.fatal_stream("FATAL STREAM ON ++++++++++++++++++++++++++")
# -v3 (-v == -v4)
self.debug_stream("DEBUG STREAM ON ++++++++++++++++++++++++++")
try:
self.axis = TgGevent.get_proxy(emotion.get_axis, self._axis_name)
self.kontroler = TgGevent.get_proxy(self.axis.controller)
except:
elog.error("unable to get kontroller or axis")
self.set_status(traceback.format_exc())
self.debug_stream("axis found : %s" % self._axis_name)
self.once = False
self._init_time = time.time()
self._t = time.time()
self.attr_Home_position_read = 0.0
self.attr_StepSize_read = 0.0
self.attr_Steps_per_unit_read = 0.0
self.attr_Acceleration_read = 1.0
self.attr_HardLimitLow_read = False
self.attr_HardLimitHigh_read = False
self.attr_Backlash_read = 0.0
self.attr_Offset_read = 0.0
self.attr_Tolerance_read = 0.0
self.attr_PresetPosition_read = 0.0
"""
self.attr_Steps_read = 0
self.attr_Position_read = 0.0
self.attr_Measured_Position_read = 0.0
self.attr_FirstVelocity_read = 0.0
self.attr_Home_side_read = False
"""
self.attr_trajpar_read = [[0.0]]
# To force update of state and status.
self.dev_state()
# elog.info(" %s" % self.axis.get_info())
elog.info(" Emotion.py Axis " + bcolors.PINK + self._ds_name + bcolors.ENDC + " initialized")
def main():
try:
delete_unused_emotion_axes()
except:
elog.error(
"Cannot delete unused emotion axes.",
raise_exception=False)
try:
py = PyTango.Util(sys.argv)
log_param = [param for param in sys.argv if "-v" in param]
if log_param:
log_param = log_param[0]
# print "-vN log flag found len=%d" % len(log_param)
if len(log_param) > 2:
tango_log_level = int(log_param[2:])
elif len(log_param) > 1:
tango_log_level = 4
else:
print "Emotion.py - EMOTION ERROR LOG LEVEL"
if tango_log_level == 1:
elog.level(40)
elif tango_log_level == 2:
elog.level(30)
elif tango_log_level == 3:
elog.level(20)
else:
elog.level(10)
else:
# by default : show INFO
elog.level(20)
tango_log_level = 0
print ""
elog.info(" ---------------------= EMotion PyTango Device Server =----------------------------")
# elog.info("tango log level=%d" % tango_log_level)
# elog.debug("Emotion.py debug message")
# elog.error("Emotion.py error message", raise_exception=False)
# Searches for emotion devices defined in tango database.
U = PyTango.Util.instance()
db = U.get_database()
device_list = get_devices_from_server().get('Emotion')
if device_list is not None:
_device = device_list[0]
elog.info(" Emotion.py - Emotion device : %s" % _device)
try:
_config_file = db.get_device_property(_device, "config_file")["config_file"][0]
except:
elog.info(" Emotion.py - 'config_file' property not present ?")
_config_file = None
first_run = False
else:
elog.error("[FIRST RUN] New server never started ? -> no database entry...", raise_exception=False)
elog.error("[FIRST RUN] NO CUSTOM COMANDS :( ", raise_exception=False)
elog.error("[FIRST RUN] Restart DS to havec CUSTOM COMMANDS", raise_exception=False)
first_run = True
py.add_class(EmotionClass, Emotion)
# py.add_class(EmotionAxisClass, EmotionAxis)
if not first_run:
if _config_file is not None:
elog.info(" Emotion.py - config file : " + bcolors.PINK + _config_file + bcolors.ENDC)
try:
TgGevent.execute(emotion.load_cfg, _config_file)
except:
elog.error("error (not present or syntax error?) in reading config file : %s" %
_config_file, raise_exception=False)
sys.excepthook(*sys.exc_info())
sys.exit(-1)
else:
# Get axis names defined in config file.
axis_names = emotion.config.axis_names_list()
else:
elog.info(" Emotion.py - " + bcolors.PINK + "beacon config" + bcolors.ENDC)
# Get axes names from property (= use beacon to get axis objects)
emotion.config.BACKEND = "beacon"
axis_names = db.get_device_property(_device, "axes")["axes"][0].split()
elog.debug("axis names list : %s" % axis_names)
for axis_name in axis_names:
elog.debug("Emotion.py : _____________ axis %s _____________" % axis_name)
try:
_axis = TgGevent.get_proxy(emotion.get_axis, axis_name)
except ConnectionException:
elog.error("beacon_server seems not running")
sys.exit(-1)
except:
print traceback.format_exc()
sys.exit(-1)
new_axis_class_class = types.ClassType("EmotionAxisClass_%s" % axis_name, (EmotionAxisClass,), {})
new_axis_class = types.ClassType("EmotionAxis_%s" % axis_name, (EmotionAxis,), {})
types_conv_tab = {
None: PyTango.DevVoid,
str: PyTango.DevString,
int: PyTango.DevLong,
float: PyTango.DevDouble,
bool: PyTango.DevBoolean,
"str": PyTango.DevString,
"int": PyTango.DevLong,
"float": PyTango.DevDouble,
"bool": PyTango.DevBoolean,
"None": PyTango.DevVoid,
"float_array": PyTango.DevVarFloatArray,
"double_array": PyTango.DevVarDoubleArray,
"long_array": PyTango.DevVarLongArray,
"string_array": PyTango.DevVarStringArray
}
"""
CUSTOM COMMANDS
"""
# Search and adds custom commands.
_cmd_list = _axis.custom_methods_list()
elog.debug("'%s' custom commands:" % axis_name)
new_axis_class_class.cmd_list = dict(EmotionAxisClass.cmd_list)
for (fname, (t1, t2)) in _cmd_list:
setattr(new_axis_class, fname, getattr(_axis, fname))
tin = types_conv_tab[t1]
tout = types_conv_tab[t2]
new_axis_class_class.cmd_list.update({fname: [[tin, ""], [tout, ""]]})
elog.debug(" %s (in: %s, %s) (out: %s, %s)" % (fname, t1, tin, t2, tout))
"""
SETTINGS AS ATTRIBUTES.
"""
elog.debug(" Emotion.py : %s : -------------- SETTINGS -----------------" % axis_name)
new_axis_class_class.attr_list = dict(EmotionAxisClass.attr_list)
for setting_name in _axis.settings():
if setting_name in ["velocity", "position", "dial_position", "state",
"offset", "low_limit", "high_limit", "acceleration", "_set_position"]:
elog.debug(" Emotion.py -- std SETTING %s " % (setting_name))
else:
_attr_name = setting_name
_setting_type = _axis.controller().axis_settings.convert_funcs[_attr_name]
_attr_type = types_conv_tab[_setting_type]
elog.debug(" Emotion.py -- adds SETTING %s as %s attribute" % (setting_name, _attr_type))
# Updates Attributes list.
new_axis_class_class.attr_list.update({_attr_name:
[[_attr_type,
PyTango._PyTango.AttrDataFormat.SCALAR,
PyTango._PyTango.AttrWriteType.READ_WRITE], {
'Display level': PyTango._PyTango.DispLevel.OPERATOR,
'format': '%10.3f',
'description': '%s : u 2' % _attr_name,
'unit': 'user units/s^2',
'label': _attr_name
}]})
# Creates functions to read and write settings.
def read_custattr(self, attr, _axis=_axis, _attr_name=_attr_name):
_val = _axis.get_setting(_attr_name)
print "in read_%s %s (%s)" % (_attr_name, _val, _axis.name())
attr.set_value(_val)
new_read_attr_method = types.MethodType(read_custattr, new_axis_class,
new_axis_class.__class__)
setattr(new_axis_class, "read_%s" % _attr_name, new_read_attr_method)
def write_custattr(self, attr, _axis=_axis, _attr_name=_attr_name):
data = attr.get_write_value()
print "in write_%s %s (%s)" % (_attr_name, data, _axis.name())
_axis.set_setting(_attr_name, data)
new_write_attr_method = types.MethodType(write_custattr, new_axis_class,
new_axis_class.__class__)
setattr(new_axis_class, "write_%s" % _attr_name, new_write_attr_method)
# End of custom command and settings
elog.debug("Emotion.py : Adds new Axis specific class.")
py.add_class(new_axis_class_class, new_axis_class)
elog.debug("Emotion.py : Class added.")
elog.debug("Emotion.py : intitialize server.")
U.server_init()
except PyTango.DevFailed:
print traceback.format_exc()
elog.exception(
"Error in server initialization")
sys.exit(0)
try:
emotion_admin_device_names = get_devices_from_server().get('Emotion')
if emotion_admin_device_names:
blname, server_name, device_number = emotion_admin_device_names[
0].split('/')
for axis_name in emotion.config.axis_names_list():
device_name = '/'.join((blname,
'%s_%s' % (server_name, device_number),
axis_name))
try:
elog.debug("Creating %s" % device_name)
U.create_device("EmotionAxis_%s" % axis_name, device_name)
except PyTango.DevFailed:
# print traceback.format_exc()
elog.debug("Device %s already defined in Tango database" % device_name)
pass
# If axis name is not already a tango alias,
# define it as an alias of the device.
try:
db.get_device_alias(axis_name)
except PyTango.DevFailed:
db.put_device_alias(device_name, axis_name)
elog.debug("Created alias %s for device %s" % (axis_name, device_name))
else:
# Do not raise exception to be able to use
# Jive device creation wizard.
elog.error("No emotion supervisor device",
raise_exception=False)
except PyTango.DevFailed:
print traceback.format_exc()
elog.exception(
"Error in devices initialization")
sys.exit(0)
U.server_run()
def log_error(self, msg):
"""Logging method"""
log.error(_ICEPAP_TAB + msg)
def tacomaxe_err(msg):
"""Logging method"""
log.error("[TacoMaxe]" + msg)
