# -*- coding: utf-8 -*-
import time
import math

import os
try:
    from .guitastrotools import GuitastroTools, GuitastroException
except:
    from guitastrotools import GuitastroTools, GuitastroException

# #####################################################################
# #####################################################################
# #####################################################################
# Class Motoraxis
# #####################################################################
# #####################################################################
# #####################################################################

class Motoraxis(GuitastroTools):
    """
    Class to define an axis of a motor.

    The first element of args is a string to define the axis type amongst:

        * LIN: Linear. Value is a length (unit = m)
        * ROT: Rotation. Value is an angle (unit = deg)

    Dictionnary of motion parameters are:

        * NAME: A string to identify the axis in memory.
        * LABEL: A string to identify the axis for prints.

    :Example:

    ::

        >>> axis = Motoraxis("LIN", name = "Focuser", label= "Focus")

    The encoder provides a frame called 'enc'. The unit is increments.

    All motors are considered having a rotation.

    The 'rot' system shares the same axis than 'enc' and the unit is deg.

        rot = (inc-inc0) * rot_per_inc * senseinc

    rot_per_inc is always positive and senseinc = 1 or -1

    All motors are considered having a translation linked to to 'rot'.
    The 'lin' system depends on 'rot':

        lin = rot * m_per_rot_rev

    m_per_rot_rev is the meters traveled when rot has increased by 360 degrees.
    m_per_rot_rev is always positive or null. If the motor has no translation, m_per_rot_rev=0.

    The physical system 'phy' provides another frame defined by a function provided by the user:

        phy = function( rot, lin, **kwargs)

    A default function is.
    """

    # === Constants for error codes
    NO_ERROR = 0

    # === Constants for senses
    POSITIVE = 1;
    NEGATIVE = -1;

    # === constants for saving coords
    SAVE_NONE = 0
    SAVE_AS_SIMU = 1
    SAVE_AS_REAL = 2

    # === Indexes for real, simu,...
    REAL = 0
    SIMU = 1

    # === Axis motion state
    MOTION_STATE_UNKNOWN = -1
    MOTION_STATE_NOMOTION = 0
    MOTION_STATE_SLEWING = 1
    MOTION_STATE_DRIFTING = 2
    MOTION_STATE_MOVING = 3

    # === Identification of the axis
    _name = "Linear motor"
    _axis_type = "Lin"

    # === relations angle and inc
    # --- rotb0=0 when the tube is observing at the meridian
    _inc0 = 0 ; # value of the motor increment corresponding to _rot0
    _senseinc = POSITIVE ; # +1 or -1 according the increasing of inc / nat

    # === relations mechanics and inc
    _inc_per_ang = None

    # === last values
    _inc = 0
    _rot = 0
    _lin = 0
    _phy = 0
    _incsimu = 0
    _rotsimu = 0
    _linsimu = 0
    _physimu = 0

    # === simulation
    _inc_simu = 0
    _simu_signal_move = 0
    _simu_current_velocity_deg_per_sec = 0

    # === slew velicities
    _slewmax_deg_per_sec = 5
    _slew_deg_per_sec = 5

    # === motion state
    _motion_state      = MOTION_STATE_NOMOTION
    _motion_state_simu = MOTION_STATE_NOMOTION

    # === Pointing limits of celestial coordinate
    _lim_phy_inf = None
    _lim_phy_sup = None

    _m_per_motor_rev = 1
    _nat2phy = None
    _phy2nat = None

# =====================================================================
# =====================================================================
# Private methods
# =====================================================================
# =====================================================================

    def nat2phy(self, rot, lin, **kwargs):
        phy = rot
        return phy

    def phy2nat(self, phy, **kwargs):
        rot = phy
        lin = rot / self._m_per_motor_rev
        return rot, lin

    def _set_compute_phy(self, nat2phy, phy2nat=None):

        self._nat2phy = nat2phy
        if phy2nat != None:
            self._phy2nat = phy2nat

    def _get_compute_phy(self):
        return self._nat2phy, self._phy2nat

    def _set_inc_per_motor_rev(self, nbr_inc:float) -> int:
        """
        Set the number of increments for a single turn of the motor.

        :param nbr_inc: Number of increments for a single turn of the motor (for example : 1000).
        :type nbr_inc: float
        :returns: Error if ratio is not positive.
        :rtype: int
        """

        if nbr_inc<=0:
            raise Exception("ratio must be strictly positive")
        self._inc_per_motor_rev = nbr_inc
        self._incr_variables()
        return self.NO_ERROR

    def _get_inc_per_motor_rev(self) -> float:
        """
        Get the number of increments for a single turn of the motor.

        :returns: Number of increments for a single turn of the motor (for example : 1000).
        :rtype: float
        """

        return self._inc_per_motor_rev

    def _incr_variables(self) -> float:
        """
        Update and calculus of two parameters :
            - number of increments for a complete turn of an axis
            - number of increments for single decimal degrees.

        :returns: Number of increments for a complete turn of an axis and number of increments for single decimal degrees.
        :rtype: float
        """

        self._inc_per_deg = self._inc_per_motor_rev/360.

    def _set_inc0(self, inc0:float) -> int:
        """
        Set the value of increments for "rot=0". When mount was initialized, the "inc0" are set by the fonction "update_inc0".

        :param inc0: Value of the increments for "rot=0" (for example : 1800)
        :returns: Error if increment is not positive.
        :rtype: int
        """

        self._inc0 = inc0
        return self.NO_ERROR

    def _get_inc0(self) -> float:
        """
        Get the value of increments for "rot=0".

        :returns: Number of increments for "rot=0" (for example : 1800)
        :rtype: float
        """

        return self._inc0

    def _set_inc(self, inc:float) -> int:
        """
        Set the value for actual increments position of an axis, direct interogation of the controller.

        :param inc: Value of the increments for the actual position.
        :returns: Error if value is not a real.
        :rtype: int
        """

        self._inc = inc
        return self.NO_ERROR

    def _get_inc(self) -> float:
        """
        Get the value for actual increments position of an axis, direct interogation of the controller.

        :returns: Number of increments (for example : 37265)
        :rtype: float
        """

        return self._inc

    def _set_incsimu(self, inc:float) -> int:
        """
        Set the value for actual increments position of an axis in simulation mode.

        :param inc: Value of the increments for the simulated position.
        :returns: Error if value is not a real.
        :rtype: int
        """

        self._incsimu = inc
        return self.NO_ERROR

    def _get_incsimu(self) -> float:
        """
        Get the value for actual increments position of an axis, direct interogation of the controller. Value are real if axle is real.

        :returns: Number of increments in simulation mode (for example : 37265)
        :rtype: float
        """

        return self._incsimu

    def _set_senseinc(self, sense:int) -> int:
        """
        If progression of increments are positive and progression of rot0 are positive, senseinc are positive. However, senseinc are negative when progression are inverse.

        The sense depend of the physical rolling sense of motor cable system.

        :param sense: Value sense are "-1" or "1".
        :returns: Error if value is not a real.
        :rtype: int
        """

        if sense>self.NEGATIVE:
            self._senseinc = self.POSITIVE
        else:
            self._senseinc = self.NEGATIVE
        return self.NO_ERROR

    def _get_senseinc(self) -> int:
        """
        If progression of increments are positive and progression of 'rot0' are positive, 'senseinc' are positive. However, 'senseinc' are negative when progression are inverse.

        The sense depend of the physical rolling sense of motor cable system.

        :returns: Value sense are "-1" or "1".
        :rtype: int
        """

        return self._senseinc

    def _set_ang(self, ang:float) -> int:
        """
        Set the arrival angle of a calculated movement for a target.

        The orientation of the coordinate system are orthonormal. (Right hand rules, tom pouce for visible polar axis !)

        :param ang: Celestial angle of an axis (degrees)
        :returns: Error if value is not a real.
        :rtype: int
        """

        self._ang = ang
        return self.NO_ERROR

    def _get_ang(self) -> int:
        """
        Get the arrival angle of a calculated movement for a target.

        The orientation of the coordinate system are orthonormal. (Right hand rules, tom pouce for visible polar axis !)

        :returns: Error if value is not a real.
        :rtype: int
        """

        return self._ang

    def _set_physimu(self, ang:float) -> int:
        """
        In simulation mode, set the arrival angle of a calculated movement for a target.

        The orientation of the coordinate system are orthonormal. (Right hand rules, tom pouce for visible polar axis !)

        :param ang: Celestial angle of an axis (degrees)
        :returns: Error if value is not a real.
        :rtype: int
        """

        self._physimu = ang
        return self.NO_ERROR

    def _get_physimu(self) -> int:
        """
        In simulation mode, get the arrival angle of a calculated movement for a target.

        The orientation of the coordinate system are orthonormal. (Right hand rules, tom pouce for visible polar axis !)

        :returns: Error if value is not a real.
        :rtype: int
        """

        return self._physimu

    def _set_real(self, real:bool) -> int:
        """
        Set the axis in real mode or simulation mode. With simulation mode, the value of the axis are given by Motoraxis simulation value.

        :param real: True or False.
        :returns: Error if value is not a real.
        :rtype: int
        """

        self._real = real
        return self.NO_ERROR

    def _set_lim_phy_inf(self, lim_cel_inf:float) -> float:
        """
        Pointing limit lowest value (deg).

        :param lim_cel_inf: Value (deg).
        :returns: lim_cel_inf.
        :rtype: float
        """
        self._lim_phy_inf = lim_cel_inf
        return self._lim_phy_inf

    def _get_lim_phy_inf(self) -> float:
        """
        Pointing limit lowest value (deg).

        :returns: lim_cel_inf.
        :rtype: float
        """
        return self._lim_phy_inf

    def _set_lim_phy_sup(self, lim_cel_sup:float) -> float:
        """
        Pointing limit highest value (deg).

        :param lim_cel_sup: Value (deg).
        :returns: lim_cel_sup.
        :rtype: float
        """
        self._lim_phy_sup = lim_cel_sup
        return self._lim_phy_sup

    def _get_lim_phy_sup(self) -> float:
        """
        Pointing limit highest value (deg).

        :param lim_cel_sup: Value (deg).
        :returns: lim_cel_sup.
        :rtype: float
        """
        return self._lim_phy_sup

    def _get_real(self) -> bool:
        """
        Get the axis mode, real or simulation.

        :returns: True or False
        :rtype: bool
        """

        return self._real

    def _set_axis_type(self, axis_type:str) -> int:
        """
        Set type and mechanical position of an axis on the mount.
            - BASE : Azimut or hour angle axis,
            - POLAR : Elevation or declination axix,
            - ROT : Derotator system for non equatorial mount (if equiped),
            - YAW : Equivalent to secondary azymtuh base (for Alt-Alt mount).

        :param axis_type : BASE = 0, POLAR = 1, ROT = 2, YAW = 3
        :returns: Error if value is not a real.
        :rtype: int
        """

        self._axis_type = axis_type
        return self.NO_ERROR

    def _get_axis_type(self) -> int:
        """
        Get type and mechanical position of an axis on the mount.
            - BASE : Azimut or hour angle axis,
            - POLAR : Elevation or declination axix,
            - ROT : Derotator system for non equatorial mount (if equiped),
            - YAW : Equivalent to secondary azymtuh base (for Alt-Alt mount).

        :returns: BASE = 0, POLAR = 1, ROT = 2, YAW = 3
        :rtype: int
        """

        return self._axis_type

    def _set_inc_per_deg(self, inc_per_deg:float):
        """
        .. attention::

            no setting for this attribute

        :param inc_per_deg: Incrment per degree
        :type inc_per_deg: float
        :returns: Error if ratio is not positive.
        :rtype: int
        """

        return self.NO_ERROR

    def _get_inc_per_deg(self) -> float:
        """
        Get the number of increments for a single degrees on the sky.

        :returns: Number of increments (for example : env 970000)
        :rtype: float
        """

        return self._inc_per_deg

    def _get_name(self) -> str:
        """
        Get the nickname of the axis.

        :returns: Nickname of the axis (for example : Declination, ...)
        :rtype: str
        """

        return self._name

    def _set_name(self, name:str):
        # no setting for this attribute
        """
        .. attention::

            no setting for this attribute

        The name are setted at the instanciation of the mount axis. The name of an axis can have several value :
            - Declination,
            - Azimuth
            - Hour angle,
            - Elevation,
            - Rotator,
            - Roll,
            - Pitch,
            - Yaw,

        You cannot set the value cause it is an protected attribute.

        :param name: Name of the axis
        :type name: str
        :returns: Error if ratio is not positive.
        :rtype: int
        """

        return self.NO_ERROR

    def _get_simu_current_velocity(self) -> int:
        """
        Get the final cruising speed during the motion. Motion are celestial slewing speed or any other, like goto for example.

        :returns: Terminal velocity speed for a movement in degrees / sec.
        :rtype: int
        """

        return self._simu_current_velocity_deg_per_sec

    def _set_simu_current_velocity(self, simu_current_velocity_deg_per_sec:float):
        # no setting for this attribute
        """
        .. attention::

            no setting for this attribute

        :returns: Error if ratio is not positive.
        :rtype: int
        """

        return self.NO_ERROR

    def _get_slew_deg_per_sec(self) -> int:
        """
        Get the setting speed of a goto motion.

        :returns: Speed for a goto movement in degrees / sec.
        :rtype: int
        """

        return self._slew_deg_per_sec

    def _set_slew_deg_per_sec(self, deg_per_sec:float) ->int:
        """
        Set the setting speed for a goto motion.

        The value are limited by the maximun limited speed (_slewmax_deg_per_sec)

        :param deg_per_sec: Speed for a goto movement in degrees / sec (for example : 30).
        :type deg_per_sec: float
        :returns: Error if value is not a real.
        :rtype: int
        """

        self._slew_deg_per_sec = abs(deg_per_sec)
        if self._slew_deg_per_sec > self._slewmax_deg_per_sec:
            self._slew_deg_per_sec = self._slewmax_deg_per_sec
        return self.NO_ERROR

    def _get_slewmax_deg_per_sec(self) -> float:
        """
        Get the maximum speed for slew motion.

        The value have a maximum, setting by a limit (_slewmax_deg_per_sec).

        :returns: Maximum speed for a goto movement in degrees / sec.
        :rtype: float
        """

        return self._slew_deg_per_sec

    def _set_slewmax_deg_per_sec(self, deg_per_sec:float) -> int:
        """
        Set the maximum speed for slew motion. Set carrefully this parameter due to issue response of the mount.

        The value have a maximum (for example : 30)

        :param deg_per_sec: Speed for a slewing movement in degrees / sec (for example : 30)
        :type deg_per_sec: float
        :returns: Error if value is not a real.
        :rtype: int
        """

        self._slewmax_deg_per_sec = abs(deg_per_sec)
        if self._slew_deg_per_sec > self._slewmax_deg_per_sec:
            self._slew_deg_per_sec = self._slewmax_deg_per_sec
        return self.NO_ERROR

    def _get_language_protocol(self) -> str:
        """
        Get the type of controller language protocol for an axis (for example : SCX 11 type, or another).

        :returns: Type of controller language.
        :rtype: str
        """

        return self._language_protocol

    def _set_language_protocol(self, language_protocol:str) -> int:
        """
        Set the type of controller language protocol for an axis (for example : SCX 11 type, or another).

        :param language_protocol : Specified the protocol language type (for example : SCX11)
        :returns: Error if value is not a real.
        :rtype: int
        """

        self._language_protocol = language_protocol
        return self.NO_ERROR

    _motion_state      = MOTION_STATE_NOMOTION
    _motion_state_simu = MOTION_STATE_NOMOTION

    def _get_motion_state(self) -> int:
        """
        Get the current motion state

        :returns: Moton state code (0=no motion, 1=slewing, 2=drifting, 3=moving).
        :rtype: int

        Slewiwng state is an absolute motion followed by a drift.
        Moving state is an infinite motion. If a Moving is stopped we retreive the Drift state.
        """

        return self._motion_state

    def _set_motion_state(self, motion_state:int):
        """
        Set the current motion state

        :returns: Error code (0=no error).
        :rtype: int
        """

        self._motion_state = motion_state
        return self.NO_ERROR

    def _get_motion_state_simu(self) -> int:
        """
        Get the current motion state for simulation

        :returns: Moton state code (0=no motion, 1=slewing, 2=drifting, 3=moving).
        :rtype: int

        Slewiwng state is an absolute motion followed by a drift.
        Moving state is an infinite motion. If a Moving is stopped we retreive the Drift state.
        """

        return self._motion_state_simu

    def _set_motion_state_simu(self, motion_state:int):
        """
        Set the current motion state for simulation

        :returns: Error code (0=no error).
        :rtype: int
        """

        self._motion_state_simu = motion_state
        return self.NO_ERROR

# =====================================================================
# =====================================================================
# Methods for users
# =====================================================================
# =====================================================================

    name              = property(_get_name              , _set_name)
    axis_type         = property(_get_axis_type         , _set_axis_type)
    language_protocol = property(_get_language_protocol , _set_language_protocol)

    inc_per_motor_rev = property(_get_inc_per_motor_rev , _set_inc_per_motor_rev)

    inc_per_deg       = property(_get_inc_per_deg       , _set_inc_per_deg)

    inc0              = property(_get_inc0              , _set_inc0)
    senseinc          = property(_get_senseinc          , _set_senseinc)

    real              = property(_get_real              , _set_real)
    inc               = property(_get_inc               , _set_inc)
    ang               = property(_get_ang               , _set_ang)

    incsimu           = property(_get_incsimu           , _set_incsimu)
    angsimu           = property(_get_physimu           , _set_physimu)

    compute_phy       = property(_get_compute_phy       , _set_compute_phy)

    slew_deg_per_sec    = property(_get_slew_deg_per_sec     , _set_slew_deg_per_sec)
    slewmax_deg_per_sec = property(_get_slewmax_deg_per_sec  , _set_slewmax_deg_per_sec)

    simu_current_velocity  = property(_get_simu_current_velocity, _set_simu_current_velocity)

    motion_state_simu  = property(_get_motion_state_simu, _set_motion_state_simu)
    motion_state  = property(_get_motion_state, _set_motion_state)

    lim_cel_inf = property(_get_lim_phy_inf, _set_lim_phy_inf)
    lim_cel_sup = property(_get_lim_phy_sup, _set_lim_phy_sup)

    def disp(self):
        """
        Get information about an axis and print it on the console. Usefull for debug.
        Instanciation of the axis are indispensable. However, the Motoraxis module when running, have by default axisb et axisp instancied.

        :Instanciation Usage:

        ::

            >>> axisb = Motoraxis("HA", name = "Unknown")
            >>> axisp = Motoraxis("DEC", name = "Unknown")

        :Usage:

        ::

            >>> axisb.disp()
            >>> axisp.disp()

        :Return table of an axis:

        ::

            --------------------
            AXIS name         = SCX11
            axis_type         = HA
            latitude          = 43
            real hardware     = False
            --------------------
            RATIO_WHEEL_PULLEY = 5.25
            RATIO_PULLEY_MOTOR = 100.0
            inc_per_motor_rev = 1000.0
            --------------------
            inc_per_sky_rev   = 525000.0
            inc_per_deg       = 1458.3333333333333
            --------------------
            senseinc          = 1            : 1=positive
            inc0              =          0.0 : Place mount rot at meridian and set inc0 = inc
            senseang          = 1            : 1=positive
            --------------------
            slew_deg_per_sec  = 5.0
            -------------------- SIMU INC -> ANG = HA
            inc               =          0.0 : inc is read from encoder
            rot               =    0.0000000 : rot = (inc - inc0) * senseinc / inc_per_deg
            pierside          = 1            : pierside must be given by polar axis
            ang               =    0.0000000 : ang = senseang * rot
            -------------------- SIMU ANG = HA -> INC
            ang               =    0.0000000 : Next target celestial angle HA
            pierside          = 1            : Next target pier side (+1 or -1)
            rot               =    0.0000000 : rot = -ang / senseang
            inc               =          0.0 : inc = inc0 + rot * inc_per_deg / senseinc
            -------------------- REAL INC -> ANG = HA
            inc               =          0.0 : inc is read from encoder
            rot               =    0.0000000 : rot = (inc - inc0) * senseinc / inc_per_deg
            pierside          = 1            : pierside must be given by polar axis
            ang               =    0.0000000 : ang = senseang * rot
            -------------------- REAL ANG = HA -> INC
            ang               =    0.0000000 : Next target celestial angle HA
            pierside          = 1            : Next target pier side (+1 or -1)
            rot               =    0.0000000 : rot = -ang / senseang
            inc               =          0.0 : inc = inc0 + rot * inc_per_deg / senseinc

        """
        self.log.print("{}".format(20*"-"))
        self.log.print("AXIS name         = {} ".format(self.name))
        self.log.print("axis_type         = {} ".format(self.axis_type))
        self.log.print("real hardware     = {} ".format(self.real))
        self.log.print("{}".format(20*"-"))
        self.log.print("inc_per_motor_rev = {} ".format(self.inc_per_motor_rev))
        self.log.print("{}".format(20*"-"))
        self.log.print("inc_per_deg       = {} ".format(self.inc_per_deg))
        self.log.print("{}".format(20*"-"))
        self.log.print("senseinc          = {:d}            : 1=positive".format(self.senseinc))
        self.log.print("inc0              = {:12.1f} : Place motor rot at a reference and set inc0 = inc".format(self.inc0))
        self.log.print("{}".format(20*"-"))
        self.log.print("slew_deg_per_sec  = {} ".format(self.slew_deg_per_sec))
        for disp_real in (False,True):
            if disp_real==True:
                inc = self._inc
                rot = self._rot
                lin = self._lin
                phy = self._phy
                msg_simu = "REAL"
            else:
                inc = self._incsimu
                rot = self._rotsimu
                lin = self._linsimu
                phy = self._physimu
                msg_simu = "SIMU"
            self.log.print("{} {} INC -> ANG = {}".format(20*"-",msg_simu,self.axis_type))
            self.log.print("inc               = {:12.1f} : inc is read from encoder ".format(inc))
            self.log.print("rot               = {:12.7f} : rot = (inc - inc0) * senseinc / inc_per_deg".format(rot))
            self.log.print("lin               = {:12.7f} : m ".format(lin))
            self.log.print("phy               = {:12.7f} : physical units ".format(phy))

    def synchro_real2simu(self):
        """
        Synchronisation between simulation value of axis to real values of the axis. Parameters are setted :
            - _incsimu,
            - _rotsimu,
            - _physimu,
            - _piersidesimu,

        Useful for ending slewing movement to prevent difference offset due to calculation time of the simulation mode.

        Instanciation of the axis are indispensable. However, the Motoraxis module when running, have by default axisb et axisp instancied.

        :Instanciation Usage:

        ::

            >>> axisb = Motoraxis("HA", name = "Unknown")
            >>> axisp = Motoraxis("DEC", name = "Unknown")

        :Usage:

        ::

            >>> axisb.synchro_real2simu()
            >>> axisp.synchro_real2simu()

        :returns: No message returned by the fonction
        """


        inc = self._inc
        rot, pierside = self.inc2rot(inc)
        ang = self.rot2ang(rot, pierside)
        self._incsimu = inc
        self._rotsimu = rot
        self._physimu = ang
        self._piersidesimu = pierside

    def synchro_simu2real(self):
        """
        Synchronisation between real value of axis to simulation values of the axis. Parameters are setted :
            - _inc,
            - _rot,
            - _ang,
            - _pierside,

        Useful for ending slewing movement to prevent difference offset due to calculation time of the simulation mode.

        Instanciation of the axis are indispensable. However, the Motoraxis module when running, have by default axisb et axisp instancied.

        :Instanciation Usage:

        ::

            >>> axisb = Motoraxis("HA", name = "Unknown")
            >>> axisp = Motoraxis("DEC", name = "Unknown")

        :Usage:

        ::

            >>> axisb.sydispnchro_simu2real()
            >>> axisp.synchro_simu2real()

        :returns: No message returned by the fonction
        """

        inc = self._incsimu
        rot, pierside = self.inc2rot(inc)
        ang = self.rot2ang(rot, pierside)
        self._inc = inc
        self._rot = rot
        self._ang = ang
        self._pierside = pierside

    def update_inc0(self, inc, ang, pierside):
        """
        Update the value of the inc0.

        Instanciation of the axis are indispensable. However, the Motoraxis module when running, have by default axisb et axisp instancied.

        :Instanciation Usage:

        ::

            >>> axisb = Motoraxis("HA", name = "Unknown")
            >>> axisp = Motoraxis("DEC", name = "Unknown")

        :Usage:

        ::

            >>> axisb.update_inc0()
            >>> axisp.update_inc0()

        :param inc:
        :param ang:
        :param pierside:
        :returns: No message returned by the fonction.
        """


        if self._axis_type=="DEC" or self._axis_type=="ELEV":
            if ang > 90:
                ang = 90
            if ang < -90:
                ang = -90
            if self._latitude<0:
                rot = (90 + ang) * pierside
            else:
                rot = (90 - ang) * pierside
            # inc = inc0 + rot * inc_per_deg / senseinc
            inc0 = inc - rot * self.inc_per_deg / self.senseinc
        else:
            rot = ang / self.senseang
            if self._latitude>0:
                rot *= -1
            rot = math.fmod(rot+1440,360)
            if (rot>180):
                rot -= 360
            if pierside==self.PIERSIDE_POS1:
                # inc = inc0 + rot * inc_per_deg / senseinc
                inc0 = inc - rot * self.inc_per_deg / self.senseinc
            else:
                # inc = inc0 + (rot-180) * inc_per_deg / senseinc
                inc0 = inc - (rot-180) * self.inc_per_deg / self.senseinc
        self.inc0 = inc0
        return inc0

    def inc2rot(self, inc:float, save=SAVE_NONE) -> tuple:
        """
        Calculation of rot and pierside from inc.

        :param inc: Encoder increments (inc)
        :type inc: float
        :param save: Define how the results are stored:

            * SAVE_NONE (=0)
            * SAVE_AS_SIMU (=1)
            * SAVE_AS_REAL (=2)
        :type save: int
        :returns: Tuple of (rot, pierside)
        :rtype: tuple

        The rot value is computed according inc, _inc0, _senseinc, _inc_per_deg and _axis_type.
        The save parameter allows to update the real or simu internal values of inc and rot:

            * SAVE_AS_SIMU: Only _incsimu, _rotsimu and _piersidesimu for simulated values are updated.
            * SAVE_AS_REAL: Only _inc, _rot and _pierside for real values are updated.
            * SAVE_NONE: No internal variables are updates.

        Instanciation of the axis is indispensable.

        :Instanciation Usage:

        ::

            >>> axisb = Motoraxis("HA", name = "Unknown")

        :Usage:

        ::

            >>> axisb.inc2rot(2000,axisb.SAVE_NONE)

        """
        rot = (inc - self._inc0) * self._senseinc / self._inc_per_deg
        # --- identify the pierside of the current pointing for polar axis
        if self._axis_type=="DEC" or self._axis_type=="ELEV":
            if rot >= 0:
                pierside =  self.PIERSIDE_POS1
            else:
                pierside =  self.PIERSIDE_POS2
        else:
            pierside = self.PIERSIDE_POS1
        # --- update attributes
        if save == self.SAVE_AS_SIMU:
            self._rotsimu = rot
            self._incsimu = inc
            self._piersidesimu = pierside
        elif save == self.SAVE_AS_REAL:
            self._rot = rot
            self._inc = inc
            self._pierside = pierside
        return rot, pierside

    def rot2ang(self, rot:float, pierside:int, save:int=SAVE_NONE) -> float:
        """
        Calculation of ang from rot and pierside.

        :param rot: Rotation angle (degrees)
        :type rot: float
        :param pierside: Location of the optical tube against the mount pier:

            * PIERSIDE_POS1 (=1) normal position
            * PIERSIDE_POS2 (=-1) back flip position
        :type pierside: int
        :param save: Define how the results are stored:

            * SAVE_NONE (=0)
            * SAVE_AS_SIMU (=1)
            * SAVE_AS_REAL (=2)
        :type save: int
        :returns: ang
        :rtype: float

        The ang value is computed according rot, _latitude, _sensephy and _axis_type.
        The save parameter allows to update the real or simu internal values of and, pierside and rot:

            * SAVE_AS_SIMU: Only _physimu, _rotsimu and _piersidesimu for simulated values are updated.
            * SAVE_AS_REAL: Only _ang, _rot and _pierside for real values are updated.
            * SAVE_NONE: No internal variables are updates.

        Instanciation of the axis is indispensable.

        :Instanciation Usage:

        ::

            >>> axisb = Motoraxis("HA", name = "Unknown")

        :Usage:

        ::

            >>> axisb.rot2ang(10, axisb.PIERSIDE_POS1, axisb.SAVE_NONE)

        """
        # compute apparent ang
        ang = 0
        if self._axis_type=="DEC" or self._axis_type=="ELEV":
            if self._latitude<0:
                # --- southern hemisphere
                ang = -90 + abs(rot)
            else:
                # --- nothern hemisphere
                ang = 90 - abs(rot)
            # --- following lines must be verified
            if ang<-90:
                ang +=360;
            if ang>90:
                ang -=360;
            # identify the pierside of the current pointing
        if self._axis_type=="HA" or self._axis_type=="ROLL":
            if self._latitude<0:
                ang = self._sensephy * rot
            else:
                ang = self._sensephy * -rot
            if pierside == self.PIERSIDE_POS2:
                ang += 180
            ang = math.fmod(ang+720,360)
            if (ang>180):
                ang -= 360
        if self._axis_type=="AZ":
            if self._latitude<0:
                ang = self._sensephy * rot
            else:
                ang = self._sensephy * -rot
            if pierside == self.PIERSIDE_POS2:
                ang += 180
            ang = math.fmod(ang+720,360)
        if save == self.SAVE_AS_SIMU:
            self._physimu = ang
            self._piersidesimu = pierside
            self._rotsimu = rot
        elif save == self.SAVE_AS_REAL:
            self._ang = ang
            self._pierside = pierside
            self._rot = rot
        return ang

    def ang2rot(self, ang:float, pierside:int, save:int=SAVE_NONE) -> float:
        """
        Calculation rot from ang and pierside.

        :param ang: Celestial angle (degrees)
        :type ang: float
        :param pierside: Location of the optical tube against the mount pier:

            * PIERSIDE_POS1 (=1) normal position
            * PIERSIDE_POS2 (=-1) back flip position
        :type pierside: int
        :param save: Define how the results are stored:

            * SAVE_NONE (=0)
            * SAVE_AS_SIMU (=1)
            * SAVE_AS_REAL (=2)
        :type save: int
        :returns: rot
        :rtype: float

        The rot value is computed according rot, _latitude, _sensephy and _axis_type.
        The save parameter allows to update the real or simu internal values of and, pierside and rot:

            * SAVE_AS_SIMU: Only _physimu, _rotsimu and _piersidesimu for simulated values are updated.
            * SAVE_AS_REAL: Only _ang, _rot and _pierside for real values are updated.
            * SAVE_NONE: No internal variables are updates.

        Instanciation of the axis is indispensable.

        :Instanciation Usage:

        ::

            >>> axisb = Motoraxis("HA", name = "Unknown")

        :Usage:

        ::

            >>> axisb.ang2rot(-10, axisb.PIERSIDE_POS1, axisb.SAVE_NONE)

        """
        # compute apparent rot
        rot = 0
        if self._axis_type=="DEC" or self._axis_type=="ELEV":
            if self._latitude<0:
                # --- southern hemisphere
                rot = (90 + ang) * pierside
            else:
                # --- nothern hemisphere
                rot = (90 - ang) * pierside
        if self._axis_type=="HA" or self._axis_type=="AZ":
            if pierside==self.PIERSIDE_POS2:
                ang -= 180
            if self._latitude<0:
                rot = ang
            else:
                rot = -ang
            if (rot>180):
                rot -= 360
            if (rot<-180):
                rot += 360
        rot /= self._sensephy
        if save == self.SAVE_AS_SIMU:
            self._physimu = ang
            self._piersidesimu = pierside
            self._rotsimu = rot
        elif save == self.SAVE_AS_REAL:
            self._ang = ang
            self._pierside = pierside
            self._rot = rot
        return rot

    def rot2inc(self, rot:float, save:int=SAVE_NONE) -> float :
        """
        Calculation of inc from rot.

        :param rot: Rotation angle (degrees)
        :type rot: float
        :param save: Define how the results are stored:

            * SAVE_NONE (=0)
            * SAVE_AS_SIMU (=1)
            * SAVE_AS_REAL (=2)
        :type save: int
        :returns: inc
        :rtype: float

        The inc value is computed according rot, _inc0, _senseinc, _inc_per_deg.
        The inc values are calculated in the interval from -inc_per_sky_rev/2 to +inc_per_sky_rev/2.
        The save parameter allows to update the real or simu internal values of inc and rot:

            * SAVE_AS_SIMU: Only _incsimu, _rotsimu for simulated values are updated.
            * SAVE_AS_REAL: Only _inc, _rot for real values are updated.
            * SAVE_NONE: No internal variables are updates.

        Instanciation of the axis is indispensable.

        :Instanciation Usage:

        ::

            >>> axisb = Motoraxis("HA", name = "Unknown")

        :Usage:

        ::

            >>> axisb.rot2inc(10,axisb.SAVE_NONE)

        """
        inc = self._inc0 + rot * self._inc_per_deg / self._senseinc
        # --- verify the limits
        inc_per_sky_rev = self._inc_per_sky_rev
        limn = -inc_per_sky_rev/2
        limp =  inc_per_sky_rev/2
        if inc>limp:
            inc -= inc_per_sky_rev
        if inc<limn:
            inc += inc_per_sky_rev
        # ---
        if save == self.SAVE_AS_SIMU:
            self._rotsimu = rot
            self._incsimu = inc
        elif save == self.SAVE_AS_REAL:
            self._rot = rot
            self._inc = inc
        return inc

# =====================================================================
# =====================================================================
# Motion methods for simulation
# =====================================================================
# =====================================================================

    def simu_motion_start(self, *args, **kwargs):
        """
        Start a simulation motion.

        :param args: First args is a string to define the type of motion to do.
        :type args: args
        :param kwargs: Dictionnary of motion parameters:
        :type kwargs: kwargs
        :returns: _incsimu
        :rtype: float

        Types of motion can be:

            * SLEW or ABSOLUTE: Absolute position of the target position.
            * MOVE or CONTINUOUS: Infinite motion.

        Dictionnary of motion parameters are:

            * Case motion type = SLEW or ABSOLUTE:

                * POSITION (inc or ang according the FRAME).
                * VELOCITY (deg/sec). Can be negative.
                * DRIFT (deg/sec). Can be negative.

            * Case motion type = MOVE or CONTINUOUS:

                * VELOCITY (deg/sec). Can be negative.
                * DRIFT (deg/sec). Can be negative.

            * For all cases of motions:

                * FRAME (str). "inc" (by default) or "ang"

        Instanciation of the axis is mandatory.

        :Instanciation Usage:

        ::

            >>> axisb = Motoraxis("HA", name = "Unknown")

        :Usage:

        ::

            >>> axisb.simu_motion_start("SLEW", position=1000, velocity=100, frame='inc', drift=0)

        """
        # ========= Definition of motion_types
        # --- Dico of motion types and their parameters
        motion_types = {}
        motion_types["SLEW"] = {"MANDATORY" : {"POSITION":[float,0.0], "VELOCITY":[float,1.0]}, "OPTIONAL" : {"DRIFT":[float,0.0]} }
        motion_types["MOVE"] = {"MANDATORY" : {"VELOCITY":[float,1.0]}, "OPTIONAL" : {"DRIFT":[float,0.0]} }
        motion_types["DRIFT"] = {"MANDATORY" : {"DRIFT":[float,0.0]}, "OPTIONAL" : {} }
        # --- deprecadec
        motion_types["ABSOLUTE"] = {"MANDATORY" : {"POSITION":[float,0.0], "VELOCITY":[float,1.0]}, "OPTIONAL" : {"DRIFT":[float,0.0]} }
        motion_types["CONTINUOUS"] = {"MANDATORY" : {"VELOCITY":[float,1.0]}, "OPTIONAL" : {"DRIFT":[float,0.0]} }
        # --- Dico of optional parameters for all motion types
        param_optionals = {"FRAME":(str,'inc')} ; # inc or ang
        # ========= Decode params
        self._simu_params = self.decode_args_kwargs(0,motion_types, param_optionals, *args, **kwargs)
        # ========= Decode params
        self._simu_motion_type = self._simu_params["SELECTED_ARG"]
        # ========= Update motion_state_simu
        self.motion_state_simu  = self.MOTION_STATE_UNKNOWN
        if self._simu_motion_type=="SLEW" or self._simu_motion_type=="ABSOLUTE":
            self.motion_state_simu = self.MOTION_STATE_SLEWING
            #self.log.print("SLEW drift={} ".format(self._simu_params['DRIFT']))
        elif self._simu_motion_type=="MOVE" or self._simu_motion_type=="CONTINUOUS":
            self.motion_state_simu = self.MOTION_STATE_MOVING
            #self.log.print("MOVE drift={} ".format(self._simu_params['DRIFT']))
        elif self._simu_motion_type=="DRIFT":
            self.motion_state_simu = self.MOTION_STATE_DRIFTING
        # --- Update t0, inct0
        self._simu_motion_t0 = time.time()
        self._simu_motion_inct0 = self._incsimu
        # --- Update start_t0, start_inct0
        self._simu_motion_start_t0 = self._simu_motion_t0
        self._simu_motion_start_inct0 = self._simu_motion_inct0
        # --- Fille history motion
        history = [time.time(), 0.0, "MOTION_START", self._simu_motion_type, self._simu_params]
        self._history.append(history)
        # --- get the current inc
        inc = self.simu_update_inc()
        return inc

    def simu_motion_stop(self):
        """
        Stop a simulation motion.
        """
        # --- get the current inc
        inc = self.simu_update_inc()
        # --- we stop
        self.motion_state_simu  = self.MOTION_STATE_NOMOTION
        t = time.time()
        dt = t-self._simu_motion_start_t0;
        history = [t, dt, "MOTION_STOP", self.motion_state_simu , inc]
        self._history.append(history)
        # --- obsolete attributes
        self._simu_signal_move = 0
        self._simu_signal_drift = 0
        return inc

    def simu_motion_stop_move(self):
        """
        Stop a moving motion.
        """
        if self.motion_state_simu == self.MOTION_STATE_MOVING:
            # --- get the current inc
            inc = self.simu_update_inc()
            # --- We switch to drift
            self.motion_state_simu = self.MOTION_STATE_DRIFTING
        # --- get the current inc
        inc = self.simu_update_inc()
        return inc

    def simu_update_inc(self):
        """
        Calculate the current position of a simulation motion.

        A simple rectangular profile is applied to velocity.
        """
        if self.motion_state_simu == self.MOTION_STATE_NOMOTION:
            return self._incsimu
        # --- compute the duration from t0
        t = time.time()
        t0 = self._simu_motion_t0
        inc = self._incsimu
        inct0 = self._simu_motion_inct0
        # --- get motion parameters
        vel = 0
        if "VELOCITY" in self._simu_params:
            # --- velocity unit deg/sec
            vel = float(self._simu_params["VELOCITY"])
        drift = 0
        if "DRIFT" in self._simu_params:
            # --- drift unit deg/sec
            drift = float(self._simu_params["DRIFT"])
        frame = 'ang'
        if "FRAME" in self._simu_params:
            frame = self._simu_params["FRAME"]
        if frame == "ang":
            # --- conversions deg/sec to inc/sec
            vel *= self.inc_per_deg
            drift *= self.inc_per_deg
        # --- moving case
        if self.motion_state_simu == self.MOTION_STATE_MOVING:
            # --- So we can compute the inc since t0
            inc = inct0 + vel*(t-t0)
        # --- slewing case
        if self.motion_state_simu == self.MOTION_STATE_SLEWING:
            # --- compute the pos to reach
            inc_end_slew = float(self._simu_params["POSITION"])
            if frame == "ang":
                # --- conversions deg to inc
                inc_end_slew *= self.inc_per_deg
            # --- process the sign of vel
            #if self._axis_type=="HA":
            #    self.log.print("inct0={} inc_end_slew={:.1f} vel={}".format(inct0,inc_end_slew,vel))
            if inct0 < inc_end_slew:
                vel = abs(vel)
            else:
                vel = -abs(vel)
            # --- compute the expected t to reach inc_end_slew
            t1 = (inc_end_slew-inct0) / vel + t0
            # self.log.print("vel={} t={} t1={}".format(vel,t,t1))
            if t < t1:
                # --- We did not overtake the target. We continue to slew
                # --- So we can compute the inc since t0
                inc = inct0 + vel*(t-t0)
                #if self._axis_type=="HA":
                #    self.log.print("t<t1 {:.0f} = {:.0f} + {:.1f} * {}".format(inc, inct0, vel, (t-t0)))
                t0 = t
            else:
                # --- We overtook the target. We switch to drift at time t1
                # --- So we can compute the inc since t0
                self.motion_state_simu = self.MOTION_STATE_DRIFTING
                t0 = t1
                inct0 = inc_end_slew
                inc = inct0
                #if self._axis_type=="HA":
                #    self.log.print("t>=t1 {:.0f}".format(inc))
        # --- drifting case
        if self.motion_state_simu == self.MOTION_STATE_DRIFTING:
            #if self._axis_type=="HA":
            #    self.log.print("drift drift={} inc/sec".format(drift))
            if drift == 0:
                self.motion_state_simu = self.MOTION_STATE_NOMOTION
            else:
                # --- compute the current inc
                inc = inct0 + drift*(t-t0)
                #if self._axis_type=="HA":
                #    self.log.print("t<t1 {:.0f} = {:.0f} + {:.1f} * {}".format(inc, inct0, drift, (t-t0)))
                t0 = t
                # --- We must test if we overtake the inc limits
        # --- update the inc0 and t0 values
        self._incsimu = inc
        self._simu_motion_t0 = t0
        self._simu_motion_inct0 = inc
        # --- deprecated attributes
        if self.motion_state_simu == self.MOTION_STATE_NOMOTION:
            self._simu_signal_move = 0
        else:
            self._simu_signal_move = 1
        if self.motion_state_simu == self.MOTION_STATE_DRIFTING:
            self._simu_signal_drift = 1
        else:
            self._simu_signal_drift = 0
        # --- update the motion history
        dt = t-self._simu_motion_start_t0;
        history = [t, dt, "MOTION_UPDATE", self.motion_state_simu , inc]
        self._history.append(history)
        return inc

# =====================================================================
# =====================================================================
# Special methods
# =====================================================================
# =====================================================================

    def __init__(self, *args, **kwargs):

        # --- Dico of optional parameters for all axis_types
        param_optionals = {}
        param_optionals["RATIO_WHEEL_PULLEY"] = (float, 5.250)
        param_optionals["RATIO_PULLEY_MOTOR"] = (float, 100.0)
        param_optionals["INC_PER_MOTOR_REV"] = (float, 1000.0)
        param_optionals["INC0"] = (float, 0.0)
        param_optionals["SENSEINC"] = (float, Motoraxis.POSITIVE)
        param_optionals["SENSEANG"] = (float, Motoraxis.POSITIVE)
        param_optionals["REAL"] = (bool, False)
        param_optionals["DESCRIPTION"] = (str, "No description.")
        param_optionals["LANGUAGE_PROTOCOL"] = (str, "")
        # --- Dico of axis_types and their parameters
        axis_types = {}
        # --- equatorial
        axis_types["HA"]   = {"MANDATORY" : {"NAME":[str,"Unknown"]}, "OPTIONAL" : {"LABEL":[str,"Hour Angle"]} }
        axis_types["DEC"]  = {"MANDATORY" : {"NAME":[str,"Unknown"]}, "OPTIONAL" : {"LABEL":[str,"Declination"]} }
        # --- altaz
        axis_types["AZ"]   = {"MANDATORY" : {"NAME":[str,"Unknown"]}, "OPTIONAL" : {"LABEL":[str,"Azimuth"]} }
        axis_types["ELEV"] = {"MANDATORY" : {"NAME":[str,"Unknown"]}, "OPTIONAL" : {"LABEL":[str,"Elevation"]} }
        axis_types["ROT"]  = {"MANDATORY" : {"NAME":[str,"Unknown"]}, "OPTIONAL" : {"LABEL":[str,"Rotator"]} }
        # --- altalt
        axis_types["ROLL"] = {"MANDATORY" : {"NAME":[str,"Unknown"]}, "OPTIONAL" : {"LABEL":[str,"Roll"]} }
        axis_types["PITCH"]= {"MANDATORY" : {"NAME":[str,"Unknown"]}, "OPTIONAL" : {"LABEL":[str,"Pitch"]} }
        axis_types["YAW"]  = {"MANDATORY" : {"NAME":[str,"Unknown"]}, "OPTIONAL" : {"LABEL":[str,"Yaw"]} }
        # N.B. Generally yaw is fixed in EW or NS direction
        # --- Decode args and kwargs parameters
        self._axis_params = self.decode_args_kwargs(0, axis_types, param_optionals, *args, **kwargs)
        # ===
        self.axis_type = self._axis_params["SELECTED_ARG"]
        # ===
        self._name = self._axis_params["NAME"]
        self._description = self._axis_params["DESCRIPTION"]
        self._language_protocol = self._axis_params["LANGUAGE_PROTOCOL"]
        # === relations mechanics and inc
        self.RATIO_WHEEL_PULLEY = self._axis_params["RATIO_WHEEL_PULLEY"]
        self.RATIO_PULLEY_MOTOR = self._axis_params["RATIO_PULLEY_MOTOR"]
        self.inc_per_motor_rev = self._axis_params["INC_PER_MOTOR_REV"]
        # === relations angle and inc
        self.inc0 = self._axis_params["INC0"]
        self.senseinc = self._axis_params["SENSEINC"]
        self.senseang = self._axis_params["SENSEANG"]
        # === simulation
        self.real = self._axis_params["REAL"]
        self.simu_signal_move = 0
        self._simu_signal_drift = 0
        self._simu_param_vel = 0
        self._simu_param_drift = 0
        self._simu_param_frame = "ang"
        self._simu_motion_t0 = time.time()
        self._simu_motion_start_t0 = self._simu_motion_t0
        # === velocities
        self.slewmax_deg_per_sec = 5.0
        self.slew_deg_per_sec = 5.0
        # === motion states
        self.motion_state_simu  = self.MOTION_STATE_NOMOTION
        self.motion_state  = self.MOTION_STATE_NOMOTION
        # === history
        self._history = []
        self._simu_start_t0 = time.time()
        # ===
        self.compute_phy = self.nat2phy, self.phy2nat

# #####################################################################
# #####################################################################
# #####################################################################
# Main
# #####################################################################
# #####################################################################
# #####################################################################

if __name__ == "__main__":
    cwd = os.getcwd()

    example = 1
    print("Example       = {}".format(example))

    if example == 1:

        inc_per_motor_rev = 1000.0 ; # IMC parameter. System Confg -> System Parameters - Distance/Revolution
        # --- SCX11 HA
        maxis = Motoraxis("DEC", name = "test", inc_per_motor_rev=inc_per_motor_rev, inc0=0, senseinc=1, real=False)