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)