pymodaq 5.0.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

pymodaq/control_modules/move_utility_classes.py

@@ -1,6 +1,9 @@
+import numbers
+
 from time import perf_counter
 from typing import Union, List, Dict, TYPE_CHECKING, Optional
 from numbers import Number
+from collections.abc import Iterable
 
 from easydict import EasyDict as edict
 import numpy as np
@@ -16,11 +19,20 @@ from pymodaq_utils.logger import set_logger, get_module_name
 import pymodaq_gui.parameter.utils as putils
 from pymodaq_gui.parameter import Parameter
 from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.utils.utils import mkQApp
 
 from pymodaq.utils.tcp_ip.tcp_server_client import TCPServer, tcp_parameters
+
+from pymodaq_data.data import DataUnitError, Q_
+
+from pymodaq.utils.messenger import deprecation_msg
 from pymodaq.utils.data import DataActuator
-from pymodaq.utils.tcp_ip.mysocket import Socket
-from pymodaq.utils.tcp_ip.serializer import DeSerializer, Serializer
+from pymodaq_utils.enums import BaseEnum, enum_checker
+
+from pymodaq_utils.serialize.mysocket import Socket
+from pymodaq_utils.serialize.serializer_legacy import DeSerializer, Serializer
+from pymodaq import Unit
+from pint.errors import OffsetUnitCalculusError
 
 if TYPE_CHECKING:
     from pymodaq.control_modules.daq_move import DAQ_Move_Hardware
@@ -29,13 +41,45 @@ logger = set_logger(get_module_name(__file__))
 config = configmod.Config()
 
 
+def check_units(dwa: DataActuator, units: str):
+    """ Check if dwa units is compatible with the units argument
+
+    If it is incompatible and has dimensionless units,  brute force change the dwa units to units,
+    otherwise raise a DataUnitError
+
+    Parameters
+    ----------
+    dwa: DataActuator
+    units: str
+
+    Returns
+    -------
+    DataActuator
+    """
+    if Unit(dwa.units).is_compatible_with(units):
+        return dwa
+    elif Unit(dwa.units).dimensionless:  # dimensionless
+        dwa.force_units(units)
+        return dwa
+    else:
+        raise DataUnitError(f'Units incompatibility between {dwa} and "{units}" units')
+
+
 class DataActuatorType(BaseEnum):
     """Enum for new or old style holding the value of the actuator"""
     float = 0
     DataActuator = 1
 
 
-def comon_parameters(epsilon=config('actuator', 'epsilon_default')):
+def comon_parameters(epsilon=config('actuator', 'epsilon_default'),
+                     epsilons=None):
+    if epsilons is not None:
+        epsilon = epsilons
+    if isinstance(epsilon, list):
+        epsilon = epsilon[0]
+    elif isinstance(epsilon, dict):
+        epsilon = epsilon[list[epsilon.keys()][0]]
+
     return [{'title': 'Units:', 'name': 'units', 'type': 'str', 'value': '', 'readonly': True},
             {'title': 'Epsilon:', 'name': 'epsilon', 'type': 'float',
              'value': epsilon,
@@ -78,28 +122,52 @@ class MoveCommand:
         self.value = value
 
 
-def comon_parameters_fun(is_multiaxes=False, axes_names=[], axis_names=[], master=True, epsilon=config('actuator', 'epsilon_default')):
+def comon_parameters_fun(is_multiaxes=False, axes_names=None,
+                         axis_names: Union[List, Dict] = [],
+                         master=True,
+                         epsilon: float = config('actuator', 'epsilon_default')):
+
     """Function returning the common and mandatory parameters that should be on the actuator plugin level
 
     Parameters
     ----------
     is_multiaxes: bool
         If True, display the particular settings to define which axis the controller is driving
-    axis_names: list of str
+    axes_names: deprecated, use axis_names
+    axis_names: list of str or dictionnary of string as key and integer as value
         The string identifier of every axis the controller can drive
     master: bool
         If True consider this plugin has to init the controller, otherwise use an already initialized instance
+    epsilon: float
+        deprecated (< 5.0.0) no more used here
+
     """
-    if axis_names == [] and len(axes_names) != 0:
+    if axes_names is not None and len(axis_names) == 0:
+        if len(axes_names) == 0:
+            axes_names = ['']
         axis_names = axes_names
 
+    is_multiaxes = len(axis_names) > 1 or is_multiaxes
+    if isinstance(axis_names, list):
+        if len(axis_names) > 0:
+            axis_name = axis_names[0]
+        else:
+            axis_names = ['']
+            axis_name = ''
+    elif isinstance(axis_names, dict):
+        axis_name = axis_names[list(axis_names.keys())[0]]
+    else:
+        raise ValueError('axis_names should be either a list of string or a dict with strings '
+                         'as keys')
     params = [
-                 {'title': 'MultiAxes:', 'name': 'multiaxes', 'type': 'group', 'visible': is_multiaxes, 'children': [
-                     {'title': 'is Multiaxes:', 'name': 'ismultiaxes', 'type': 'bool', 'value': is_multiaxes,
-                      'default': False},
+                 {'title': 'MultiAxes:', 'name': 'multiaxes', 'type': 'group',
+                  'visible': True, 'children': [
+                     {'title': 'Controller ID:', 'name': 'controller_ID', 'type': 'int', 'value': 0,
+                      'default': 0},
                      {'title': 'Status:', 'name': 'multi_status', 'type': 'list',
                       'value': 'Master' if master else 'Slave', 'limits': ['Master', 'Slave']},
-                     {'title': 'Axis:', 'name': 'axis', 'type': 'list', 'limits': axis_names},
+                     {'title': 'Axis:', 'name': 'axis', 'type': 'list', 'limits': axis_names,
+                      'value': axis_name},
                  ]},
              ] + comon_parameters(epsilon)
     return params
@@ -110,7 +178,7 @@ params = [
         {'title': 'Actuator type:', 'name': 'move_type', 'type': 'str', 'value': '', 'readonly': True},
         {'title': 'Actuator name:', 'name': 'module_name', 'type': 'str', 'value': '', 'readonly': True},
         {'title': 'Plugin Config:', 'name': 'plugin_config', 'type': 'bool_push', 'label': 'Show Config', },
-        {'title': 'Controller ID:', 'name': 'controller_ID', 'type': 'int', 'value': 0, 'default': 0},
+
         {'title': 'Refresh value (ms):', 'name': 'refresh_timeout', 'type': 'int',
             'value': config('actuator', 'refresh_timeout_ms')},
         {'title': 'TCP/IP options:', 'name': 'tcpip', 'type': 'group', 'visible': True, 'expanded': False,
@@ -147,13 +215,13 @@ def main(plugin_file, init=True, title='test'):
     from qtpy import QtWidgets
     from pymodaq.control_modules.daq_move import DAQ_Move
     from pathlib import Path
-    app = QtWidgets.QApplication(sys.argv)
-    if config('style', 'darkstyle'):
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet())
+
+    act = Path(plugin_file).stem.split('daq_move_')[1]
+
+    app = mkQApp("PyMoDAQ Viewer")
 
     widget = QtWidgets.QWidget()
-    prog = DAQ_Move(widget, title=title,)
+    prog = DAQ_Move(widget, title=title, actuator=act)
     widget.show()
     prog.actuator = Path(plugin_file).stem[9:]
     if init:
@@ -199,11 +267,17 @@ class DAQ_Move_base(QObject):
 
     move_done_signal = Signal(DataActuator)
     is_multiaxes = False
-    stage_names = []
+    stage_names = []  # deprecated
+
+    _axis_names: Union[list, Dict[str, int]] = None
+    _controller_units: Union[str, List[str], Dict[str, int]] = ''
+    _epsilons: Union[float, List[float], Dict[str, float]] = None
+    _epsilon = 1.0  # deprecated
+
+
     params = []
-    _controller_units = ''
-    _epsilon = 1
-    data_actuator_type = DataActuatorType['float']
+
+    data_actuator_type = DataActuatorType.float
     data_shape = (1, )  # expected shape of the underlying actuator's value (in general a float so shape = (1, ))
 
     def __init__(self, parent: Optional['DAQ_Move_Hardware'] = None,
@@ -212,6 +286,7 @@ class DAQ_Move_base(QObject):
         self.move_is_done = False
         self.parent = parent
         self.stage = None
+        self.controller = None
         self.status = edict(info="", controller=None, stage=None, initialized=False)
 
         self._ispolling = True
@@ -225,17 +300,25 @@ class DAQ_Move_base(QObject):
                 self.settings.restoreState(params_state.saveState())
 
         self.settings.sigTreeStateChanged.connect(self.send_param_status)
-        # self.settings.child('multiaxes',
-        #                     'axis').sigLimitsChanged.connect(lambda param,
-        #                                                             limits: self.send_param_status(
-        #    param, [(param, 'limits', None)]))
+
         if parent is not None:
             self._title = parent.title
         else:
             self._title = "myactuator"
-        self._current_value = DataActuator(self._title, data=[np.zeros(self.data_shape, dtype=float)])
-        self._target_value = DataActuator(self._title, data=[np.zeros(self.data_shape, dtype=float)])
-        self.controller_units = self._controller_units
+
+        self._axis_units: Union[Dict[str, str], List[str]] = None
+        self.axis_units = self._controller_units
+        if self._epsilons is None:
+            self._epsilons = self._epsilon
+        self.epsilons = self._epsilons
+        self.axis_name = self.axis_name  # to trigger some actions on units and epsilons
+
+        self._current_value = DataActuator(self._title,
+                                           data=[np.zeros(self.data_shape, dtype=float)],
+                                           units=self.axis_unit)
+        self._target_value = DataActuator(self._title,
+                                          data=[np.zeros(self.data_shape, dtype=float)],
+                                          units=self.axis_unit)
 
         self.poll_timer = QTimer()
         self.poll_timer.setInterval(config('actuator', 'polling_interval_ms'))
@@ -245,7 +328,108 @@ class DAQ_Move_base(QObject):
         self.ini_attributes()
 
     @property
-    def axis_name(self) -> Union[str, object]:
+    def axis_unit(self) -> str:
+        """ Get/set the unit of the currently chosen axis
+
+        Will update the printed controller unit in the UI
+
+        New in 4.4.0
+        """
+        return self.axis_units[self.axis_index_key]
+
+    @axis_unit.setter
+    def axis_unit(self, unit: str):
+        self.axis_units[self.axis_index_key] = unit
+        self.settings.child('units').setValue(unit)
+        self.emit_status(ThreadCommand('units', unit))
+
+    @property
+    def axis_units(self) -> Union[List[str], Dict[str, str]]:
+        """ Get/Set the units for each axis of the controller
+
+        New in 4.4.0
+        """
+        return self._axis_units
+
+    @axis_units.setter
+    def axis_units(self, units: Union[str, List[str], Dict[str, str]]):
+        if isinstance(units, str):
+            if isinstance(self.axis_names, list):
+                units_tmp = [units for _ in range(len(self.axis_names))]
+            else:
+                units_tmp = {}
+                for key in self.axis_names:
+                    units_tmp[key] = units
+        else:
+            if not isinstance(units, type(self.axis_names)):
+                raise TypeError('units should be defined just like axis_names: a str, list of string or'
+                                'dict of string')
+            if len(units) != len(self.axis_names):
+                raise ValueError('Units should be defined either as a single str or a list/dict with'
+                                 'a str defined for each axis')
+            units_tmp = units
+        self._axis_units = units_tmp
+
+    @property
+    def epsilon(self) -> float:
+        """ Get/Set the epsilon of the currently chosen axis
+
+        New in 4.4.0
+        """
+        return self.epsilons[self.axis_index_key]
+
+    @epsilon.setter
+    def epsilon(self, eps: float):
+        self.epsilons[self.axis_index_key] = eps
+
+    @property
+    def epsilons(self) -> Union[List[float], Dict[str, float]]:
+        """ Get/Set the epsilon for each axis of the controller
+
+        New in 4.4.0
+        """
+        return self._epsilons
+
+    @epsilons.setter
+    def epsilons(self, epsilons: Union[float, List[float], Dict[str, float]]):
+        if isinstance(epsilons, numbers.Number):
+            if isinstance(self.axis_names, list):
+                epsilons_tmp = [epsilons for _ in range(len(self.axis_names))]
+            else:
+                epsilons_tmp = {}
+                for key in self.axis_names:
+                    epsilons_tmp[key] = epsilons
+        else:
+            if not isinstance(epsilons, type(self.axis_names)):
+                raise TypeError('units should be defined just like axis_names: a float, list of '
+                                'float or dict of float')
+            if len(epsilons) != len(self.axis_names):
+                raise ValueError('epsilons should be defined either as a single float or a '
+                                 'list/dict with'
+                                 'a float defined for each axis')
+            epsilons_tmp = epsilons
+        self._epsilons = epsilons_tmp
+
+    @property
+    def controller_units(self):
+        """ Get/Set the units of the currently chosen axis of the controller
+
+        Deprecated with pymodaq >= 4.4.0
+
+        The property controller_units is deprecated please use the axis_unit property
+        """
+        deprecation_msg('The property controller_units is deprecated please use the'
+                        'axis_unit property.')
+        return self.axis_unit
+
+    @controller_units.setter
+    def controller_units(self, units: str = ''):
+        deprecation_msg('The property controller_units is deprecated please use the'
+                        'axis_unit property.')
+        self._axis_units[self.axis_index_key] = units
+
+    @property
+    def axis_name(self) -> Union[str]:
         """Get/Set the current axis using its string identifier"""
         limits = self.settings.child('multiaxes', 'axis').opts['limits']
         if isinstance(limits, list):
@@ -262,6 +446,10 @@ class DAQ_Move_base(QObject):
             elif isinstance(limits, dict):
                 self.settings.child('multiaxes', 'axis').setValue(limits[name])
             QtWidgets.QApplication.processEvents()
+            self.axis_unit = self.axis_unit
+            self.settings.child('epsilon').setValue(self.epsilon)
+            if self.controller is not None:
+                self._current_value = self.get_actuator_value()
 
     @property
     def axis_names(self) -> Union[List, Dict]:
@@ -279,15 +467,35 @@ class DAQ_Move_base(QObject):
         QtWidgets.QApplication.processEvents()
 
     @property
-    def axis_value(self) -> object:
-        """Get the current value selected from the current axis"""
-        return self.settings['multiaxes', 'axis']
+    def axis_value(self) -> int:
+        """Get the current value selected from the current axis
+
+        In case axis_names is a list, return the element of the list: self.axis_name
+        In case axis_names is a dict, return the value of the dict self.axis_names[self.axis_name]
+        """
+        if isinstance(self.axis_names, list):
+            return self.axis_name
+        else:
+            return self.axis_names[self.axis_name]
+
+    @property
+    def axis_index_key(self) -> Union[int, str]:
+        """ Get the current index or key correspondingto the current axis
+
+        In case axis_names is a list, return the index wihtin the list
+        In case axis_names is a dict, return the key of the dict self.axis_name
+
+        """
+        if isinstance(self.axis_names, list):
+            return self.axis_names.index(self.axis_name)
+        else:
+            return self.axis_name
 
     def ini_attributes(self):
         """ To be subclassed, in order to init specific attributes needed by the real implementation"""
         self.controller = None
 
-    def ini_stage_init(self, old_controller=None, new_controller=None):
+    def ini_stage_init(self, old_controller=None, new_controller=None, slave_controller=None):
         """Manage the Master/Slave controller issue
 
         First initialize the status dictionary
@@ -305,10 +513,14 @@ class DAQ_Move_base(QObject):
             The particular object that allow the communication with the hardware, in general a python wrapper around the
             hardware library. In case of Master it is the new instance of your plugin controller
         """
+        if old_controller is None and slave_controller is not None:
+            old_controller = slave_controller
+
         self.status.update(edict(info="", controller=None, initialized=False))
-        if self.settings['multiaxes', 'ismultiaxes'] and self.settings['multiaxes', 'multi_status'] == "Slave":
+        if not self.is_master:
             if old_controller is None:
-                raise Exception('no controller has been defined externally while this axe is a slave one')
+                raise Exception('no controller has been defined externally while this axe '
+                                'is a slave one')
             else:
                 controller = old_controller
         else:  # Master stage
@@ -318,30 +530,40 @@ class DAQ_Move_base(QObject):
 
     @property
     def current_value(self):
-        if self.data_actuator_type.name == 'float':
+        if self.data_actuator_type == self.data_actuator_type.float:
             return self._current_value.value()
         else:
             return self._current_value
 
     @current_value.setter
-    def current_value(self, value: Union[float, DataActuator]):
-        if not isinstance(value, DataActuator):
-            self._current_value = DataActuator(self._title, data=value)
+    def current_value(self, value: Union[float, np.ndarray, DataActuator]):
+        if isinstance(value, numbers.Number) or isinstance(value, np.ndarray):
+            self._current_value = DataActuator(self._title, data=value,
+                                               units=self.axis_unit)
         else:
+            if (not Unit(self.axis_unit).is_compatible_with(
+                    Unit(value.units)) and
+                    value.units == ''):
+                value.force_units(self.axis_unit)
             self._current_value = value
 
     @property
     def target_value(self):
-        if self.data_actuator_type.name == 'float':
+        if self.data_actuator_type.name == self.data_actuator_type.float:
             return self._target_value.value()
         else:
             return self._target_value
 
     @target_value.setter
-    def target_value(self, value: Union[float, DataActuator]):
-        if not isinstance(value, DataActuator):
-            self._target_value = DataActuator(self._title, data=value)
+    def target_value(self, value: Union[numbers.Number, DataActuator]):
+        if isinstance(value, numbers.Number):
+            self._target_value = DataActuator(self._title, data=value,
+                                              units=self.axis_unit)
         else:
+            if (not Unit(self.axis_unit).is_compatible_with(
+                    Unit(value.units)) and
+                    value.units == ''):
+                value.force_units(self.axis_unit)
             self._target_value = value
 
     @property
@@ -370,20 +592,6 @@ class DAQ_Move_base(QObject):
         """
         return self.settings['multiaxes', 'multi_status'] == 'Master'
 
-    @property
-    def controller_units(self):
-        """ Get/Set the units of this plugin"""
-        return self._controller_units
-
-    @controller_units.setter
-    def controller_units(self, units: str = ''):
-        self._controller_units = units
-        try:
-            self.settings.child('units').setValue(units)
-            self.emit_status(ThreadCommand('units', units))
-        except Exception:
-            pass
-
     @property
     def ispolling(self):
         """ Get/Set the polling status"""
@@ -398,13 +606,11 @@ class DAQ_Move_base(QObject):
 
         Return the new position eventually coerced within the bounds
         """
-        if self.settings.child('bounds', 'is_bounds').value():
-            if position > self.settings.child('bounds', 'max_bound').value():
-                position = DataActuator(self._title, data=self.settings.child('bounds', 'max_bound').value())
-                self.emit_status(ThreadCommand('outofbounds', []))
-            elif position < self.settings.child('bounds', 'min_bound').value():
-                position = DataActuator(self._title, data=self.settings.child('bounds', 'min_bound').value())
-                self.emit_status(ThreadCommand('outofbounds', []))
+        if self.settings['bounds', 'is_bounds']:
+            for data_array in position:
+                data_array[data_array > self.settings['bounds', 'max_bound']] = self.settings['bounds', 'max_bound']
+                data_array[data_array < self.settings['bounds', 'min_bound']] = self.settings['bounds', 'min_bound']
+            self.emit_status(ThreadCommand('outofbounds', []))
         return position
 
     def get_actuator_value(self):
@@ -414,6 +620,10 @@ class DAQ_Move_base(QObject):
         else:
             raise NotImplementedError
 
+
+    def close(self):
+        raise NotImplementedError
+
     def move_abs(self, value: Union[float, DataActuator]):
         if hasattr(self, 'move_Abs'):
             deprecation_msg('move_Abs method in plugins is deprecated, use move_abs', 3)
@@ -470,12 +680,14 @@ class DAQ_Move_base(QObject):
         """
         if position is None:
             if self.data_actuator_type.name == 'float':
-                position = DataActuator(self._title, data=self.get_actuator_value())
+                position = DataActuator(self._title, data=self.get_actuator_value(),
+                                        units=self.axis_unit)
             else:
                 position = self.get_actuator_value()
         if position.name != self._title:  # make sure the emitted DataActuator has the name of the real implementation
             #of the plugin
-            position = DataActuator(self._title, data=position.value())
+            position = DataActuator(self._title, data=position.value(),
+                                    units=self.axis_unit)
         self.move_done_signal.emit(position)
         self.move_is_done = True
 
@@ -491,31 +703,74 @@ class DAQ_Move_base(QObject):
             if self.ispolling:
                 self.poll_timer.start()
             else:
-                if self.data_actuator_type.name == 'float':
-                    self._current_value = DataActuator(data=self.get_actuator_value())
+                if self.data_actuator_type == DataActuatorType.float:
+                    self._current_value = DataActuator(data=self.get_actuator_value(),
+                                                       units=self.axis_unit)
                 else:
                     self._current_value = self.get_actuator_value()
+                    if (not Unit(self.axis_unit).is_compatible_with(
+                            Unit(self._current_value.units)) and
+                            self._current_value.units == ''):
+                        # this happens if the units have not been specified in
+                        # the plugin
+                        self._current_value.force_units(self.axis_unit)
+
                 logger.debug(f'Current position: {self._current_value}')
                 self.move_done(self._current_value)
 
-    def check_target_reached(self):
-        # if not isinstance(self._current_value, DataActuator):
-        #     self._current_value = DataActuator(data=self._current_value)
-        # if not isinstance(self._target_value, DataActuator):
-        #     self._target_value = DataActuator(data=self._target_value)
+    def _condition_to_reach_target(self) -> bool:
+        """ Implement the condition for exiting the polling mechanism and specifying that the
+        target value has been reached
+
+        Returns
+        -------
+        bool: if True, PyMoDAQ considers the target value has been reached at epsilon
+
+        See Also
+        --------
+        user_condition_to_reach_target
+        """
+        try:
+            epsilon_calculated = (
+                    self._current_value - self._target_value).abs().value(self.axis_unit)
+        except DataUnitError as e:
+            epsilon_calculated = abs(self._current_value.value() - self._target_value.value())
+            logger.warning(f'Unit issue when calculating epsilon, units are not compatible between'
+                           f'target and current values')
+        except OffsetUnitCalculusError as e:
+            if '°C' in self.axis_unit or 'celcius' in self.axis_unit.lower():
+                epsilon_calculated = (
+                        self._current_value.to_base_units() -
+                        self._target_value.to_base_units()).abs().value()
+            else:
+                raise e
 
-        logger.debug(f"epsilon value is {self.settings['epsilon']}")
+        return (epsilon_calculated < self.epsilon) and self.user_condition_to_reach_target()
+
+    def user_condition_to_reach_target(self) -> bool:
+        """ Implement a user defined condition for exiting the polling mechanism and specifying
+        that the target value has been reached (on top of the existing epsilon mechanism)
+
+        Should be reimplemented in plugins to implement other conditions
+
+        Returns
+        -------
+        bool: if True, PyMoDAQ considers the target value has been reached
+        """
+        return True
+
+    def check_target_reached(self):
+        logger.debug(f"epsilon value is {self.epsilon}")
         logger.debug(f"current_value value is {self._current_value}")
         logger.debug(f"target_value value is {self._target_value}")
 
-        if not (self._current_value - self._target_value).abs() < self.settings['epsilon']:
+        if not self._condition_to_reach_target():
 
             logger.debug(f'Check move_is_done: {self.move_is_done}')
             if self.move_is_done:
                 self.emit_status(ThreadCommand('Move has been stopped', ))
                 logger.info('Move has been stopped')
             self.current_value = self.get_actuator_value()
-
             self.emit_value(self._current_value)
             logger.debug(f'Current value: {self._current_value}')
 
@@ -525,6 +780,7 @@ class DAQ_Move_base(QObject):
                 logger.info('Timeout activated')
         else:
             self.poll_timer.stop()
+            self.current_value = self.get_actuator_value()
             logger.debug(f'Current value: {self._current_value}')
             self.move_done(self._current_value)
 
@@ -605,6 +861,11 @@ class DAQ_Move_base(QObject):
             self.commit_common_settings(param)
             self.commit_settings(param)
 
+            if param.name() == 'axis':
+                self.axis_name = param.value()
+            elif param.name() == 'epsilon':
+                self.epsilon = param.value()
+
 
 class DAQ_Move_TCP_server(DAQ_Move_base, TCPServer):
     """
@@ -622,12 +883,12 @@ class DAQ_Move_TCP_server(DAQ_Move_base, TCPServer):
     """
     params_client = []  # parameters of a client grabber
     command_server = Signal(list)
-    data_actuator_type = DataActuatorType['DataActuator']
+    data_actuator_type = DataActuatorType.DataActuator
 
     message_list = ["Quit", "Status", "Done", "Server Closed", "Info", "Infos", "Info_xml", "move_abs",
                     'move_home', 'move_rel', 'get_actuator_value', 'stop_motion', 'position_is', 'move_done']
     socket_types = ["ACTUATOR"]
-    params = comon_parameters() + tcp_parameters
+    params = comon_parameters_fun() + tcp_parameters
 
     def __init__(self, parent=None, params_state=None):
         """
@@ -654,13 +915,13 @@ class DAQ_Move_TCP_server(DAQ_Move_base, TCPServer):
 
                 pos = self.get_position_with_scaling(pos)
                 self._current_value = pos
-                self.emit_status(ThreadCommand('get_actuator_value', [pos]))
+                self.emit_status(ThreadCommand('get_actuator_value', pos))
 
             elif command == 'move_done':
                 pos = DeSerializer(sock).dwa_deserialization()
                 pos = self.get_position_with_scaling(pos)
                 self._current_value = pos
-                self.emit_status(ThreadCommand('move_done', [pos]))
+                self.emit_status(ThreadCommand('move_done', pos))
             else:
                 self.send_command(sock, command)
 
@@ -699,6 +960,12 @@ class DAQ_Move_TCP_server(DAQ_Move_base, TCPServer):
         initialized = True
         return info, initialized
 
+    def read_infos(self, sock: Socket = None, infos=''):
+        """Reimplemented to get the units"""
+        super().read_infos(sock, infos)
+
+        self.axis_unit = self.settings['settings_client', 'units']
+
     def close(self):
         """
             Should be used to uninitialize hardware.