def create_measurement_group(self, **kwargs):
name = kwargs['name']
elem_ids = kwargs["user_elements"]
kwargs['pool'] = self
kwargs["pool_name"] = self.name
td = TYPE_MAP_OBJ[ElementType.MeasurementGroup]
klass = td.klass
auto_full_name = td.auto_full_name
full_name = kwargs.get("full_name", auto_full_name.format(**kwargs))
kwargs.pop('pool_name')
self.check_element(name, full_name)
for elem_id in elem_ids:
if isinstance(elem_id, int):
self.pool.get_element(id=elem_id)
else:
tg_attr_validator = TangoAttributeNameValidator()
params = tg_attr_validator.getUriGroups(elem_id)
if params is None:
raise Exception("Invalid channel name %s" % elem_id)
eid = kwargs.get('id')
if eid is None:
kwargs['id'] = eid = self.get_new_id()
else:
self.reserve_id(eid)
elem = klass(**kwargs)
ret = self.add_element(elem)
self.fire_event(EventType("ElementCreated"), elem)
return ret
def create_element(self, **kwargs):
type = kwargs['type']
elem_type = ElementType[type]
name = kwargs['name']
kwargs['macro_server'] = self
td = TYPE_MAP_OBJ[elem_type]
klass = td.klass
auto_full_name = td.auto_full_name
full_name = kwargs.get("full_name", auto_full_name.format(**kwargs))
self.check_element(name, full_name)
id = kwargs.get('id')
if id is None:
kwargs['id'] = id = self.get_new_id()
else:
self.reserve_id(id)
elem = klass(**kwargs)
ret = self.add_element(elem)
self.fire_event(EventType("ElementCreated"), elem)
return ret
def append_value(self, value, propagate=1):
self.accumulation.append_value(value.value, value.timestamp)
if propagate > 0:
evt_type = EventType(self.name, priority=propagate)
self.fire_event(evt_type, self)
def set_macro_status(self, macro_status, propagate=1):
self._macro_status = macro_status
self.fire_event(EventType("macrostatus", priority=propagate),
macro_status)
def set_status(self, status, propagate=1):
self._status = status
self.fire_event(EventType("status", priority=propagate), status)
def on_pool_elements_changed(self, evt_src, evt_type, evt_value):
if evt_type not in CHANGE_EVT_TYPES:
return
self.fire_event(EventType("PoolElementsChanged"), evt_value)
def _set_velocity(self, velocity, propagate=1):
self._velocity = velocity
if not propagate:
return
self.fire_event(EventType("velocity", priority=propagate), velocity)
def _set_deceleration(self, deceleration, propagate=1):
self._deceleration = deceleration
if not propagate:
return
self.fire_event(
EventType("deceleration", priority=propagate), deceleration)
def _set_data_source(self, data_source, propagate=1):
self._data_source = data_source
if not propagate:
return
self.fire_event(EventType("data_source", priority=propagate),
data_source)
def fire_passive(self):
self.fire_event(EventType("passive"), self._id)
self.set_passive_events(self.passive_events[1:])
def _set_shape(self, shape, propagate=1):
self._shape = shape
if not propagate:
return
self.fire_event(
EventType("shape", priority=propagate), shape)
def set_configuration(self, config=None, propagate=1, to_fqdn=True):
if config is None:
config = self._build_configuration()
else:
# create a configuration based on a new configuration
user_elem_ids = {}
tg_elem_ids = []
pool = self.pool
for c, c_data in config['controllers'].items():
synchronizer = c_data.get('synchronizer')
acq_synch_type = c_data.get('synchronization')
software = synchronizer == 'software'
external = isinstance(c, (str, unicode))
# only timerable elements are configured with acq_synch
acq_synch = None
ctrl_enabled = False
if not external and c.is_timerable():
acq_synch = AcqSynch.from_synch_type(
software, acq_synch_type)
for channel_data in c_data['channels'].values():
if external:
element = _id = channel_data['full_name']
channel_data['source'] = _id
else:
full_name = channel_data['full_name']
if to_fqdn:
full_name = _to_fqdn(full_name, logger=self)
element = pool.get_element_by_full_name(full_name)
_id = element.id
channel_data = self._build_channel_defaults(
channel_data, element)
if channel_data["enabled"]:
if acq_synch is not None:
ctrl_enabled = True
self._channel_to_acq_synch[element] = acq_synch
if not software:
tg_elem_ids.append(synchronizer.id)
user_elem_ids[channel_data['index']] = _id
if ctrl_enabled:
self._ctrl_to_acq_synch[c] = acq_synch
# sorted ids may not be consecutive (if a channel is disabled)
indexes = sorted(user_elem_ids.keys())
user_elem_ids_list = [user_elem_ids[idx] for idx in indexes]
user_elem_ids_list.extend(tg_elem_ids)
self.set_user_element_ids(user_elem_ids_list)
g_timer, g_monitor = config['timer'], config['monitor']
timer_ctrl_data = config['controllers'][g_timer.controller]
if timer_ctrl_data['timer'] != g_timer:
self.warning('controller timer and global timer mismatch. '
'Using global timer')
self.debug(
'For controller %s, timer is defined as channel %s. '
'The global timer is set to channel %s which belongs '
'to the same controller', g_timer.controller.name,
timer_ctrl_data['timer'].name, g_timer.name)
timer_ctrl_data['timer'] = g_timer
monitor_ctrl_data = config['controllers'][g_monitor.controller]
if monitor_ctrl_data['monitor'] != g_monitor:
self.warning('controller monitor and global monitor mismatch. '
'Using global monitor')
self.debug(
'For controller %s, monitor is defined as channel %s. '
'The global timer is set to channel %s which belongs '
'to the same controller', g_monitor.controller.name,
monitor_ctrl_data['monitor'].name, g_monitor.name)
monitor_ctrl_data['monitor'] != g_monitor
self._config = config
self._config_dirty = True
if not propagate:
return
self.fire_event(EventType("configuration", priority=propagate), config)
def set_nb_starts(self, nb_starts, propagate=1):
self._nb_starts = nb_starts
if not propagate:
return
self.fire_event(EventType("nb_starts", priority=propagate), nb_starts)
def set_moveable(self, moveable, propagate=1):
self._moveable = moveable
if self._moveable != 'None' and self._moveable is not None:
self._moveable_obj = self.pool.get_element_by_full_name(moveable)
self.fire_event(EventType("moveable", priority=propagate), moveable)
def fire_end(self):
self.fire_event(EventType("end"), self._id)
def set_backlash(self, backlash, propagate=1):
self._backlash = backlash
if propagate > 0:
self.fire_event(
EventType("backlash", priority=propagate), backlash)
def _set_acceleration(self, acceleration, propagate=1):
self._acceleration = acceleration
if not propagate:
return
self.fire_event(
EventType("acceleration", priority=propagate), acceleration)
def set_integration_time(self, integration_time, propagate=1):
self._integration_time = integration_time
if not propagate:
return
self.fire_event(EventType("integration_time", priority=propagate),
integration_time)
def _set_base_rate(self, base_rate, propagate=1):
self._base_rate = base_rate
if not propagate:
return
self.fire_event(EventType("base_rate", priority=propagate), base_rate)
def set_monitor_count(self, monitor_count, propagate=1):
self._monitor_count = monitor_count
if not propagate:
return
self.fire_event(EventType("monitor_count", priority=propagate),
monitor_count)
def run(self, start=0, end=2, step=0.01, sleep=0.01):
for position in numpy.arange(start, end, step):
self.value = position
self.fire_event(EventType("Position"), self)
time.sleep(sleep)
def set_acquisition_mode(self, acquisition_mode, propagate=1):
self._acquisition_mode = acquisition_mode
if not propagate:
return
self.fire_event(EventType("acquisition_mode", priority=propagate),
acquisition_mode)
def set_state(self, state, propagate=1):
self._state = state
self.fire_event(EventType("state", priority=propagate), state)
def _set_value_ref_pattern(self, value_ref_pattern, propagate=1):
self._value_ref_pattern = value_ref_pattern
if not propagate:
return
self.fire_event(EventType("value_ref_pattern", priority=propagate),
value_ref_pattern)
def set_result(self, result, propagate=1):
self._result = result
self.fire_event(EventType("result", priority=propagate), result)
def _set_value_ref_enabled(self, value_ref_enabled, propagate=1):
self._value_ref_enabled = value_ref_enabled
if not propagate:
return
self.fire_event(EventType("value_ref_enabled", priority=propagate),
value_ref_enabled)
def set_record_data(self, record_data, codec=None, propagate=1):
self._record_data = record_data
self.fire_event(EventType("recorddata", priority=propagate),
(codec, record_data))
def rename_element(self, old_name, new_name):
elem = self.get_element_by_name(old_name)
elem.controller.rename_element(old_name, new_name)
PoolContainer.rename_element(self, old_name, new_name)
elem = self.get_element_by_name(new_name)
self.fire_event(EventType("ElementChanged"), elem)
def append_value(self, value, timestamp=None, propagate=1):
cumulation = self.cumulation
cumulation.append_value(value, timestamp)
if not propagate:
return
self.fire_event(EventType("value", priority=propagate), cumulation.value)
def set_instability_time(self, instability_time, propagate=1):
self._instability_time = instability_time
if propagate > 0:
self.fire_event(EventType("instability_time", priority=propagate),
instability_time)