cinosbaseaxis.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSBASEAXIS_H
#define INC_CINOSBASEAXIS_H
//
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
#define DF_INOS_BASE_AXIS_DBT   "INOS-BASE-AXIS"    // db table name
//
#if defined(INOS_64)
#define DF_INOS_MAX_AXIS                512 // max. number of allowed axis
#else
#define DF_INOS_MAX_AXIS                256 // max. number of allowed axis
#endif
//
// --- axis states -------------------------------------------------------------
//
#define DF_INOS_AXIS_STATE_DISABLED     -1  // static state 'disabled'
#define DF_INOS_AXIS_STATE_UNDEFINED    0   // static state 'undefined'
#define DF_INOS_AXIS_STATE_OFF          0   // static state 'off', same as 'undefined'
#define DF_INOS_AXIS_STATE_ACTIVE       1   // static state 'active'
#define DF_INOS_AXIS_STATE_READY        2   // static state 'ready'
#define DF_INOS_AXIS_STATE_PEACE        2   // static state 'ready'
#define DF_INOS_AXIS_STATE_PULL         3   // static state 'pull'
#define DF_INOS_AXIS_STATE_BREAK        4   // static state 'break'
#define DF_INOS_AXIS_STATE_COUPLED      5   // static state 'coupled'
#define DF_INOS_AXIS_STATE_FORCE        6   // static state 'force'
#define DF_INOS_AXIS_STATE_ACTIVATING   8   // dynamic state 'activating'
#define DF_INOS_AXIS_STATE_INACTIVATING 9   // dynamic state 'inactivating'
#define DF_INOS_AXIS_STATE_SYNCING      10  // dynamic state 'syncing'
#define DF_INOS_AXIS_STATE_MOVING       11  // dynamic state 'moving'
#define DF_INOS_AXIS_STATE_ENDLESS      12  // dynamic state 'endless'
#define DF_INOS_AXIS_STATE_TOGGLE       13  // dynamic state 'toggle'
#define DF_INOS_AXIS_STATE_STOPPING     14  // dynamic state 'stopping'
#define DF_INOS_AXIS_STATE_BREAKING     15  // dynamic state 'breaking'
#define DF_INOS_AXIS_STATE_EMSTOPPING   16  // dynamic state 'emergency stopping'
#define DF_INOS_AXIS_STATE_MOVINGEX     17  // dynamic state 'moving ex'
#define DF_INOS_AXIS_STATE_CURSOR       18  // dynamic state 'cursor'
#define DF_INOS_AXIS_STATE_TRACK        19  // dynamic state 'track'
#define DF_INOS_AXIS_STATE_MOVINGAPP    20  // dynamic state 'movingapp'
#define DF_INOS_AXIS_STATE_MOVINGDEP    21  // dynamic state 'movingapp'
#define DF_INOS_AXIS_STATE_RELAXING     22  // dynamic state 'relaxing'
#define DF_INOS_AXIS_STATE_UMOVE        23  // dynamic state 'micromove' => see also DF_INOS_CONTROL_SUBSTATE_ACTIVE_UMOVE
#define DF_INOS_AXIS_STATE_SEARCHING    24  // dynamic state 'searching touch down'
#define DF_INOS_AXIS_STATE_DEPARTING    25  // dynamic state 'departing from touch down'
#define DF_INOS_AXIS_STATES             27  // number of states
//
// --- axis substates ----------------------------------------------------------
//
#define DF_INOS_AXIS_SUBSTATE_TRACK_FOLLOW  0   // track mode 'follow'
#define DF_INOS_AXIS_SUBSTATE_TRACK_KEEP    1   // track mode 'keep'
//
// --- axis commands -----------------------------------------------------------
//
#define DF_INOS_AXIS_CMD_ACTIVATE   0x00000001      // command 'Activate'
#define DF_INOS_AXIS_CMD_INACTIVATE 0x00000002      // command 'InActivate'
#define DF_INOS_AXIS_CMD_SYNC       0x00000004      // command 'Sync'
#define DF_INOS_AXIS_CMD_MOVE       0x00000008      // command 'Move'
#define DF_INOS_AXIS_CMD_ENDLESS    0x00000010      // command 'Endless'
#define DF_INOS_AXIS_CMD_STOP       0x00000020      // command 'Stop'
#define DF_INOS_AXIS_CMD_BREAK      0x00000040      // command 'Break'
#define DF_INOS_AXIS_CMD_CONTINUE   0x00000080      // command 'Continue'
#define DF_INOS_AXIS_CMD_EMSTOP     0x00000100      // command 'EmergencyStop'
#define DF_INOS_AXIS_CMD_UPDATE     0x00000200      // command 'Update'
#define DF_INOS_AXIS_CMD_TOGGLE     0x00000400      // command 'Toggle'
#define DF_INOS_AXIS_CMD_MOVEEX     0x00002000      // command 'MoveEx'
#define DF_INOS_AXIS_CMD_HANDLE_CACHE 0x00004000    // commands 'Enable,Disable,FlushCache'
#define DF_INOS_AXIS_CMD_CURSOR     0x00008000      // command 'Cursor'
#define DF_INOS_AXIS_CMD_TRACK      0x00010000      // command 'Track'
#define DF_INOS_AXIS_CMD_MOVESEG    0x00020000      // command 'Seg...'
#define DF_INOS_AXIS_CMD_COUPLING   0x00040000      // command 'couple'
#define DF_INOS_AXIS_CMD_PULL       0x00080000      // command 'pull'
#define DF_INOS_AXIS_CMD_MOVEAPP    0x00100000      // command 'MoveApp'
#define DF_INOS_AXIS_CMD_MOVEDEP    0x00200000      // command 'MoveDep'
#define DF_INOS_AXIS_CMD_ENABLE     0x00400000      // command 'Enable'
#define DF_INOS_AXIS_CMD_DISABLE    0x00800000      // command 'Disable'
#define DF_INOS_AXIS_CMD_COMMUTATE  0x01000000      // command 'Commutate'
#define DF_INOS_AXIS_CMD_MOVETIME   0x02000000      // command 'MoveTime'
#define DF_INOS_AXIS_CMD_RELAX      0x04000000      // command 'Relax'
//
// --- axis errors -------------------------------------------------------------
//
#define ER_INOS_AXIS_REJECTED   0x00000001  // command rejected
#define ER_INOS_AXIS_FAILED     0x00000002  // command failed
#define ER_INOS_AXIS_POS_WINDOW 0x00000004  // positioning window failed
#define ER_INOS_AXIS_CPD_ERROR  0x00000008  // coupled axis on error
#define ER_INOS_AXIS_CPD_DELTA  0x00000010  // coupling max delta reached
#define ER_INOS_AXIS_CPD_CORR   0x00000020  // coupling max correction reached
#define ER_INOS_AXIS_COM_FAILED 0x00000040  // communication to foreign controller failed
#define ER_INOS_AXIS_RAMP_LIMIT 0x00000080  // ramp limits exceeded
#define ER_INOS_AXIS_REJECTED_SOS 0x00000100// command SOS (safe operating stop) rejected
#define ER_INOS_AXIS_PULL_UNDERRUN 0x00000200// pull underrun detected
#define ER_INOS_AXIS_SLS_VIOLATION 0x00000400// emergency stop due to upcoming SLS violation
#define ER_INOS_AXIS_SOS_VIOLATION 0x00000800// emergency stop due to upcoming SOS violation
#define ER_INOS_AXIS_CORE_MISMATCH 0x00001000// core mismatch
#define ER_INOS_AXIS_FORCE_CONTROL  0x00002000  // force control error pending
#define ER_INOS_AXIS_CONTROL    0x00004000  // control error pending
#define ER_INOS_AXIS_RAMP       0x00008000  // ramp error pending
#define ER_INOS_AXIS_HOOK       0x00010000  // registering hook failed
//
// --- axis warnings -----------------------------------------------------------
//
#define WR_INOS_AXIS_RAMP       0x00008000  // ramp warning pending
#define WR_INOS_AXIS_CONTROL    0x00004000  // control warning pending
#define WR_INOS_AXIS_IGNORED    0x00000001  // command ignored
#define WR_INOS_AXIS_CPD_CORR_IGNORED   0x00000002  // coupling correction ignored
#define WR_INOS_AXIS_COUPLED    0x00000008  // coupled axis has warning
#define WR_INOS_AXIS_EME_STOPPED    0x00000010  // the axis has been emergency stopped
//
// --- axis flags --------------------------------------------------------------
//
#define DF_INOS_AXIS_FLAG_ZERO  0x00000001  // zero position after move
#define DF_INOS_AXIS_FLAG_NORM  0x00000002  // norm position after move
#define DF_INOS_AXIS_FLAG_INCR  0x00000004  // incremental moves
#define DF_INOS_AXIS_FLAG_SYNC  0x00000008  // live sync position
#define DF_INOS_AXIS_FLAG_EDONE 0x00000010  // early done
#define DF_INOS_AXIS_FLAG_AACC  0x00000020  // auto accept errors on activate
#define DF_INOS_AXIS_FLAG_CURL  0x00000040  // current limitation
#define DF_INOS_AXIS_FLAG_LSNCD 0x00000080  // limits only checked if synched
#define DF_INOS_AXIS_FLAG_DISMP 0x00000100  // mapping permanently disabled
#define DF_INOS_AXIS_FLAG_RNDNR 0x00000200  // axis has random number
#define DF_INOS_AXIS_FLAG_PWCL  0x00000400  // limits are checked in post write
#define DF_INOS_AXIS_FLAG_DSAP  0x00000800  // disable SetAct/SetRealPosition in case of synched
#define DF_INOS_AXIS_FLAG_SAFETY 0x00001000 // powered by Indel safety
#define DF_INOS_AXIS_FLAG_ESPULL 0x00002000 // emergency stop pull in case of an axis error
#define DF_INOS_AXIS_FLAG_IGNORE_CORE 0x00004000 // ignore core mismatch failure (should only be used in desperate situations)
#define DF_INOS_AXIS_FLAG_INPUT_SHAPING_ACTIVE  0x20000000  // temporary input shaping active
#define DF_INOS_AXIS_FLAG_WINDOW 0x40000000 // temporary position window active
#define DF_INOS_AXIS_FLAG_SNCD  0x80000000  // axis is synced
//
// --- axis sync modes ---------------------------------------------------------
//
#define DF_INOS_AXIS_SYNC_NOADJ     0x00    // live sync with no move adjust
#define DF_INOS_AXIS_SYNC_ADJUST    0x01    // live sync with move adjust
#define DF_INOS_AXIS_SYNC_STOP      0x02    // live sync with stop at sync
//
// --- axis norm modes ---------------------------------------------------------
//
#define DF_INOS_AXIS_NORM_AFTER     0x00
#define DF_INOS_AXIS_NORM_LIVE      0x01
#define DF_INOS_AXIS_NORM_POSITIVE  0x40
#define DF_INOS_AXIS_NORM_ROUND     0x80
//
// --- axis moving direction in norm mode --------------------------------------
//
#define DF_INOS_AXIS_NORM_MOVE_DIR_NO   0x00
#define DF_INOS_AXIS_NORM_MOVE_DIR_POS  0x01
#define DF_INOS_AXIS_NORM_MOVE_DIR_NEG  0x02
#define DF_INOS_AXIS_NORM_MOVE_DIR_SHORT 0x03
#define DF_INOS_AXIS_NORM_MOVE_DIR_SHORT_EX 0x04
//
// --- axis safety types -------------------------------------------------------
//
#define DF_INOS_AXIS_SAFETY_EMGSTOP         0x00
#define DF_INOS_AXIS_SAFETY_AUTO            0x01
#define DF_INOS_AXIS_SAFETY_NONE            0x02
//
// --- axis emergency types ----------------------------------------------------
//
#define DF_INOS_AXIS_EMGT_STOP              0x00
#define DF_INOS_AXIS_EMGT_STOP_INACTIVATE   0x01
#define DF_INOS_AXIS_EMGT_INACTIVATE        0x02
#define DF_INOS_AXIS_EMGT_NONE              0x03
#define DF_INOS_AXIS_EMGT_STOP_POSITION     0x04
#define DF_INOS_AXIS_EMGT_STOP_POSITION_INACTIVATE  0x05
//
// --- emergency stop special values -------------------------------------------
//
#define DF_PRECONFIGURED_EME_STOP_TYPE      0xffff  // preconfigured (by dt2 or via inco variable) emergency stop type
#define DF_PRECONFIGURED_EME_STOP_POS_OR_STOP 0xfffe
#define DF_PRECONFIGURED_EME_STOP_DELAY     0xffff  // preconfigured (by dt2 or via inco variable) emergency stop delay
//
// --- positioning type --------------------------------------------------------
//
#define DF_INOS_AXIS_PST_STANDARD   0x00000000
#define DF_INOS_AXIS_PST_WINDOW     0x00000001
#define DF_INOS_AXIS_PST_WINDOW_OPT 0x00000002
//
// --- axis options ------------------------------------------------------------
//                       
#define DF_INOS_BASE_AXIS_OPT_EARLY_DONE    0x00000001
#define DF_INOS_BASE_AXIS_OPT_AUTO_ACCEPT   0x00000002
#define DF_INOS_BASE_AXIS_OPT_LIMITS_IF_SNCD 0x00000004
#define DF_INOS_BASE_AXIS_OPT_MAPPING_DISABLED 0x00000008
#define DF_INOS_BASE_AXIS_OPT_NORM_ENABLED  0x00000010
#define DF_INOS_BASE_AXIS_OPT_CHECK_LIMITS  0x00000020
#define DF_INOS_BASE_AXIS_OPT_LIFETIME      0x00000040
#define DF_INOS_BASE_AXIS_OPT_SETPOS_DISABLED 0x00000080
#define DF_INOS_BASE_AXIS_OPT_EMGSTOP_PULL  0x00000100
#define DF_INOS_BASE_AXIS_OPT_FORCE_CONTROL 0x00000200
#define DF_INOS_BASE_AXIS_OPT_IGNORE_CORE   0x00000400
 
#if defined(INOS_MOTORCONFIG_LOAD_SUPPORT)
#define DF_INOS_BASE_AXIS_OPT_CPF_UNIQUE    0x00000800
#endif
 
#define DF_INOS_BASE_AXIS_OPT_EMERGENCY_EXTERNAL    0x00001000
 
// --- axis limit errors -------------------------------------------------------------
//
#define DF_INOS_BASE_AXIS_LIMIT_S           0x00000001  // position limit of cmdS exceeded                             
#define DF_INOS_BASE_AXIS_LIMIT_V_OF_S      0x00000002  // velocity limit of cmdS exceeded                               
#define DF_INOS_BASE_AXIS_LIMIT_A_OF_S      0x00000004  // accelleration ity limit of cmdS exceeded                      
#define DF_INOS_BASE_AXIS_LIMIT_B_OF_S      0x00000008  // de-accelleration ity limit of cmdS exceeded                    
#define DF_INOS_BASE_AXIS_LIMIT_S_V_CONS    0x00000010  // consistency error between S and V                    
#define DF_INOS_BASE_AXIS_LIMIT_V           0x00000020  // velocity limit of cmdV exceeded                   
#define DF_INOS_BASE_AXIS_LIMIT_A_OF_V      0x00000040  // accelleration ity limit of cmdV exceeded                 
#define DF_INOS_BASE_AXIS_LIMIT_B_OF_V      0x00000080  // de-accelleration ity limit of cmdV exceeded   
#define DF_INOS_BASE_AXIS_LIMIT_A           0x00000100  // accelleration ity limit of cmdA exceeded
#define DF_INOS_BASE_AXIS_LIMIT_B           0x00000200  // de-accelleration ity limit of cmdA exceeded 
#define DF_INOS_BASE_AXIS_LIMIT_BRAKE       0x00000400  // axis cannot stop within bordes
#define DF_INOS_BASE_AXIS_LIMIT_J_OF_S      0x00000800  // jerk limit of cmdS exceeded 
#define DF_INOS_BASE_AXIS_LIMIT_J_OF_V      0x00001000  // jerk limit of cmdV exceeded 
#define DF_INOS_BASE_AXIS_LIMIT_J_OF_A      0x00002000  // jerk limit of cmdA exceeded 
#define DF_INOS_BASE_AXIS_LIMIT_J           0x00004000  // jerk limit of cmdJ exceeded 
 
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <cinosbus.h>
#include <cinosbaseramp.h>
#if defined(INOS_AXIS_EXTENSION_SUPPORT)
#include <cinosbaseaxisextension.h>
#endif
//
// C++
//
// project
//
//------------------------------------------------------------------------------
//--- structures ---------------------------------------------------------------
//------------------------------------------------------------------------------
 
struct SINOSBaseAxis
{
    inosName64 m_cName;
 
    inosName32 m_cRampType;
 
    uint16 m_uNumber;
 
    uint8 m_uCoreId;
 
    uint8 m_uReserved;
 
    uint32 m_uOptions;
 
    uint8 m_uSafetyType;
 
    uint8 m_uEmergencyType;
 
    uint16 m_uEmergencyDelay;
 
    uint32 m_uTestDelay;
 
    real64 m_rTestPos1;
 
    real64 m_rTestPos1Max;
 
    real64 m_rTestPos2;
 
    real64 m_rTestPos2Max;
 
    real64 m_rEmergencyPosition;
 
    real64 m_rTrackFactor;
 
    uint32 m_uTrackFilterLength;
 
    uint32 m_uPosType;
 
    uint32 m_uPosTime;
 
    uint32 m_uPosTimeout;
 
    real64 m_rPosTolerance;
 
    uint32 m_uCacheSize;
 
    uint16 m_cShort;
 
    uint8 m_uNormMode;
 
    uint8 m_uNormMoveDir;
 
    real64 m_rNormPos;
 
    inosName32 m_cDefaultParam;
 
    inosName32 m_cEmergencyParam;
 
    real64 m_rPowerPosition;
 
    inosName32 m_cPowerParam;
 
    inosName64 m_cDescription;
 
    // constructor
    SINOSBaseAxis();
};
 
//------------------------------------------------------------------------------
// forward declarations
//------------------------------------------------------------------------------
//
class CINOSMoveCache;
class CINOSBaseAxis;
class CINOSLimitChecker;
//
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
 
class CINOSBaseAxisParamSet
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
        virtual uint32 SetParam(const char* apName, real64 arValue);
            //; universal set parameter with aName to aValue and return error code
            //; \return 0 on success, an INCO error code otherwise, such as
            //;  defVarNotFound, defVarReadOnly, etc.
        virtual uint32 GetParam(const char* apName, real64& arResult);
            //; universal get parameter with aName to aResult and return error code
        virtual CINCOObject* GetRegister(CINOSBaseAxis* apAxis);
            //; On the first invocation, this function creates the INCO tree
            //; for this object. Subsequent invocations just return the
            //; previously created tree.
            //; return pointer to my inco object
        virtual CINCOObject* GetRegister() const;
            //; \return Pointer to my INCO object (or NULL if non have been
            //; created so far). This function doesn't create any INCO items,
            //; it just returns what's currently there.
        SINOSRampParam* GetRampParam()
            { return &m_pRamp->m_Param;};
 
        #if defined(INOS_AXIS_EXTENSION_SUPPORT)
        void AddExtension(SINOSParamSetExtension* apExtension);
        void RemoveExtension(const char* apName);
        #endif
 
    //--- internals --------------------------------------------------------
 
    // my axis is my friend
    friend class CINOSBaseAxis;
    friend class CINOSPhysicalAxis;
    friend class CINOSShape;
    
    // public but just for internal use
    public:
        CINOSBaseAxisParamSet& operator=(const CINOSBaseAxisParamSet& aOther);
        int operator < (CINOSBaseAxisParamSet& aSet) const
            { return (strcmp(m_cName, aSet.m_cName)<0);}
        int operator == (CINOSBaseAxisParamSet& aSet) const
            { return (strcmp(m_cName, aSet.m_cName)==0);}
        int operator < (const char* apName) const
            { return (strcmp(m_cName, apName)<0);}
        int operator == (const char* apName) const
            { return (strcmp(m_cName, apName)==0);}
        friend int operator == (CINOSBaseAxisParamSet& aSet1, CINOSBaseAxisParamSet& aSet2)
            { return (strcmp(aSet1.m_cName, aSet2.m_cName)==0);}
 
    // public but just for internal use
    public:
        explicit CINOSBaseAxisParamSet(const char* apName);
            //; constructor
        CINOSBaseAxisParamSet(const CINOSBaseAxisParamSet& aOther);
            //; copy constructor, creates deep copies of the values. Note
            //; that m_pRegister will not be copied nor created. The caller
            //; would need to call GetRegister() to create the INCO
            //; representation
        virtual ~CINOSBaseAxisParamSet();
            //; destructor
 
    // protected members
    protected:
        inosName64 m_cName;
            //; set name
        CINCOObject* m_pRegister;
            //; pointer to inco registration of set
        CINOSBaseRampParamSet* m_pRamp;
            //; pointer to ramp param set
        uint32 m_uPosType;
            //; positioning type [0-standard, 1-window]
        uint32 m_uPosTime;
            //; positioning time [ms]
        uint32 m_uPosTimeout;
            //; positioning timeout [ms]
        real64 m_rPosTolerance;
            //; positioning tolerance [unit]
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSBaseAxisParamSet);
};
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
typedef real64 (*tpGetter)(void* apVal);
 
struct SINOSBaseAxisHook;
class CINOSMapping;
class CINOSBaseAxis
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        explicit CINOSBaseAxis(SINOSBaseAxis* apDesc);
 
        CINOSBaseAxis(SINOSBaseAxis* apDesc, CINOSBaseRamp* apRamp);
 
        virtual ~CINOSBaseAxis();
 
        static CINOSBaseAxis* GetAxis(const char* apAxisName);
 
        static CINOSBaseAxis* GetAxis(uint32 auNumber)
            { 
                if (auNumber < DF_INOS_MAX_AXIS)
                    return m_pAxis[auNumber];
                else
                    return nullptr;
            }
 
        static uint8 GetNumber(const char* apAxisName);
            //; return number of axis apAxis 
 
        virtual uint32 WaitTicks(uint32 auTicks = 1);
        
        virtual uint32 Connect()
            { return 0; };
 
        virtual uint32 Enable(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Disable(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        void InitializeLimitChecker();
 
 
        virtual uint32 Activate(bool abCheckPos = true, bool abSimulatePos = false,
            bool abSimulateOut = false, bool abSimulateAct = false, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 InActivate(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
        
        virtual uint32 Relax(uint32 auTimeMs, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Sync(real64 arPosition, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Sync(real64 arPosition, SINOSRampParam* apParam, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Sync(real64 arPosition, const char* apParam, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Sync(real64 arPosition, real64 arSyncPos,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Sync(real64 arPosition, real64 arSyncPos,
            SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Sync(real64 arPosition, real64 arSyncPos,
            const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Sync(real64 arSyncPos, const char* apParam, CINCOObject* apObject,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Move(real64 arPosition, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Move(real64 arPosition, SINOSRampParam* apParam,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Move(real64 arPosition, const char* apParam,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5 = true,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5,
            SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 MoveTime(real64 arPosition, real64 arTime, bool abUseP5,
            const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Move(real64 arPosition, real64 arSafe1, real64 arSafe2, 
            SINOSRampParam* apParam1, SINOSRampParam* apParam2, real64 arPartner, SINOSRampParam* apPartner,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Move(real64 arPosition, real64 arSave1, real64 arSave2, 
            const char* apParam1, const char* apParam2, real64 arPartner, const char* apPartner,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity, 
            SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity, 
            const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity, 
            SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity, 
            const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Toggle(real64 arPosition1, real64 arPosition2);
 
        virtual uint32 ToggleSection(real64 arPos1Min, real64 arPos1Max,
            real64 arPos2Min, real64 arPos2Max, uint32 auDelayMin, uint32 auDelayMax);
 
        virtual uint32 Track(const char* apVarName, real64 arFactor,
            uint32 auFilterLength, uint32 auDirection = 0);
 
        virtual uint32 Track(const char* apVarName, real64 arFactor,
            uint32 auFilterLength, uint32 auDirection, const char* apParam);
 
        virtual uint32 Track(const char* apVarName, real64 arCmdValue, 
            real64 arFactor, uint32 auFilterLength);
 
        virtual uint32 SetTrackFactor(real64 arFactor);
 
        virtual uint32 Endless(bool abPositive = true);
 
        virtual uint32 Endless(bool abPositive, SINOSRampParam* apParam,
            CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
 
        virtual uint32 Endless(bool abPositive, const char* apParam,
            CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
 
        virtual uint32 Cursor(bool abPositive = true);
 
        virtual uint32 Cursor(real64 arPosition);
 
        virtual uint32 Cursor(bool abPositive, uint32 auWaitTime);
 
        virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime);
 
        virtual uint32 Cursor(bool abPositive, uint32 auWaitTime,
            real64 arStep);
 
        virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime,
            real64 arStep);
 
        virtual uint32 Cursor(bool abPositive, uint32 auWaitTime,
            real64 arStep, SINOSRampParam* apParam);
 
        virtual uint32 Cursor(real64 arPosition, uint32 auWaitTime,
            real64 arStep, SINOSRampParam* apParam);
 
        virtual uint32 Cursor(bool abPositive, uint32 auWaitTime,
            real64 arStep, const char* apParam);
 
        virtual uint32 Cursor(real64 arbPosition, uint32 auWaitTime,
            real64 arStep, const char* apParam);
 
        virtual uint32 Update(CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
 
        virtual uint32 Update(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
 
        virtual uint32 Update(const char* apParam, CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
 
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition);
 
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, SINOSRampParam* apParam);
 
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, const char* apParam);
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta);
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta,
                SINOSRampParam* apParam);
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta, const char* apParam);
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
                real64 arDelta);
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
                real64 arDelta, SINOSRampParam* apParam);
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
                real64 arDelta, const char* apParam);
 
        virtual real64 GetMoveTime(real64 arPosition);
 
        virtual real64 GetAccelerationTime(real64 arPosition);
 
        virtual real64 GetConstTime(real64 arPosition);
 
        virtual real64 GetDecelerationTime(real64 arPosition);
 
        virtual real64 GetMoveTime(real64 arPosition, SINOSRampParam* apParam);
 
        virtual real64 GetAccelerationTime(real64 arPosition, SINOSRampParam* apParam);
 
        virtual real64 GetConstTime(real64 arPosition, SINOSRampParam* apParam);
 
        virtual real64 GetDecelerationTime(real64 arPosition, SINOSRampParam* apParam);
 
        virtual real64 GetMoveTime(real64 arPosition, const char* apParam);
 
        virtual real64 GetAccelerationTime(real64 arPosition, const char* apParam);
 
        virtual real64 GetConstTime(real64 arPosition, const char* apParam);
 
        virtual real64 GetDecelerationTime(real64 arPosition, const char* apParam);
 
        virtual real64 GetMoveTime(real64 arPosition, real64 arDelta);
 
        virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta);
 
        virtual real64 GetConstTime(real64 arPosition, real64 arDelta);
 
        virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta);
 
        virtual real64 GetMoveTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetConstTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetMoveTime(real64 arPosition, real64 arDelta, const char* apParam);
 
        virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta, const char* apParam);
 
        virtual real64 GetConstTime(real64 arPosition, real64 arDelta, const char* apParam);
 
        virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta, const char* apParam);
 
        virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta);
 
        virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta);
 
        virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta);
 
        virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta);
 
        virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam);
        
        virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, const char* apParam);
 
        virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, const char* apParam);
 
        virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, const char* apParam);
 
        virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, const char* apParam);
        
        virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity);
 
        virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, SINOSRampParam* apParam);
 
        virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, const char* apParam);
 
        virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, real64 arDelta);
 
        virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, real64 arDelta, const char* apParam);
 
        virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
            real64 arPositionVel, real64 arVelocity, real64 arDelta);
 
        virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
            real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
            real64 arPositionVel, real64 arVelocity, real64 arDelta, const char* apParam);
 
        virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity);
 
        virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, SINOSRampParam* apParam);
 
        virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, const char* apParam);
 
        virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, real64 arDelta);
 
        virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel,
            real64 arVelocity, real64 arDelta, const char* apParam);
 
        virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
            real64 arPositionVel, real64 arVelocity, real64 arDelta);
 
        virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
            real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam* apParam);
 
        virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
            real64 arPositionVel, real64 arVelocity, real64 arDelta, const char* apParam);
 
        virtual int32 GetMoveTicks(real64 arPosition);
 
        virtual int32 GetAccelerationTicks(real64 arPosition);
 
        virtual int32 GetConstTicks(real64 arPosition);
 
        virtual int32 GetDecelerationTicks(real64 arPosition);
 
        virtual int32 GetMoveTicks(real64 arPosition, SINOSRampParam* apParam);
 
        virtual int32 GetAccelerationTicks(real64 arPosition, SINOSRampParam* apParam);
 
        virtual int32 GetConstTicks(real64 arPosition, SINOSRampParam* apParam);
 
        virtual int32 GetDecelerationTicks(real64 arPosition, SINOSRampParam* apParam);
 
        virtual int32 GetMoveTicks(real64 arPosition, const char* apParam);
 
        virtual int32 GetAccelerationTicks(real64 arPosition, const char* apParam);
 
        virtual int32 GetConstTicks(real64 arPosition, const char* apParam);
 
        virtual int32 GetDecelerationTicks(real64 arPosition, const char* apParam);
 
        virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta);
 
        virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta);
 
        virtual int32 GetConstTicks(real64 arPosition, real64 arDelta);
 
        virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta);
 
        virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
 
        virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
 
        virtual int32 GetConstTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
 
        virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta, SINOSRampParam* apParam);
 
        virtual int32 GetMoveTicks(real64 arPosition, real64 arDelta, const char* apParam);
 
        virtual int32 GetAccelerationTicks(real64 arPosition, real64 arDelta, const char* apParam);
 
        virtual int32 GetConstTicks(real64 arPosition, real64 arDelta, const char* apParam);
 
        virtual int32 GetDecelerationTicks(real64 arPosition, real64 arDelta, const char* apParam);
 
        virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta);
 
        virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta);
 
        virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta);
 
        virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta);
 
        virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam);
 
        virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam);
 
        virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam);
 
        virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam);
 
        virtual int32 GetMoveTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, const char* apParam);
 
        virtual int32 GetAccelerationTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, const char* apParam);
 
        virtual int32 GetConstTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, const char* apParam);
 
        virtual int32 GetDecelerationTicks(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, const char* apParam);
 
        virtual int32 GetExitTicks();
 
        virtual real64 GetMoveDist(real64 arTime);
 
        virtual real64 GetMoveDist(real64 arPosition, real64 arTime);
 
        virtual real64 GetMoveDist(real64 arTime, SINOSRampParam* apParam);
 
        virtual real64 GetMoveDist(real64 arPosition, real64 arTime,
            SINOSRampParam* apParam);
 
        virtual real64 GetMoveDist(real64 arTime, const char* apParam);
 
        virtual real64 GetMoveDist(real64 arPosition, real64 arTime,
            const char* apParam);
 
        virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks);
 
        virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks,
            SINOSRampParam* apParam);
 
        virtual real64 GetMoveDist(real64 arPosition, uint32 auTicks,
            const char* apParam);
 
        virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
            real64 arTime);
 
        virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
            real64 arTime, SINOSRampParam* apParam);
 
        virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
            real64 arTime, const char* apParam);
 
        virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
            uint32 auTicks);
 
        virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
            uint32 auTicks, SINOSRampParam* apParam);
 
        virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
            uint32 auTicks, const char* apParam);
 
        virtual uint64 GetStartTicks(real64 arDelta);
 
        virtual uint64 GetTargetTicks();
 
        virtual uint64 GetTargetTicks(real64 arDelta);
 
        virtual uint32 SegBegin(real64 arSlowMotion = REAL64(1.0), real64 arStartVelocity = REAL64(0.0));
 
        virtual uint32 SegBegin(real64 arSlowMotion, real64 arStartPosition, real64 arStartVelocity);
 
        virtual uint32 SegMove(real64 arPosition);
 
        virtual uint32 SegMove(real64 arPosition, SINOSRampParam* apParam);
 
        virtual uint32 SegMove(real64 arPosition, const char* apParam);
 
        virtual uint32 SegMove(real64 arPosition, real64 arVelocity);
 
        virtual uint32 SegMove(real64 arPosition, real64 arVelocity, 
            SINOSRampParam* apParam);
 
        virtual uint32 SegMove(real64 arPosition, real64 arVelocity, 
            const char* apParam);
 
        virtual uint32 SegConst(real64 arPosition);
 
        virtual uint32 SegPos(real64 arTime);
 
        virtual uint32 SegPosSetTime(real64 arTime);
 
        virtual uint32 SegVelocity(real64 arVelocity, SINOSRampParam* apParam);
 
        virtual uint32 SegVelocity(real64 arVelocity, const char* apParam);
 
        virtual real64 SegTime();
 
        virtual uint32 SegRun(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 WaitInPosition();
 
        virtual uint32 GetBusTicksPerAxisTick();
 
        // pulling
 
        virtual uint32 Pull(real64 arS, real64 arV, real64 arA, real64 arJ);
 
        virtual uint32 Pull(SINOSRampData& aData);
 
        virtual uint32 Pull(SINOSRampDataEx* apData);
 
        void EnableRamp()
            {
                // enable trajectory generator
                m_pRamp->Enable();
            };
 
        void DisableRamp()
            {
                // disable trajectory generator
                m_pRamp->Disable();
            };
 
        // stop/break/continue functions
 
        virtual uint32 Stop(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Stop(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Stop(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Stop(real64 arPosition, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Stop(real64 arPosition, SINOSRampParam* apParam,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Stop(real64 arPosition, const char* apParam,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 StopLive();
 
        virtual uint32 StopLive(real64 arSlowMotion, SINOSRampParam* apParam);
 
        virtual uint32 StopLiveDelta(real64 arDelta, real64 arSlowMotion, SINOSRampParam* apParam = nullptr);
 
        virtual uint32 Break(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Break(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Break(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Break(real64 arPosition, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Break(real64 arPosition, SINOSRampParam* apParam, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Break(real64 arPosition, const char* apParam, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Continue(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Continue(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 Continue(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 EmergencyStop(CINOSSync* apSync);
 
        virtual uint32 EmergencyStop(uint16 auType = DF_PRECONFIGURED_EME_STOP_TYPE, uint16 auDelay = DF_PRECONFIGURED_EME_STOP_DELAY,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uint32 EmergencyStopLive();
 
        virtual uint32 EmergencyStopLive(uint16 auType, uint16 auDelay = DF_PRECONFIGURED_EME_STOP_DELAY);
 
        // get/set property functions
        
        virtual const char* GetName();
            //; return axis name
        virtual const char* GetType();
            //; return axis type
        virtual const char* GetUnit();
            //; return axis unit
        virtual uint32 GetCharacteristics();
            //; return axis characteristics
        virtual uint8 GetNumber()
            //; return axis number
            { return (uint8) m_pDesc->m_uNumber;};
        virtual uint32 GetOptions()
            //; return axis options
            { return m_pDesc->m_uOptions;};
        virtual char GetShort()
            //; return axis short character
            { return m_cShort[0];};
        virtual void SetShort(char acShort)
            //; set axis short character
            { m_cShort[0] = acShort;};
        virtual void SetPartner(const char* apPartner);
            //; set partner axis (used for special move commands)
        virtual void SetPartner(CINOSBaseAxis* apPartner);
            //; set partner axis (used for special move commands)
        virtual void SetCmdPosition(real64 arPosition);
            //; set commanded axis position (see comment above)
        virtual void SetPathPosition(real64 arPosition){};
            //; set commanded path axis position
        virtual void GetCmdPosition(real64& arPosition);
            //; get commanded axis position (see comment above)
        virtual void SetCmdVelocity(real64 arVelocity);
            //; set commanded velocity (see comment above)
        virtual void GetCmdVelocity(real64& arVelocity, CINOSBaseRamp::ECmdFlags aeFlags = CINOSBaseRamp::eFlgCmdNone);
            //; get commanded velocity (see comment above)
        virtual void SetCmdAcceleration(real64 arAcceleration);
            //; set commanded acceleration (see comment above)
        virtual void GetCmdAcceleration(real64& arAcceleration, CINOSBaseRamp::ECmdFlags aeFlags = CINOSBaseRamp::eFlgCmdNone);
            //; get commanded acceleration (see comment above)
        virtual void SetCmdDeceleration(real64 arDeceleration);
            //; set commanded deceleration (see comment above)       
        virtual void GetCmdDeceleration(real64& arDeceleration, CINOSBaseRamp::ECmdFlags aeFlags = CINOSBaseRamp::eFlgCmdNone);
            //; get commanded deceleration (see comment above)
        virtual void SetCmdCruiseleration(real64 arCruiseleration);
            //; set commanded cruiseleration (see comment above)         
        virtual void GetCmdCruiseleration(real64& arCruiseleration);
            //; get commanded cruiseleration (see comment above)
        virtual void SetCmdJerk(real64 arJerk, uint32 auNumber = DF_INOS_RAMP_JERK_ALL);
            //; set commanded jerk (see comment above)
        virtual void GetCmdJerk(real64& arJerk, uint32 auNumber = 0);
            //; get commanded jerk (see comment above)
        virtual void SetCmdCruiseJerk(real64 arCruiseJerk);
            //; set commanded cruise jerk (see comment above)
        virtual void GetCmdCruiseJerk(real64& arCruiseJerk);
            //; get commanded cruise jerk (see comment above)
        virtual void GetCmdRealJerk(real64& arJerk, uint32 auNumber = 0);
            //; get commanded real jerk (see comment above)
        virtual void SetCmdSlowMotion(real64 arSlowMotion, bool abUpdate = false);
            //; set commanded slowmotion factor
        virtual void GetCmdSlowMotion(real64& arSlowMotion, const char* apParam = 0);
            //; get commanded slowmotion factor
        virtual void GetActSlowMotion(real64& arSlowMotion, const char* apParam = 0);
            //; get actual slowmotion factor (slowmotion>slowmotionmax ? slowmotionmax : slowmotion)
        virtual void SetCmdRelaxTime(real64 arRelaxTime);
            //; set commanded relax time
        virtual void GetCmdRelaxTime(real64& arRelaxTime);
            //; get commanded relax time
        virtual void SetEmgDeceleration(real64 arDeceleration);
            //; set commanded emergency deceleration         
        virtual void GetEmgDeceleration(real64& arDeceleration);
            //; get commanded emergency deceleration
        //; get commanded relax time
        virtual void SetEmgPosition(real64 arPosition);
            //; set emergency position
        virtual void GetEmgPosition(real64& arPosition);
            //; get emergency position
 
 
        virtual uint32 SetActPosition(real64 arPosition);
 
        virtual void GetActPosition(real64& arPosition, bool abRamp = true);
 
        double NormPosition(real64 arPosition) const
            {
                if (m_uFlag & DF_INOS_AXIS_FLAG_NORM){
                    // norming active
                    return iNormPosition(arPosition, m_rNormPos, m_uNormMode & DF_INOS_AXIS_NORM_ROUND);
                }
                else {
                    // no norming
                    return arPosition;
                }
            }
 
        virtual void GetActPosition(real64& arPosition, uint64 auTicks);
            //; get actual commanded position at bus ticks auTicks
        virtual void GetPullAdjPosition(real64& arPosition);
            //; get actual position adjust used in pull mode
        virtual uint32 NrmActPosition(real64 arRange = REAL64(0.0), bool abRound = false);
            //; norm actual position
        virtual void GetActVelocity(real64& arVelocity, bool abMapped = true);
            //; get actual commaned velocity (see comment above)
        virtual void GetActAcceleration(real64& arAcceleration, bool abRamp = true);
            //; get actual commanded acceleratio (see comment above)n
        virtual void GetActJerk(real64& arJerk, bool abRamp = true);
            //; get actual commanded jerk (see comment above)
        virtual uint32 AdjActTime(real64 arDelta);
            //; adjust actual move time
 
        virtual uint32 SetRealPosition(real64 arPosition);
 
        virtual void GetRealPosition(real64& arPosition, bool abMapped = true);
 
        virtual void GetRealVelocity(real64& arVelocity);
            //; get real velocity (see comment above)
        virtual void GetRealAcceleration(real64& arAcceleration);
            //; get real acceleration (see comment above)
        virtual void GetRealJerk(real64& arJerk);
            //; get real jerk (see comment above)
        virtual void GetActPosError(real64& arPosError)
            { arPosError = REAL64(0.0);};
            //; get actual position error (see comment above)
        virtual void GetActVelocityError(real64& arVelocityError, bool abFiltered = false)
            { arVelocityError = REAL64(0.0);};
            //; get actual position error
        virtual void GetUnitsPerInc(double& adUnits);
            //; get number of units per one inc
        virtual void GetIncsPerUnit(double& adIncs);
            //; get number of incs per unit
        virtual void SetMinPosition(real64 arPosition);
            //; set min. allowed position
        virtual void GetMinPosition(real64& apPosition) const;
            //; get min. allowed position
        virtual void SetMaxPosition(real64 arPosition);
            //; set max. allowed position
        virtual void GetMaxPosition(real64& arPosition) const;
            //; get max. allowed position
        virtual bool CheckPosition(real64& arPosition, bool abIgnoreMapping = false, SINOSRampParam* apParam = nullptr);
            //; return true if arPosition within the range or no range requested
        virtual void SetMinVelocity(real64 arVelocity);
            //; set min. allowed velocity
        virtual void SetMaxVelocity(real64 arVelocity);
            //; set max. allowed velocity
        virtual void SetMaxSetupVelocity(real64 arVelocity);
            //; set max. allowed velocity in setup mode
        virtual void SetMaxInitVelocity(real64 arVelocity);
            //; set max. allowed velocity during initialization
        virtual void GetMinVelocity(real64& arVelocity);
            //; get min. allowed velocity
        virtual void GetMaxVelocity(real64& arVelocity, uint32 auFlags = eMaxVelocityNone);
            //; get max. allowed velocity
        virtual void GetTrqVelocity(real64& arVelocity);
            //; get torque velocity
        virtual void GetMaxSetupVelocity(real64& arVelocity);
            //; get max. allowed velocity in setup mode
        virtual void GetMaxInitVelocity(real64& arVelocity);
            //; get max. allowed velocity during initialization
        virtual void SetMinAcceleration(real64 arAcceleration);
            //; set min. allowed acceleration
        virtual void SetMaxAcceleration(real64 arAcceleration);
            //; set max. allowed acceleration
        virtual void SetMaxAccelerationPull(real64 arAcceleration);
            //; set max. allowed acceleration during pull
        virtual void GetMinAcceleration(real64& arAcceleration);
            //; get min. allowed acceleration
        virtual void GetMaxAcceleration(real64& arAcceleration);
            //; get max. allowed acceleration
        virtual void GetMaxAccelerationPull(real64& arAcceleration);
            //; get max. allowed acceleration during pull
        virtual void GetTrqAcceleration(real64& arAcceleration);
            //; get torque acceleration
        virtual void SetMinDeceleration(real64 arDeceleration);
            //; set min. allowed deceleration
        virtual void SetMaxDeceleration(real64 arDeceleration);
            //; set max. allowed deceleration
        virtual void GetMinDeceleration(real64& arDeceleration);
            //; get min. allowed deceleration
        virtual void GetMaxDeceleration(real64& arDeceleration);
            //; get max. allowed deceleration
        virtual void GetTrqDeceleration(real64& arDeceleration);
            //; get tourque deceleration
        virtual void SetMinCruiseleration(real64 arCruiseleration);
            //; set min. allowed cruiseleration
        virtual void SetMaxCruiseleration(real64 arCruiseleration);
            //; set max. allowed cruiseleration
        virtual void GetMinCruiseleration(real64& arCruiseleration);
            //; get min. allowed cruiseleration
        virtual void GetMaxCruiseleration(real64& arCruiseleration);
            //; get max. allowed cruiseleration
        virtual void SetMinJerk(real64 arJerk);
            //; set min. allowed jerk
        virtual void SetMaxJerk(real64 arJerk);
            //; set max. allowed jerk
        virtual void GetMinJerk(real64& arJerk);
            //; get min. allowed jerk
        virtual void GetMaxJerk(real64& arJerk);
            //; get max. allowed jerk
        virtual void GetEpsilon(real64& arEpsilon);
            //; get axis epsilon
        virtual void GetCycleTime(real64& arCycleTime, bool abOversampled=false);
            //; get axis cycle time [sec]
        virtual void GetCycleTimeUs(uint32& auCycleTime);
            //; get axis cycle time [us]
        virtual void GetCycleTimeNs(uint32& auCycleTime);
            //; get axis cycle time [ns]
        virtual uint8 GetOversampling();
            //; get oversampling factor
        virtual uint16 GetCycleNumber();
            //; get axis cycle number
        virtual uint16 GetCycleId();
            //; get axis cycle id
        virtual void UpdateCycleId(uint16 auCycleId);
            //; inform about updated cycle id (core id and cycle number could have changed)
        virtual uint8 GetBusId();
            //; get axis bus id
        virtual uint32 SetParam(const char* apName, real64 arValue);
            //; universal set parameter with aName to aValue and return error code
        virtual uint32 SetParam(const char* apName, uint64 auValue)
            //; universal set parameter with aName to aValue and return error code
            { return defVarNotFound;};
        virtual uint32 GetParam(const char* apName, real64& arResult);
            //; universal get parameter with aName to aResult and return error code
        virtual uint32 GetParam(const char* apName, uint64& auResult)
            //; universal get parameter with aName to aResult and return error code
            { return defVarNotFound;};
        virtual volatile real64* GetParamAdr(const char* apName);
            //; universal get address of parameter with aName or NULL if not found
        void SetFlag(uint32 auFlag)
            { INOS_OR(m_uFlag, auFlag);};
            //; set axis flags
        void ClrFlag(uint32 auFlag)
            { INOS_AND(m_uFlag, ~auFlag);};
            //; clear axis flags
        uint32 GetFlag()
            { return m_uFlag & m_uFlagEnb;};
            //; get axis flags
        void Absolute()
            { ClrFlag(DF_INOS_AXIS_FLAG_INCR);};
            //; switch to absolute mode 
        void Incremental()
            { SetFlag(DF_INOS_AXIS_FLAG_INCR);};
            //; switch to incremental mode  
        virtual uint32 SetState(uint32 auState);
            //; set axis state (used to set from ready to active to be able to force sync)
        virtual int32 GetState();
            //; get axis state
        virtual int32 GetState(uint32& auRampState);
            //; get axis and ramp state
        const char* GetStateText() const;
            //; \return A human readable text describing the current axis state.
        virtual bool IsBusy() const;
            //; Whether the axis is busy or not. Busy means: The axis is "used"
            //; by someone. E.g. the axis is also busy if it's in the "Coupled"
            //; state, which means that this axis is the "slave" and therefore 
            //; it gets its positions/commands from its master axis. The axis 
            //; is also busy if it is in "break" state (which means it is not 
            //; currently moving, but it'll continue an already started move 
            //; later). And it is also 'busy' if it's in "relax" state. In 
            //; fact, the axis is always busy, unless it is in undefined, 
            //; disabled, active, peace or read state.
            //; return true if the axis is currently busy. false otherwise.
        virtual uint32 GetError(bool abResolveExternal = false);
            //; get axis error
        virtual uint64 GetErrorEx(bool abResolveExternal = false);
            //; get extended axis errors
        virtual uint32 GetError(uint32& auRampError, bool abResolveExternal = false);
            //; get axis and ramp error
        virtual uint64 GetErrorEx(uint64& auRampError, bool abResolveExternal = false);
            //; get extended axis and ramp error
        virtual uint32 GetErrorHook() { return m_uErrorHook; };
            //; get axis and ramp error
        virtual bool IsErrorFatal()
            //; return true if error is fatal
            { return false;};       
        virtual uint32 GetWarning(bool abResolveExternal = false);
            //; get axis warning
        virtual uint64 GetWarningEx(bool abResolveExternal = false);
            //; get extended axis warning
        virtual uint32 GetWarning(uint32& auRampWarning, bool abResolveExternal = false);
            //; get axis and ramp warning
        virtual uint64 GetWarningEx(uint64& auRampWarning, bool abResolveExternal = false);
            //; get extended axis and ramp warning
        virtual uint32 GetLimitViolation() { return m_uLimitViolation;};
            //; get axis limit violation
        virtual void SetErrorMask(uint32 auMask) { m_uErrorMask = auMask;};
            //; set error mask and return old mask
        virtual void SetWarningMask(uint32 auMask) { m_uWarningMask = auMask;};
            //; set warning mask and return old mask
        virtual void SetLimitViolation(uint32 auLimitViolation) 
                                { INOSOr(&m_uLimitViolation, auLimitViolation);};
            //; set axis limit violation
        virtual uint32 GetErrorMask() { return m_uErrorMask;};
            //; get actual error mask
        virtual uint32 GetWarningMask() { return m_uWarningMask;};
            //; get actual warning mask
        virtual uint32 AcceptError();
            //; accept all errors
        virtual uint32 AcceptError(uint32 auError);
            //; accept error
        virtual uint32 AcceptError(uint32 auError, uint32 auRampError);
            //; accept error
        virtual uint32 AcceptWarning();
            //; accept all warnings
        virtual uint32 AcceptWarning(uint32 auWarning);
            //; accept warning
        virtual uint32 AcceptWarning(uint32 auWarning, uint32 auRampWarning);
            //; accept warning
        virtual uint32 AcceptLimitViolation() { m_uLimitViolation = 0; return 0;};
            //; get axis limit violation
 
        // param set functions
        virtual void eCreateParamSet(const char* apSetName);
            //; Same as CreateParamSet but for INCO registration (as it doesn't return 
            //; a pointer)
        virtual CINOSBaseAxisParamSet* CreateParamSet(const char* apSetName);
            //; create new param set with name apSetName and return pointer to it
        virtual void DestroyParamSet(const char* apSetName);
            //; destroy param set with name apSetName
        virtual bool SelectParamSet(const char* apSetName);
            //; select param set with name apSetName
        
        enum {
            eFlgParamSetNone = 0x00000000,
            eFlgParamSetSearchGlobal = 0x00000001,
            eFlgParamSetIgnoreOverwrite = 0x00000002
        };
 
        virtual CINOSBaseAxisParamSet* GetParamSet(const char* apSetName, uint32 auFlags = eFlgParamSetSearchGlobal);
            //; get pointer to param set with name apSetName
        virtual SINOSRampParam* GetRampParam(const char* apSetName, uint32 auFlags = eFlgParamSetSearchGlobal);
            //; get pointer to ramp param of set apSetName
        virtual bool GetRampParam(const char* apSetName, char* apResult, uint32 auSize,
                SINOSRampParam& aResult, uint32 auFlags = eFlgParamSetSearchGlobal);
            //; copy ramp param data to aResult and return true if successful, copy also to original speed set
            //; name to apResult. This method is also able to handle the xxx[V/A/B=yyy] case
        virtual void PreDestroyRampParam(SINOSRampParam* apParam);
            //; use this method to inform axis, that we're about to destroy a previously
            //; used speed set
 
        static void eCreateGlobalParamSet(const char* apSetName);
            //; Same as CreateParamSet but for INCO registration (as it doesn't return 
            //; a pointer)
        static CINOSBaseAxisParamSet* CreateGlobalParamSet(const char* apSetName);
            //; create new param set with name apSetName and return pointer to it
        static void DestroyGlobalParamSet(const char* apSetName);
            //; destroy param set with name apSetName
        static CINOSBaseAxisParamSet* GetGlobalParamSet(const char* apSetName);
            //; get pointer to param set with name apSetName
        static SINOSRampParam* GetGlobalRampParam(const char* apSetName);
            //; get pointer to ramp param of set apSetName
 
        // pos type functions
        virtual void SetPosType(uint32 auPosType)
            //; set pos type                     
            { m_uPosType = auPosType; };
        virtual void SetPosTime(uint32 auPosTime)
            //; set pos time
            { m_uPosTime = auPosTime; };
        virtual void SetPosTimeout(uint32 auPosTimeout)
            //; set pos timeout
            { m_uPosTimeout = auPosTimeout; };
        virtual void SetPosTolerance(real64 arPosTolerance)
            //; set pos tolerance
            { m_rPosTolerance = arPosTolerance; };
 
        // param set extensions
 
        #if defined(INOS_AXIS_EXTENSION_SUPPORT)
        SINOSParamSetExtension* GetParamSetExtension(uint32 auExtensionId)
        {
            // handle over
            return m_pRamp->GetParamSetExtension(auExtensionId);
        }
        real64 GetMoveTimeAdjust(SINOSRampParam* apParam);
        #endif
 
        // caching functions
 
        void EnableCache(uint32 auSize = 32);
            //; create moving cache with size auSize if nessecary and enable it
        CINOSRampCache* EnableCache(CINOSRampCache* apCache);
            //; set actual moving cache to apCache and return old one or 0
        CINOSRampCache* DisableCache();
            //; disable moving cache and return old one
        void ReEnableCache();
            //; Reenables a previously disabled ramp cache. This function is 
            //; useful if the cache feature has temporarily been disabled 
            //; before (DisableCache). Note: This function has no effect if
            //; the ramp does not yet owns a cache object. Also: It's safe
            //; to call this function while the cache is already enabled.
        void FlushCache();
            //; flush ramp cache
        void SetCacheEpsilon(real64 arEpsilon);
            //; set new cache 'epsilon' (standard is = 0.0)
        #ifdef INOS_MOVE_CACHE_SUPPORT
        void FlushMoveCache();
            //; flush moving cache
        #endif
 
        // safety
 
        #ifdef INOS_SAFETY_SUPPORT
        virtual void EnableSafetySupervision();
        virtual bool DisableSafetySupervision();
        virtual void ToggleSafetySupervision();
        #endif
 
        // miscellaneous functions
 
        virtual CINCOObject* GetRegister();
            //; do inco registration and return pointer to it
        virtual void SetRamp(CINOSBaseRamp* apRamp);
            //; set new ramp geni   
        CINOSBaseRamp* GetRamp()
            { return m_pRamp;};
            //; return pointer to ramp geni 
        virtual CINOSMapping* GetMapping()
            { return m_pMapping;};
            //; return pointer to actual axis mapping
        uint32 GetMappingIndex()
            { return m_uMappingIndex;};
            //; get actual mapping index
 
        // miscellaneous functions
 
        virtual uint32 RegisterHook(uintid& auHookId, void* apHandler, void* apObject,
            int32 aiOrder, bool abEnabled=true);
            //; register bus hook that runs in the same bus context, core,
            //; category, cyclenumber and cycletime as the axis
        virtual uint32 UnRegisterHook(uintid auHookId);
            //; unregister bus hook
        virtual uint32 EnableHook(uintid auHookId);
            //; enable hook
        virtual uint32 DisableHook(uintid auHookId);
            //; disable hook
        virtual uint32 RegisterPostHook(uintid& auHookId, void* apHandler, void* apObject,
            int32 aiOrder, bool abEnabled=true);
            //; register post bus hook that runs in the same bus context, core,
            //; category, cyclenumber and cycletime as the axis
        virtual uint32 UnRegisterPostHook(uintid auHookId);
            //; unregister bus hook
        virtual uintid RegisterErrorHook(void* apHandler, void* apObject = 0);
            //; register error hook and return hook id
        virtual void UnRegisterErrorHook(uintid auHookId);
            //; unregister error hook
        virtual uintid RegisterWarningHook(void* apHandler, void* apObject = 0);
            //; register Warning hook and return hook id
        virtual void UnRegisterWarningHook(uintid auHookId);
            //; unregister Warning hook
        #ifdef INOS_SAFETY_SUPPORT
        virtual uintid RegisterSOSHook(void* apHandler, void* apObject = 0);
            //; register SOS hook and return hook id
        virtual void UnRegisterSOSHook(uintid auHookId);
            //; unregister SOS hook
        #endif
 
        #if defined(INOS_AXIS_EXTENSION_SUPPORT)
        virtual void RegisterExtension(IINOSBaseAxisExtension* apExtension);
        virtual void UnRegisterExtension(IINOSBaseAxisExtension* apExtension);
        #endif
 
        // auto sync
 
        virtual void EnableSync(real64 arPosition = REAL64(0.0),
            uint8 auMode = DF_INOS_AXIS_SYNC_NOADJ){};
            //; enable auto syncing (at sync set pos = arPosition)
        virtual void DisableSync(){};
            //; disable auto syncing
        virtual void GetSyncCount(uint32& auSyncCount)
            { auSyncCount = 0;};
            //; return actual sync counter
        virtual void SetSyncCount(uint32 auSyncCount){};
            //; set sync counter
 
        // auto norm
 
        virtual void EnableNorm(uint8 auMode = DF_INOS_AXIS_NORM_AFTER,
            uint8 auMoveDir = DF_INOS_AXIS_NORM_MOVE_DIR_NO,
            real64 arNormPos = REAL64(0.0));
        virtual void DisableNorm();
 
        virtual uint8 GetNormMoveDir()
            { return m_uNormMoveDir; };
 
        virtual void SetNormMoveDir(uint8 auNormMoveDir)
            { m_uNormMoveDir = auNormMoveDir; };
 
        virtual uint8 GetNormMode()
            { return m_uNormMode; };
 
        virtual void SetNormMode(uint8 auNormMode)
            { m_uNormMode = auNormMode; };
 
        // current limitation
 
        virtual void EnableCurLimit(){};
            //; enable current limitation
        virtual void DisableCurLimit(){};
            //; disable current limitation
        virtual bool GetCurLimit()
            //; return state of current limitation
            { return (m_uFlag & DF_INOS_AXIS_FLAG_CURL) != 0;};
 
        enum EActualType {
            eActInput,
            eActActual,
            eActOutput
        };
        SINOSRampData* GetActual(EActualType aeType = eActOutput, bool abCopy = true)
            {
                // check reqeusted type
                if (aeType == eActInput) {
                    // return pointer to ramp values
                    return m_pActRamp;
                } // end if
                else if (aeType == eActActual) {
                    // return pointer to actual values
                    return m_pActual;
                } // end if
                else {
                    // copy requested ?
                    if (abCopy && (m_pActual == m_pActRamp)) {
                        // yes
                        *m_pActControl = *m_pActRamp;
                    }
                    // actuals are now control avalues
                    m_pActual = m_pActControl;
                    // return pointer to output values
                    return m_pActControl;
                } // end else
            };
        SINOSRampData* GetRealVrt()
            { return m_pRealVrt;};
        SINOSRampData* GetActVrt()
            { return m_pActRamp;};
        SINOSRampData* GetActPhy()
            { return GetActual(eActOutput, false);};
 
        // safety move
 
        virtual void SetMoveSafeMin(real64 arMin, real64 arFact1=REAL64(0.0), 
            real64 arFact2=REAL64(0.0));
            //; set move safe minimum : arMin=requested minimum, 
            //; safe1=safe1+arFact(MoveSafeMin-calcedMin), safe2=dito
        virtual void ResetMoveSafeMin();
            //; reset move safe minimum
 
        // setup mode
        
        void EnableSetupMode();
            //; enable setup mode
        void DisableSetupMode();
            //; disable setup mode
        virtual bool CheckSetupMode();
            //; return true if setup mode active and fullfilled
 
        #ifdef INOS_USE_CUSTOMER_IMAGE_DATA
        void* GetCustomerSpecificData() const { return m_pCustomerSpecificData; }
            //; \return The pinter to the customer specific data (or NULL if
            //;  no such data are set).
        void SetCustomerSpecificData(void* apData) { m_pCustomerSpecificData = apData; }
            //; Sets apData to be the "customer specific data" of this axis.
            //; The function doesn't care about any previously set customer
            //; specific data: The caller is 100% responsible for freeing amy 
            //; resource related to these data!
            //; This class will never access the data in any way apart from
            //; initialization to NULL during object contstruction!
        #endif
 
        virtual uint32 GetToggleCnt()
            { return m_uToggleCnt; };
        virtual void SetToggleCnt(uint32 auSetVal)
            { m_uToggleCnt=auSetVal; };
 
        #ifdef INOS_MOVEPATH_SUPPORT
        void SetMovePathActuals(struct SINOSMovePathActual* apActuals);
        #endif
 
        // torque limitation
 
        SINOSBaseRampTrqLimit* GetTrqLimitAcceleration()
            { return m_pRamp->GetTrqLimitAcceleration(); };
        SINOSBaseRampTrqLimit* GetTrqLimitDeceleration()
            { return m_pRamp->GetTrqLimitDeceleration(); };
 
        // multicore
 
        uint8 GetCoreId()
            { return m_uCoreId; };
 
        #ifdef INOS_SAFETY_SUPPORT
        uint32 GetSafetyUid()
            { return m_uSafetyUid; };
        uint32 GetSafetyType()
            { return m_uSafetyType; };
        ESafetyFunction GetSafetyFunction() const {
            return m_eSafetyFunction;
        }
        #endif
 
    //--- internals --------------------------------------------------------
 
    // after this function you can register new ramps
    friend void _INI_0000_CINOSBaseAxis();
    friend void _INI_0400_CINOSBaseAxis();
    friend class CINOSRegisterBaseAxis;
    friend class CINOSMapping;
    friend class CINOSPhysicalAxis;
    friend void _INI_0400_INFO_DCM();
    friend class CINOSBaseAxisTest;
    friend class CINOSMovePathResourcePosAxis;
    friend class CINOSMcRobotCmdMove;
    friend class CINOSMcRobotCmdInit;
    friend class CINOSMcRobotCmdCalib;
    friend class CINOSMcTargetAxis;
    
    // protected member functions
    protected:
        void Create();
            //; create base axis
        real64 iNormPosition(real64 arPosition, real64 arRange = REAL64(0.0), bool abRound = false) const;
            //; norm arPosition to 0..360
        void Signal(CINOSSync*& apSync);
            //; signal sync object if requested
        virtual void SignalSync(CINOSSync& apSync);
            //; signal given sync object
        virtual void SetError(uint32 auErrors);
            //; set axis error (and call error hook if nessecary)
        virtual void SetWarning(uint32 auWarnings);
            //; set axis warning (and call warning hook if nessecary)
#ifdef INOS_SAFETY_SUPPORT
        virtual void CallSOSHooks();
            //; call SOS hooks
#endif // INOS_SAFETY_SUPPORT
        bool Enter(uint32 auCommand, CINOSSync* apSync = 0);
            //; check if command allowed in current state and return false if not
        void Exit ();
            //; leave critical section
        void Exit (CINOSSync*& apCmdSync, CINOSSync* apSync);
            //; leave critical section and wait if nessecary
        bool IsCritical()
            { return m_CmdLock.GetOwner() != 0;};
            //; return true if somebody stays in critical section
        virtual void iInActivate();
            //; inactivate axis
        virtual void iStop(SINOSRampParam* apParam);
            //; internal stop
        virtual void iEmergencyStop(bool abLive = false);
            //; internal emergency stop
        virtual void iPowerEmergencyStop();
            //; internal power failure emergency stop
        virtual uint32 iCursor(bool abPositive, uint32 auWaitTime,
            real64 arStep, SINOSRampParam* apParam);
            //; internal cursor
        virtual uint32 iCursor(real64 arPosition, uint32 auWaitTime,
            real64 arStep, SINOSRampParam* apParam);
            //; internal cursor
        real64 iGetAbsPosition(real64 arRelPosition);
            //; get absolute position of arRelPosition
        real64 iGetNrmAbsPosition(real64 arRelPosition, SINOSRampParam* apParam = nullptr, bool abConsiderStop = false);
            //; get normed absolute position of arRelPosition
        virtual void iSetCycleTime(real64 arCycleTime);
            //; set axis cycle time [sec]
        virtual void iRegisterAxis();
            //; register axis
        ICACHE virtual void iPreMap();
            //; pre mapping handler 
        ICACHE virtual void iPostMap();
 
        ICACHE inline void iCheckRampLimits() {
            if (m_pRamp->GetError() & ER_INOS_RAMP_VMAX_REACHED) {
                SetError(ER_INOS_AXIS_RAMP_LIMIT);
            }
        }
 
            //; post mapping handler 
        ICACHE virtual void iPostWrite();
            //; post bus write handler 
        void SetMapping(CINOSMapping* apMapping, uint32 auIndex)
            { m_pMapping = apMapping; m_uMappingIndex = auIndex;
              m_pRamp->SetMapping(apMapping, auIndex);};
            //; set actual axis mapping
        void ResetMapping()
            { m_pMapping = 0; m_uMappingIndex = 0;
              m_pRamp->ResetMapping();};
            //; reset actual axis mapping
        virtual bool iInPosition(bool abEarlyDone);
            //; returns true if requested position reached
        virtual bool iInPosition();
            //; returns true if requested position reached (originally, only
            //; this overload existed. Then, the abEarlyDone was introduced.
            //; Unfortunately, as this function was already 'virtual' we could
            //; not just add abEalyDone with a default value, as it would
            //; cause derived class, implemented by customers, to not function
            //; properly anymore.
        virtual void iAdjPreviousPositions(real64 arDifference);
            //; adjust previous axis positions (used in limit checker)  
        virtual void iSetActRampPosition(real64 arPosition);
            //; set actual ramp geni position
        virtual bool IsCheckPositionRequired();
            //; return true if check position required
        void SetDefaultParamIfRequired();
            //; Sets the "default param" values (V,A,J) to the ramp if those
            //; ramp values are current undefined (means: are 0.0). Function does
            //; nothing otherwise, or if no "default param" has been specified
            //; in the axis config (e.g. in dt2)
        void iSetupPositionType(SINOSRampParam* apParam = 0);
            //; init position type handling
        virtual void iResetTrajectory();
            //; reset trajectory planner
 
        void iCoreMismatchError();
            //; set core mismatch axis error
 
        INOS_INLINE void AtomicEnter(uint32& auToken)
        {
            CINOSBus* pBus=CINOSBus::FindBus(GetBusId());
            if (pBus) {
                pBus->AtomicGatherEnter(auToken);
            } else {
                // no bus -> no token
                auToken = 0;
            }
        }
 
        INOS_INLINE bool AtomicExit(uint32 auToken)
        {
            CINOSBus* pBus=CINOSBus::FindBus(GetBusId());
            if (pBus) {
                return pBus->AtomicGatherExit(auToken);
            } else {
                // no bus -> always OK
                return true;
            }
        }
 
    // private member functions (external versions, because until now we are not
    // able to register functions with default parameters)
    private:
        uint32 eEnable();
            //; enable axis
        uint32 eDisable();
            //; disable axis
        uint32 eActivate(bool abCheckPos, bool abSimulatePos,   bool abSimulateOut,
            bool abSimulateAct);
            //; activate physical axis
        uint32 eInActivate();
            //; inactivate physical axis
        uint32 eRelax(uint32 auTimeMs);
            //; relax coupled axis
        uint32 eMove(real64 arPosition);
            //; move to position with acc/deceleration and velocity
        uint32 eMove(real64 arPosition, char* apParam);
            //; move to position with apParam parameters
        uint32 eMoveTime(real64 arPosition, real64 arTime);
            //; move to position with acc/deceleration and velocity
        uint32 eMoveTime(real64 arPosition, real64 arTime, char* apParam);
            //; move to position with apParam parameters
        uint32 eMoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity);
            //; move to position with acc/deceleration and velocity
        uint32 eMoveApp(real64 arPosition, real64 aPositionVel, real64 arVelocity, char* apParam);
            //; move to position with apParam parameters
        uint32 eMoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity);
            //; move to position with acc/deceleration and velocity
        uint32 eMoveDep(real64 arPosition, real64 aPositionVel, real64 arVelocity, char* apParam);
            //; move to position with apParam parameters
        uint32 eSync(real64 arPosition);
            //; sync axis
        uint32 eSync(real64 arPosition, char* apParam);
            //; sync axis
        uint32 eSync(real64 arPosition, real64 arSyncPosition);
            //; sync axis
        uint32 eSync(real64 arPosition, real64 arSyncPosition, char* apParam);
            //; sync axis
        uint32 eCursor();
            //; cursor
        uint32 eUpdate();
            //; update
        uint32 eUpdate(const char* apParam);
            //; update
        uint32 eEndless(bool abPositive);
            //; move to position with acc/deceleration and velocity
        uint32 eEndless(bool abPositive, const char* aparam);
            //; move to position with acc/deceleration and velocity
        uint32 eStop();
            //; stop
        uint32 eStop(const char* apParam);
            //; stop
        uint32 eStop(real64 arPosition);
            //; stop
        uint32 eStop(real64 arPosition, const char* apParam);
            //; stop
        uint32 eBreak();
            //; break
        uint32 eBreak(const char* apParam);
            //; break
        uint32 eBreak(real64 arPosition);
            //; break
        uint32 eBreak(real64 arPosition, const char* apParam);
            //; break
        uint32 eEmergencyStop();
            //; emergency stop
        uint32 eEmergencyStop(uint32 auType, uint32 auDelay);
            //; emergency stop
        uint32 eContinue();
            //; stop
        uint32 eContinue(const char* apParam);
            //; stop
        void eSetSlowMotion(real64 arSlowMotion);
            //; stop
        void ePos1();
            //; move to pos 1 
        void ePos2();
            //; move to pos 2
        void eToggle();
            //; toggle between pos 1 and pos 2
        void eZero();
            //; set act pos = 0
        uint32 eAcceptError();
            //; accept all pending errors
        uint32 eAcceptWarning();
            //; accept all pending warnings
        void iToggling();
            //; toggle handler (called cyclic)
        void iCursoring();
            //; toggle handler (called cyclic)
        bool iTrack(const char* apVarName, real64 arFactor, uint32 auFilterLength);
            //; track the variable apVarName
        uint32 _Track(const char* apVarName, real64 arFactor, uint32 auFilter,
            uint32 auDirection, SINOSRampParam* apParam);
        void iTrackFollow();
            //; tracking handler (called cyclic)
        void iTrackKeep();
            //; tracking handler (called cyclic)
        
    // protected members
    protected:
        int32 m_uState;
            //; actual state
        uint32 m_uSubState;
            //; actual sub state
        uint32 m_uNxtState;
            //; next state
        uint32 m_uPrvState;
            //; previous state
        uint32 m_uBrkState;
            //; state before break
        uint32 m_uRmpState;
            //; state of ramp geni before GetSVAJ
        uint32 m_uError;
            //; actual errors
        uint32 m_uErrorMask;
            //; actual error mask
        uint32 m_uErrorHook;
            //; actual hook error
        uint32 m_uWarning;
            //; actual warnings
        uint32 m_uWarningMask;
            //; actual warnings mask
        uint32 m_uLimitViolation;
            //; actual limit violation mask
        uint32 m_uFlag;
            //; axis flags (zero, norm, ...)
        uint32 m_uFlagEnb;
            //; axis flags enable
 
        const char* m_pName;
            //; axis name
        const char* m_pType;
            //; axis type
        char m_cShort[2];
            //; short character
        CINOSBaseAxis* m_pPartner;
            //; pointer to partner axis
        CINCOObject* m_pRegister;
            //; pointer to inco registration
        CINCOObject* m_pCommand;
            //; pointer to inco registration of commands
        CINCOObject* m_pTest;
            //; pointer to inco registration of axis test
        CINCOObject* m_pError;
            //; pointer to inco registration of axis errors
        CINCOObject* m_pWarning;
            //; pointer to inco registration of axis warnings
        CINCOObject* m_pLimitViolation;      
            //; pointer to inco registration of limit violations 
        CINCOObject* m_pFlag;
            //; pointer to inco registration of axis flags
        CINCOObject* m_pState;
            //; pointer to inco registration of axis state
        CINOSBaseRamp* m_pRamp;
            //; pointer to ramp generator
        CINOSLimitChecker* m_pLimitChecker;
            //; pointer to limit checker
        CINOSMapping* m_pMapping;
            //; pointer to actual mapping
        uint32 m_uMappingIndex;
            //; index this axis has in the actual mapping
        SINOSBaseAxis* m_pDesc;
            //; pointer to object descriptor
        CINOSMutex m_CmdLock;
            //; mutex to guarantee mutual exclusion in command handling
        CINOSSync* m_pActivate;
            //; pointer to synch object to be signaled on end of activate
        CINOSSync* m_pInActivate;
            //; pointer to synch object to be signaled on end of inactivate
        CINOSSync* m_pMove;
            //; pointer to synch object to be signaled on end of move
        CINOSSync* m_pEndless;
            //; pointer to synch object to be signaled on end of endless
        CINOSSync* m_pStop;
            //; pointer to synch object to be signaled on end of stop
        CINOSSync* m_pEmStop;
            //; pointer to synch object to be signaled on end of emstop
        CINOSSync* m_pBreak;
            //; pointer to synch object to be signaled on end of break
        CINOSSync* m_pVelocity;
            //; pointer to synch object to be signaled on velocity reached
        CINOSSync* m_pContinue;
            //; pointer to synch object to be signaled on end of continue
        CINOSSync* m_pWaitInPosition;
            //; pointer to synch object to be signaled on end of waitinposition
        CINOSSync* m_pWaitInPositionDyn;
            //; pointer to dynamically created synch object to be signaled on end of waitinposition
        CINOSSync* m_pWaitTicks;
            //; pointer to synch object to be signaled on end of waitticks
        uint32 m_uWaitTicks;
            //; to to be waited for
        uintid m_uPreMapHookId;
            //; id of pre map hook
        uintid m_uPostMapHookId;
            //; id of post map hook
        uintid m_uPostWriteHookId;
            //; id of post bus write hook
        uintid m_uPreHookId;
            //; id of pre axis command hooks (e.g. track)
        #ifdef INOS_SAFETY_SUPPORT
        bool m_bPreHookSafetyEnabled;
        #endif
        uintid m_uPostHookId;
            //; id of post hook command hooks (e.g. toggle)
        SINOSBaseAxisHook* m_pErrorHooks;
            //; pointer to list of error hooks
        SINOSBaseAxisHook* m_pWarningHooks;
            //; pointer to list of error hooks
        TINOSNameBalancedBinaryTree<CINOSBaseAxisParamSet>* m_pParamSets;
            //; pool of all param sets
        static CINOSMutex m_GlobalParamSetsMutex;
            //; global param set mutex
        static TINOSNameBalancedBinaryTree<CINOSBaseAxisParamSet>* m_pGlobalParamSets;
            //; pool of all param sets
        #ifdef INOS_MOVE_CACHE_SUPPORT
        CINOSMoveCache* m_pMoveCache;
            //; pointer to move cache
        #endif
 
        // actual commanded values
 
        SINOSRampDataEx* m_pActual;
        SINOSRampDataEx* m_pActRamp;
        SINOSRampDataEx* m_pActControl;
        SINOSRampDataEx* m_pRealVrt;
        
        // previous three commanded values
        SINOSRampData m_sPreviousVrt[3];
 
        // test values
        
        real64 m_rPos1;
            //; toggle position 1
        real64 m_rPos1Max;
            //; max. toggle position 1
        real64 m_rPos2;
            //; toggle position 2
        real64 m_rPos2Max;
            //; max. toggle position 2
        uint32 m_uDelay;
            //; delay in ms between toggles
        uint32 m_uDelayMax;
            //; max. delay in ms between toggles
        uint32 m_uDelayAct;
            //; act. delay in ms between toggles
        int32 m_iTicks;
            //; system ticks to handle delay
        uint32 m_uToggleCnt;
            //; toggle counter
        
        // miscelanselous
        real64 m_rFeedPerTurn;
            //; feed per turn (used in method NormPosition)
        real64 m_rFeedPerTurn_1;
            //; 1 / feed per turn (used in method NormPosition)
        real64 m_rInertia;
            //; inertia (used in torque limitation)
        
        inosName32 m_cSelectedParamName;
            //; last selected param name
 
        // emergency values
 
        uint32 m_uEmergencyType;
            //; type of emergency stop (0-Stop, 1-Stop/InActivate, 2-InActivate, 3-none
            //; 4-Position, 5-Position/InActivate)
        uint32 m_uEmergencyDelay;
            //; Delay [ms] after Stop till InActivate (Type = 1)
        real64 m_rEmergencyPosition;
            //; emergency position
        uint16 m_uIntEmergencyType;
            //; type of emergency stop (0-Stop, 1-Stop/InActivate, 2-InActivate)
        uint16 m_uIntEmergencyDelay;
            //; Delay [ms] after Stop till InActivate (Type = 1)
        SINOSRampParam* m_pEmergency;
            //; pointer to emergency speed set (if available)
        SINOSRampParam* m_pPowerFailure;
            //; pointer to power failure speed set (if available)
        
        // cursoring 
        uint32 m_uCurWaitTime;
            //; wait afet initial move
        real64 m_rCurPosition;
            //; cursoring direction
        SINOSRampParam* m_pCurParam;
            //; cursoring params
        
        // syncing
        uint8 m_uSyncMode;
            //; requested sync mode
        // sync methods available
        bool m_bSyncAvailable = true;
 
        // norming
        uint8 m_uNormMode;
            //; requested norm mode
        uint8 m_uNormMoveDir;
            //; requested norm move direction
        real64 m_rNormPos;
            //; requested norm position
        
        // multicore
 
        uint8 m_uCoreId = DF_INOS_CORE_DEFAULT;
        
        // tracking
        uint16 m_uTrackValType;
            //; tracking value type
        uint16 m_uTrackDir;
            //; tracking direction (0-pos and neg, 1-pos, 2-neg)
        void* m_pTrackVal;
            //; pointer to track value
        real64 m_rTrackCyc;
            //; track cycletime [sec]
        real64 m_rTrackFct;
            //; tracking factor
        real64 m_rTrackPos;
            //; tracking position
        real64 m_rTrackVel;
            //; tracking velocity
        real64 m_rTrackCmd;
            //; tracking commanded value
        real64 m_rTrackSum;
            //; tracking sum
        uint16 m_uTrackLen;
            //; tracking buffer length
        uint16 m_uTrackInd;
            //; tracking buffer index
        int32 m_iTrackLst;
            //; last track value
        int32 m_iTrackOld;
            //; old track value
        real64* m_pTrackBuf;
            //; pointer to tracking buffer
        tpGetter m_pTrackGet;
            //; pointer to tracking value getter method
        real64 m_rTrackVmax;
        real64 m_rTrackAmax;
        real64 m_rTrackBmax;
 
        // positioning
        
        uint32 m_uPosType;
            //; positioning type
        uint32 m_uPosTime;
            //; positioning time [ms]
        uint32 m_uPosTimeout;
            //; positioning timeout [ms]
        int32 m_iPosTicks;
            //; positioning ticks
        int32 m_iPosTimeout;
            //; positioning timeout ticks
        real64 m_rPosTolerance;
            //; positioning tolerance
        
        // save moves
        
        // exit time
        real64 m_rExitTime;
        // partner also running
        bool m_bPartnerMoving;
        
        // bus timing
 
        uint32 m_uBusTicksPerAxisTick;
 
        uint16 m_uCycleId;
 
        #ifdef INOS_USE_CUSTOMER_IMAGE_DATA
        void* m_pCustomerSpecificData;
        #endif
        
        // safety
 
        #ifdef INOS_SAFETY_SUPPORT
        tUid m_uSafetyUid;
        uint8 m_uSafetyLevel;
        uint8 m_uSafetyType;
        ESafetyFunction m_eSafetyFunction;
        real64 m_rSafetyLimit;
        uint32 m_uSafetyDelay;
        int32 m_iSafetySupervisionStart;
        real64 m_rSafetySupervisionLimit;
        SINOSBaseAxisHook* m_pSOSHooks;
 
        // also called from CINOSMcTargetSafety at reload of ch.indel.safety.config.img
        friend class CINOSMcTargetSafety;
        void iSetupSafety();
        virtual bool iSetupSafetyRegistration();
        #endif
 
        // axis extensions
 
        #if defined(INOS_AXIS_EXTENSION_SUPPORT)
        TINOSDoubleLinkedList<IINOSBaseAxisExtension>* m_pExtensions = 0;
        #endif
 
    // command parameters
    protected:
        uint32 m_ueActivateCheckPos;
            //; param : CheckPos
        uint32 m_ueActivateSimulatePos;
            //; param : SimulatePos
        uint32 m_ueActivateSimulateOut;
            //; param : SimulateOut
        uint32 m_ueActivateSimulateAct;
            //; param : SimulateAct
        real64 m_rePosition;
            //; param : Position
        real64 m_rePositionVel{};
            //; param : PositionVel
        real64 m_reVelocity{};
            //; param : Velocity
        real64 m_reSyncPosition;
            //; param : SyncPosition
        inosName32 m_ceParam;
            //; param : Param
        char m_ceVariable[64];
            //; param : Variable
        real64 m_reFactor;
            //; param : Factor
        real64 m_reValue;
            //; param : Value
        uint32 m_ueFilter;
            //; param : Filter
        uint32 m_ueTrackDir;
            //; param : Track direction
        uint32 m_ueDirection;
            //; param : Direction
        uint32 m_ueWait;
            //; param : Wait
        real64 m_reStep;
            //; param : Step
        real64 m_reReturn;
            //; param : return
        real64 m_reDelta;
            //; param : delta
        real64 m_reStart;
            //; param : start
        real64 m_reEnd;
            //; param : end
        uint32 m_ueReturn;
            //; param : return
        uint32 m_ueTicks;
            //; param : ticks
        real64 m_reTime;
            //; param : time
        real64 m_reSlowMotion;
            //; param SLowMotion
 
        #ifdef INOS_MOVEPATH_SUPPORT
        class CINCOMovePathActuals* m_pMovePathActuals;
        #endif
 
    // static private members
    private:
        static uint32 m_uCount;
            //; number of axis in pool
        static uint8 m_uCountCoreId;
            //; current core id
        static CINOSBaseAxis* m_pFirst;
            //; pointer to first axis
        CINOSBaseAxis* m_pNext;
            //; pointer to next axis in the chain of all axis
        static CINOSBaseAxis* m_pAxis[DF_INOS_MAX_AXIS];
            //; array of axis pointers
        static char m_cStateCombo[494]; 
            //; axis state INCO item text. Use 494 (=defMaxDataLength). I fear
            //; to include inco_com.h here, that's why a plain number is used)
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSBaseAxis);
};
 
//------------------------------------------------------------------------------
// class registration
//------------------------------------------------------------------------------
 
typedef CINOSBaseAxis *(*TCreateAxis)(const char* apAxisName);
class CINOSRegisterBaseAxis 
{   
    // after this function you can register new ramps
    friend void _INI_0000_CINOSRegisterBaseAxis();
    
    //--- internals --------------------------------------------------------
    // private members 
private:
    // pointer to the first registered axis
    static CINOSRegisterBaseAxis* m_pFirst; 
    // pointer to the next axis
    CINOSRegisterBaseAxis* m_pNext; 
    // create funtion for axis
    TCreateAxis m_pCreate;
    // axis type name
    const char* m_pAxisType;
    // database table name
    const char* m_pDatabaseTable;
        
    //--- user interface ---------------------------------------------------
 
public:
    // register a new axis type
    CINOSRegisterBaseAxis(TCreateAxis apFunction, const char* apAxisType,
        const char* apDatabaseTable);
    
    // create and return and new axis instance
    static CINOSBaseAxis* GetAxis(const char* apAxisName, const char* apAxisType);
    // create all registered axis
    static void CreateAll();
};
 
//
//------------------------------------------------------------------------------
//--- helper macros ------------------------------------------------------------
//------------------------------------------------------------------------------
//
#if defined(INOS_MULTICORE)
#define INOS_AXIS_CORE_MISMATCH_IS_ERROR(ret)                               \
if ((m_uCoreId != DF_INOS_CORE_DEFAULT) && (::GetCoreId() != m_uCoreId)) {  \
    if (!(GetFlag() & DF_INOS_AXIS_FLAG_IGNORE_CORE)) {                     \
        iCoreMismatchError();                                               \
        return ret;                                                         \
    }                                                                       \
}
#else
#define INOS_AXIS_CORE_MISMATCH_IS_ERROR(ret)
#endif
 
 
//
//------------------------------------------------------------------------------
// safety macros
//------------------------------------------------------------------------------
//
#ifdef INOS_SAFETY_SUPPORT
#define SAFETY_CHECK_SOS()                                                  \
    if (GetFlag() & DF_INOS_AXIS_FLAG_SAFETY) {                             \
        if (m_eSafetyFunction == eSafetyFunctionSOS) {                      \
            real64 rSlowMotion; GetActSlowMotion(rSlowMotion);              \
            if (rSlowMotion != REAL64(0.0)) {                               \
                m_uError |= ER_INOS_AXIS_REJECTED_SOS;                      \
                INOS_ERROR("AXIS[%s]: Command rejected, axis in SOS (safe operating stop)", GetName());\
                return m_uError;                                            \
            }                                                               \
        }                                                                   \
    }
//
#define SAFETY_CHECK_SOS_SYNC(apSync)                                       \
    if (GetFlag() & DF_INOS_AXIS_FLAG_SAFETY) {                             \
        if (m_eSafetyFunction == eSafetyFunctionSOS) {                      \
            real64 rSlowMotion; GetActSlowMotion(rSlowMotion);              \
            if (rSlowMotion != REAL64(0.0)) {                               \
                m_uError |= ER_INOS_AXIS_REJECTED_SOS;                      \
                INOS_ERROR("AXIS[%s]: Command rejected, axis in SOS (safe operating stop)", GetName());\
                Signal(apSync);                                             \
                return m_uError;                                            \
            }                                                               \
        }                                                                   \
    }
//
#define SAFETY_IGNORE_IF_SOS()                                              \
    if (GetFlag() & DF_INOS_AXIS_FLAG_SAFETY) {                             \
        if (m_eSafetyFunction == eSafetyFunctionSOS) {                      \
            return m_uError;                                                \
        }                                                                   \
    }
#else
#define SAFETY_CHECK_SOS()
#define SAFETY_CHECK_SOS_SYNC(apSync)
#define SAFETY_IGNORE_IF_SOS()
#endif
//
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSBASEAXIS_H