def init_device(self):
        PoolElementDevice.init_device(self)
        motor = self.motor
        if motor is None:
            full_name = self.get_full_name()
            name = self.alias or full_name
            self.motor = motor = \
                self.pool.create_element(type="Motor", name=name,
                    full_name=full_name, id=self.Id, axis=self.Axis,
                    ctrl_id=self.Ctrl_id)
            if self.instrument is not None:
                motor.set_instrument(self.instrument)
            # if in constructor, for all memorized no init attributes (position)
            # let poolmotor know their write values
            if self.in_constructor:
                try:
                    w_pos, w_ts = self.get_write_dial_position_from_db()
                    self.in_write_position = True
                    try:
                        motor.set_write_position(w_pos, timestamp=w_ts)
                    finally:
                        self.in_write_position = False
                except KeyError:
                    pass

        if self.Sleep_bef_last_read > 0:
            motor.set_instability_time(self.Sleep_bef_last_read / 1000.0)
        motor.add_listener(self.on_motor_changed)
        self.set_state(DevState.ON)

    def init_device(self):
        PoolElementDevice.init_device(self)

        tg = self.tg
        if tg is None:
            full_name = self.get_full_name()
            name = self.alias or full_name
            self.tg = tg = \
                self.pool.create_element(type="TriggerGate",
                                         name=name, full_name=full_name, id=self.Id, axis=self.Axis,
                                         ctrl_id=self.Ctrl_id)

        tg.add_listener(self.on_tg_changed)
        self.set_state(DevState.ON)

    def init_device(self):
        PoolElementDevice.init_device(self)
        zerod = self.zerod
        if zerod is None:
            full_name = self.get_full_name()
            name = self.alias or full_name
            self.zerod = zerod = \
                self.pool.create_element(type="ZeroDExpChannel", name=name,
                    full_name=full_name, id=self.Id, axis=self.Axis,
                    ctrl_id=self.Ctrl_id)
        zerod.add_listener(self.on_zerod_changed)

        ## force a state read to initialize the state attribute
        #state = zerod.state
        self.set_state(DevState.ON)

    def init_device(self):
        PoolElementDevice.init_device(self)

        self.Elements = map(int, self.Elements)
        pseudo_counter = self.pseudo_counter
        if pseudo_counter is None:
            full_name = self.get_full_name()
            name = self.alias or full_name
            self.pseudo_counter = pseudo_counter = \
                self.pool.create_element(type="PseudoCounter", name=name,
                    full_name=full_name, id=self.Id, axis=self.Axis,
                    ctrl_id=self.Ctrl_id, user_elements=self.Elements)
            if self.instrument is not None:
                pseudo_counter.set_instrument(self.instrument)
        pseudo_counter.add_listener(self.on_pseudo_counter_changed)

        self.set_state(DevState.ON)

    def init_device(self):
        PoolElementDevice.init_device(self)
        twod = self.twod
        if twod is None:
            full_name = self.get_full_name()
            name = self.alias or full_name
            self.twod = twod = \
                self.pool.create_element(type="TwoDExpChannel",
                    name=name, full_name=full_name, id=self.Id, axis=self.Axis,
                    ctrl_id=self.Ctrl_id)
            if self.instrument is not None:
                twod.set_instrument(self.instrument)
        twod.add_listener(self.on_twod_changed)

        ## force a state read to initialize the state attribute
        #state = ct.state
        self.set_state(DevState.ON)

    def init_device(self):
        PoolElementDevice.init_device(self)

        ior = self.ior
        if ior is None:
            full_name = self.get_full_name()
            name = self.alias or full_name
            self.ior = ior = \
                self.pool.create_element(type="IORegister", name=name,
                    full_name=full_name, id=self.Id, axis=self.Axis,
                    ctrl_id=self.Ctrl_id)
            if self.instrument is not None:
                ior.set_instrument(self.instrument)
        ior.add_listener(self.on_ior_changed)

        ## force a state read to initialize the state attribute
        #state = ior.get_state(cache=False)
        self.set_state(DevState.ON)

 def get_attributes_to_restore(self):
     """Make sure position is the last attribute to restore"""
     restore_attributes = PoolElementDevice.get_attributes_to_restore(self)
     try:
         restore_attributes.remove('Position')
         restore_attributes.append('Position')
     except ValueError:
         pass
     return restore_attributes

    def initialize_dynamic_attributes(self):
        attrs = PoolElementDevice.initialize_dynamic_attributes(self)

        detect_evts = "value",
        non_detect_evts = ()

        for attr_name in detect_evts:
            if attr_name in attrs:
                self.set_change_event(attr_name, True, True)
        for attr_name in non_detect_evts:
            if attr_name in attrs:
                self.set_change_event(attr_name, True, False)

    def initialize_dynamic_attributes(self):
        attrs = PoolElementDevice.initialize_dynamic_attributes(self)

        detect_evts = "position", "dialposition",
        non_detect_evts = "limit_switches", "step_per_unit", "offset", \
            "sign", "velocity", "acceleration", "deceleration", "base_rate", \
            "backlash"

        for attr_name in detect_evts:
            if attr_name in attrs:
                self.set_change_event(attr_name, True, True)
        for attr_name in non_detect_evts:
            if attr_name in attrs:
                self.set_change_event(attr_name, True, False)

    def get_dynamic_attributes(self):
        cache_built = hasattr(self, "_dynamic_attributes_cache")

        std_attrs, dyn_attrs = \
            PoolElementDevice.get_dynamic_attributes(self)

        if not cache_built:
            # For position attribute, listen to what the controller says for data
            # type (between long and float)
            pos = std_attrs.get('position')
            if pos is not None:
                _, data_info, attr_info = pos
                ttype, _ = to_tango_type_format(attr_info.dtype)
                data_info[0][0] = ttype
        return std_attrs, dyn_attrs

    def get_dynamic_attributes(self):
        cache_built = hasattr(self, "_dynamic_attributes_cache")

        std_attrs, dyn_attrs = \
            PoolElementDevice.get_dynamic_attributes(self)

        if not cache_built:
            # For value attribute, listen to what the controller says for data
            # type (between long, float or bool)
            value = std_attrs.get('value')
            if value is not None:
                _, data_info, attr_info = value
                ttype, _ = to_tango_type_format(attr_info.dtype)
                data_info[0][0] = ttype
        return std_attrs, dyn_attrs

    def get_dynamic_attributes(self):
        cache_built = hasattr(self, "_dynamic_attributes_cache")

        std_attrs, dyn_attrs = \
            PoolElementDevice.get_dynamic_attributes(self)

        if not cache_built:
            # For value attribute, listen to what the controller says for data
            # type (between long and float) and length
            value = std_attrs.get('value')
            if value is not None:
                _, data_info, attr_info = value
                ttype, _ = to_tango_type_format(attr_info.dtype)
                data_info[0][0] = ttype
                shape = attr_info.maxdimsize
                data_info[0][3] = shape[0]
                data_info[0][4] = shape[1]
        return std_attrs, dyn_attrs

    def get_dynamic_attributes(self):
        cache_built = hasattr(self, "_dynamic_attributes_cache")

        std_attrs, dyn_attrs = \
            PoolElementDevice.get_dynamic_attributes(self)

        if not cache_built:
            # For value attribute, listen to what the controller says for data
            # type (between long and float)
            value = std_attrs.get('value')
            if value is not None:
                attr_name, data_info, attr_info = value
                ttype, _ = to_tango_type_format(attr_info.dtype)
                data_info[0][0] = ttype

                # Add manually a 'CurrentValue' with the same time as 'Value'
                attr_name = 'CurrentValue'
                attr_info = attr_info.copy()
                attr_info.description = attr_name
                std_attrs[attr_name] = [attr_name, data_info, attr_info]

        return std_attrs, dyn_attrs

 def delete_device(self):
     PoolElementDevice.delete_device(self)
     oned = self.oned
     if oned is not None:
         oned.remove_listener(self.on_oned_changed)

 def delete_device(self):
     PoolElementDevice.delete_device(self)
     pseudo_motor = self.pseudo_motor
     if pseudo_motor is not None:
         pseudo_motor.remove_listener(self.on_pseudo_motor_changed)

 def __init__(self, dclass, name):
     self.in_write_position = False
     PoolElementDevice.__init__(self, dclass, name)

 def delete_device(self):
     PoolElementDevice.delete_device(self)
     motor = self.motor
     if motor is not None:
         motor.remove_listener(self.on_motor_changed)

 def __init__(self, dclass, name):
     self.in_write_value = False
     PoolElementDevice.__init__(self, dclass, name)

 def delete_device(self):
     PoolElementDevice.delete_device(self)
     zerod = self.zerod
     if zerod is not None:
         zerod.remove_listener(self.on_zerod_changed)

 def delete_device(self):
     PoolElementDevice.delete_device(self)
     twod = self.twod
     if twod is not None:
         twod.remove_listener(self.on_twod_changed)