cinosbaseramp.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSBASERAMP_H
#define INC_CINOSBASERAMP_H
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
#define DF_INOS_BASE_RAMP_DBT   "INOS-BASE-RAMP"// db table name
#define DF_INOS_BASE_RAMP_TRQ_LIMIT_ACC_DBT "INOS-BASE-RAMP-TRQ-LIMIT-ACC"  // db table name
#define DF_INOS_BASE_RAMP_TRQ_LIMIT_DEC_DBT "INOS-BASE-RAMP-TRQ-LIMIT-DEC"  // db table name
//                                                               
#define DF_INOS_RAMP_MAX_JERK   4       // max. number of supported jerks
//
// --- ramp states -------------------------------------------------------------
//
#define DF_INOS_RAMP_STATE_PEACE    0   // state 'peace'
#define DF_INOS_RAMP_STATE_BREAK    1   // state 'break'
#define DF_INOS_RAMP_STATE_RUNNING  2   // state 'running'
#define DF_INOS_RAMP_STATE_PULLING  3   // state 'pulling'
#define DF_INOS_RAMP_STATE_STOPPING 4   // state 'stopping'
//
// --- ramp errors -------------------------------------------------------------
//
#define ER_INOS_RAMP_POSRANGE   0x00000001          // position out of range
#define ER_INOS_RAMP_FAILED     0x00000002          // requested command failed
#define ER_INOS_RAMP_MIM_RANGE  0x00000004          // position out of range during mov in move
#define ER_INOS_RAMP_OVERSAMPLING 0x00000008        // number of samples was not a
                                                    // multiple of oversampling number
#define ER_INOS_RAMP_VMAX_REACHED 0x00000010        // allowed Vmax reached
#define ER_INOS_RAMP_MOVE_NOT_IN_CACHE 0x00000020   // trajectory was not in cache as expected
#define ER_INOS_RAMP_CORE_MISMATCH 0x00000040       // core mismatch
//
#define DF_INOS_RAMP_MAX_ERR    32          // max. number of errors
//
// --- ramp warnings -----------------------------------------------------------
//
#define WR_INOS_RAMP_MIM_DEC        0x00000001      // move in move during deceleration
#define WR_INOS_RAMP_CORE_MISMATCH  0x00000002      // core mismatch
//
// --- ramp flags --------------------------------------------------------------
//                       
#define DF_INOS_BASE_RAMP_FLAG_CHK_LIMITS   0x00000001  // check position limits
#define DF_INOS_BASE_RAMP_FLAG_ENB_BASE     0x00000002  // take base class geni
#define DF_INOS_BASE_RAMP_FLAG_ENB_TRQLIMIT 0x00000004  // enable torque limitation
#define DF_INOS_BASE_RAMP_FLAG_DIS_MIM      0x00000008  // disable 'move in move'
#define DF_INOS_BASE_RAMP_FLAG_LIMIT_MOVE   0x00000010  // limit move to min/max instead of range error
#define DF_INOS_BASE_RAMP_FLAG_DIS_MIM_DEC  0x00000020  // disable 'move in move' if axis is in deceleration already
#define DF_INOS_BASE_RAMP_FLAG_SET_CACHE_EPSILON 0x00000040 // set cache epsilon == ramp epsilon
#define DF_INOS_BASE_RAMP_FLAG_OPT_MIM      0x00000080  // enable optimized move in move handling
#define DF_INOS_BASE_RAMP_FLAG_CHK_LIMITS_IN_SEG 0x00000200 // check position limits within segments
#define DF_INOS_BASE_RAMP_FLAG_BACKLASH     0x00000400  // do backlash compensation
#define DF_INOS_BASE_RAMP_FLAG_FORCE_BACKLASH 0x00000800// do always a backlash move at target position
#define DF_INOS_BASE_RAMP_FLAG_IGNORE_LIMITS_AT_STOP 0x00001000// always ignore soft limits at stop
#define DF_INOS_BASE_RAMP_FLAG_LOOK_AHEAD   0x00002000  // enable look ahead (used e.g. for move in move on slow targets)
#define DF_INOS_BASE_RAMP_FLAG_CACHE_ONLY   0x00004000  // consume trajectory from ramp cache only. Reject move request with a failure in case of a cache miss
#define DF_INOS_BASE_RAMP_FLAG_IGNORE_VMAX  0x00008000  // ignore Vmax reached error (should only be used for testing purposes)
#define DF_INOS_BASE_RAMP_FLAG_IGNORE_JERK  0x00010000  // ignore cmdJ to speed up move calculation
#define DF_INOS_BASE_RAMP_FLAG_IGNORE_CORE  0x00020000  // ignore core mismatch failure (should only be used in desperate situations)
#define DF_INOS_BASE_RAMP_FLAG_NO_PULL_ADJ  0x00040000  // do not adjust pull positions
#define DF_INOS_BASE_RAMP_FLAG_OVRS_LAST    0x00800000  // restore last oversampled value
#define DF_INOS_BASE_RAMP_FLAG_SLOW_SPEED   0x01000000  // slowmotion is done with only speed reduction
#define DF_INOS_BASE_RAMP_FLAG_SHAPE_CALC   0x02000000  // internal flag used for shape calculation
#define DF_INOS_BASE_RAMP_FLAG_SETUPMODE    0x04000000  // setup mode active
#define DF_INOS_BASE_RAMP_FLAG_JOB_SLOW     0x08000000  // use job slowmotion in 'move in move'
#define DF_INOS_BASE_RAMP_FLAG_CACHE_FLUSH  0x10000000  // force a cache flush at next move
#define DF_INOS_BASE_RAMP_FLAG_CRS_PEACE    0x20000000  // geni requests peace during critical section
#define DF_INOS_BASE_RAMP_FLAG_CRS_ACTIVE   0x40000000  // critical section active
#define DF_INOS_BASE_RAMP_FLAG_ENABLED      0x80000000  // ramp geni is enabled
//
// no caching
#define DF_INOS_BASE_RAMP_FLAG_NO_CACHE     (DF_INOS_BASE_RAMP_FLAG_SETUPMODE|DF_INOS_BASE_RAMP_FLAG_BACKLASH)
//
// --- cache critical flags (changing them -> cache flush) ---------------------
//
#define DF_INOS_BASE_RAMP_FLAG_CACHE_CRITICAL \
    (DF_INOS_BASE_RAMP_FLAG_ENB_BASE | DF_INOS_BASE_RAMP_FLAG_ENB_TRQLIMIT | DF_INOS_BASE_RAMP_FLAG_CACHE_FLUSH)
//
// --- ramp options ------------------------------------------------------------
//
#define DF_INOS_BASE_RAMP_OPT_CHK_LIMITS    0x00000001
#define DF_INOS_BASE_RAMP_OPT_ENB_BASE      0x00000002
#define DF_INOS_BASE_RAMP_OPT_ENB_TRQLIMIT  0x00000004  // enable torque limitation
#define DF_INOS_BASE_RAMP_OPT_DIS_MIM       0x00000008
#define DF_INOS_BASE_RAMP_OPT_LIMIT_MOVE    0x00000010
#define DF_INOS_BASE_RAMP_OPT_DIS_MIM_DEC   0x00000020
#define DF_INOS_BASE_RAMP_OPT_OPT_MIM       0x00000080
#define DF_INOS_BASE_RAMP_OPT_TRQ_LIMIT     0x00000100
#define DF_INOS_BASE_RAMP_OPT_BACKLASH      0x00000400
#define DF_INOS_BASE_RAMP_OPT_FORCE_BACKLASH 0x00000800
#define DF_INOS_BASE_RAMP_OPT_IGNORE_LIMITS_AT_STOP 0x00001000
#define DF_INOS_BASE_RAMP_OPT_LOOK_AHEAD    0x00002000
#define DF_INOS_BASE_RAMP_OPT_IGNORE_VMAX   0x00008000
#define DF_INOS_BASE_RAMP_OPT_IGNORE_CORE   0x00020000
#define DF_INOS_BASE_RAMP_OPT_NO_PULL_ADJ   0x00040000
//
// --- ramp data flags ---------------------------------------------------------
//                       
#define DF_INOS_BASE_RAMP_DATA_FLAG_DEL     0x00000001  // structure has to be deleted
#define DF_INOS_BASE_RAMP_DATA_FLAG_LST     0x00000002  // last block in chain
//
// --- others ------------------------------------------------------------------
//
#define DF_INOS_RAMP_JERK_ALL   0xFFFFFFFF  // jerk number for all jerks
#ifdef INOS_SLOWMOTION_ZERO_SUPPORT
#define DF_INOS_RAMP_MIN_SLOW   REAL64(0.0000) // min. allowed slowmotion factor
#else
#define DF_INOS_RAMP_MIN_SLOW   REAL64(0.0001) // min. allowed slowmotion factor
#endif
#define DF_INOS_RAMP_MAX_SLOW   REAL64(2.0000) // max. allowed slowmotion factor
#define DF_INOS_RAMP_EPS_V_STOP REAL64(1.0e-6) // epsilon value used to determine when a velocity reaches zero during a stop
//
// --- max. velocity flags -----------------------------------------------------
//
enum {
    eMaxVelocityNone = 0x00000000,
    eMaxVelocityIgnoreSetup = 0x00000001,
    eMaxVelocityIgnoreSLS = 0x00000002,
};
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#ifdef INOS_RAMP_DLL
#include <_inos.h>
#else
#include <inos.h>
#endif
#ifdef INOS_SAFETY_SUPPORT
#include <cinossafetyconfig.h>
#endif
//
// C++
//
// project
//
//------------------------------------------------------------------------------
//--- structures ---------------------------------------------------------------
//------------------------------------------------------------------------------
//
struct SINOSBaseRamp
{
    inosName64 m_cName;
 
    inosName m_cUnit;
 
    real64 m_rCycleTime;
 
    real64 m_rScmd;
 
    real64 m_rVcmd;
 
    real64 m_rAcmd;
 
    real64 m_rBcmd;
 
    real64 m_rCcmd;
 
    real64 m_rJcmd;
 
    real64 m_rJbcmd;
 
    real64 m_rJm1cmd;
 
    real64 m_rJm2cmd;
 
    real64 m_rJecmd;
 
    real64 m_rBemg;
 
    real64 m_rJemg;
 
    real64 m_rJeemg;
 
    real64 m_rSmin;
 
    real64 m_rSmax;
 
    real64 m_rVmin;
 
    real64 m_rVmax;
 
    real64 m_rVmaxSetup;
 
    real64 m_rVmaxInit;
 
    real64 m_rVtrq;
 
    real64 m_rAmin;
 
    real64 m_rAmax;
 
    real64 m_rAmaxPull;
 
    real64 m_rArms;
 
    real64 m_rAtrq;
 
    real64 m_rBmin;
 
    real64 m_rBmax;
 
    real64 m_rBtrq;
 
    real64 m_rCmin;
 
    real64 m_rCmax;
 
    real64 m_rJmin;
 
    real64 m_rJmax;
 
    real64 m_rMiMTol;
 
    real64 m_rBacklash;
 
    real64 m_rBacklashSlowmotion;
 
    real64 m_rSLSValue;
 
    real64 m_rSLSJerk;
 
    uint32 m_uOptions;
 
    uint8 m_uDigits;
 
    uint8 m_uCacheSize;
 
    uint8 m_uSLSType;
 
    uint8 m_uInternal0[1];
 
    // constructor
    SINOSBaseRamp();
};
  
// generic param extension
#if defined(INOS_AXIS_EXTENSION_SUPPORT)
struct SINOSParamSetExtension
{
    uint32 m_uId;
    char m_cName[32];
    SINOSParamSetExtension* m_pNext;
 
    SINOSParamSetExtension(uint32 auId, const char* apName)
        : m_uId(auId), m_cName{0}, m_pNext(0)
        { inos_strncpy(m_cName, apName, sizeof(m_cName));};
    virtual ~SINOSParamSetExtension(){};
 
    uint32 GetId() const
        { return m_uId; };
    const char* GetName() const
        { return &m_cName[0]; };
    virtual SINOSParamSetExtension& operator=(const SINOSParamSetExtension& src)
    {
        // we do not need to copy anything, because this operator is only called
        // if id and name are already equal, see SINOSRampParam::CloneExtensions in
        // cinosbaseramp.cpp
        return *this;
    }
    virtual SINOSParamSetExtension* Clone() = 0;
    virtual CINCOObject* CreateInco() = 0;
 
    // dynamic object
    DECLARE_DYNAMIC(SINOSParamSetExtension);
};
#endif
 
struct SINOSRampParam
{       
        // ramp param flags
        enum {
            eFlgFix = 0x00000001,       // speed set is fixed (ignore slowmotion, ...)
            eFlgOk  = 0x00000002,       // speed set is ok checked already
            eFlgTim = 0x00000004,       // required time for the move is m_rTime [sec]
            eFlgP5  = 0x00000008,       // use a P5 for the move
            eFlgWindow = 0x00000010,    // use position type 'window'
            eFlgWindowOpt = 0x00000020, // use position type 'windowopt'
            eFlgEco = 0x00000040,       // use a ecological params
            eFlgAwayLight = 0x00000080, // move with disabled torque limitation
                                        // and jerks = 0.0 at move away from border to speed up calculation
            eFlgIgnoreLimits = 0x00000100,  // ignore position limits
            eFlgTriggerReduced = 0x00000200,// MoveEx trigger only active with reduced speed
            eFlgIgnoreCache = 0x00000400,// ignore ramp cache. useful to avoid interference between concurrent calculation and move calls.
            eFlgTemporary = 0x80000000, // temporary structure
        };
        real64 m_rVcmd;
        real64 m_rAcmd;
        real64 m_rBcmd;
        real64 m_rCcmd;
        real64 m_rJcmd[DF_INOS_RAMP_MAX_JERK];
        real64 m_rJCcmd;
        real64 m_rTime;
        real64 m_rSlow;
        uint32 m_uFlags = 0;
        void SetTemporary()
            { m_uFlags |= eFlgTemporary; }
        bool GetTemporary()
            { return (m_uFlags & eFlgTemporary)!=0; }
        void SetIgnoreCache()
            { m_uFlags |= eFlgIgnoreCache; }
        void ClrIgnoreCache()
            { m_uFlags &= ~eFlgIgnoreCache; }
        bool GetIgnoreCache()
            { return (m_uFlags & eFlgIgnoreCache)!=0; }
        #if !defined(INOS_AXIS_EXTENSION_SUPPORT)
        uint32 m_uDummy;
        #else
        struct SINOSParamSetExtension* m_pExtension;
        SINOSRampParam();
        SINOSRampParam(const SINOSRampParam& aParam);
        ~SINOSRampParam();
        // assignment operator
        SINOSRampParam& operator= (const SINOSRampParam& src);
        void Copy(const SINOSRampParam& src);
        void DestroyExtensions();
        void CloneExtensions(const SINOSRampParam& src);
        void AddExtension(SINOSParamSetExtension* apExtension);
        void RemoveExtension(const char* apName);
        SINOSParamSetExtension* GetExtension(uint32 auId)
        {
            // search
            SINOSParamSetExtension* ext = m_pExtension;
            while (ext){
                // found ?
                if (ext->m_uId == auId) {
                    // found
                    return ext;
                } // end if
                ext = ext->m_pNext;
            }
            // not found
            return 0;
        }
        #endif
        
        DECLARE_DYNAMIC(SINOSRampParam);
};
 
struct SINOSRampData
{       
        real64 m_rS;
        real64 m_rV;
        real64 m_rA;
        real64 m_rJ;
        // allow new/delete     
        DECLARE_DYNAMIC(SINOSRampData);
};
 
struct SINOSRampDataEx : public SINOSRampData
{       
        uint32 m_uFlags;
        SINOSRampDataEx* m_pNext;
        // allow new/delete     
        DECLARE_DYNAMIC(SINOSRampDataEx);
};
 
typedef struct{
    real64 m_rAccelerationTime;
    real64 m_rMoveTime;
    real64 m_rConstTime;
    real64 m_rDecelerationTime;
} SINOSTimeCharacteristics;
 
struct SINOSBaseRampTrqLimitPoint
{
    inosName32 m_cName;
    uint32 m_uNumber;
    uint32 m_uDummy;
    real64 m_rV;
    real64 m_rA;
};
 
struct SINOSBaseRampTrqLimitPointAcc : public SINOSBaseRampTrqLimitPoint
{
};
 
struct SINOSBaseRampTrqLimitPointDec : public SINOSBaseRampTrqLimitPoint
{
};
 
struct SINOSBaseRampTrqLimit
{
    uint32 m_uNumber;
    uint32 m_uDummy;
    real64* m_rV;
    real64* m_rA;
 
    explicit SINOSBaseRampTrqLimit(uint32 auNumber = 0);
    SINOSBaseRampTrqLimit(const SINOSBaseRampTrqLimit& aLimit);
    ~SINOSBaseRampTrqLimit();
 
    bool operator ==(const SINOSBaseRampTrqLimit &b) const
        {
            if (m_uNumber != b.m_uNumber) return false;
            for (uint32 i=0; i<m_uNumber; i++){
                if (m_rV[i] != b.m_rV[i]) return false;
                if (m_rA[i] != b.m_rA[i]) return false;
            }
            return true;
        }
};
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSBaseRamp;
#ifndef INOS_RAMP_DLL
class CINOSBaseRampParamSet
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        #if defined(INOS_AXIS_EXTENSION_SUPPORT)
        void AddExtension(SINOSParamSetExtension* apExtension);
        void RemoveExtension(const char* apName);
        #endif
 
        virtual CINCOObject* GetRegister(CINOSBaseRamp* apRamp);
 
    //--- internals --------------------------------------------------------
 
    // public but just for internal use
    public:
        explicit CINOSBaseRampParamSet(SINOSRampParam* apParam = 0);
            //; constructor
        CINOSBaseRampParamSet(const CINOSBaseRampParamSet& aOther);
            //; copy constructor. Note: m_pRegister will not be copied,
            //; it'll be initialized to NULL.
        CINOSBaseRampParamSet& operator=(
                const CINOSBaseRampParamSet& aOther);
            //; assignment operator. Note that this function does not alter
            //; m_pRegister!
        virtual ~CINOSBaseRampParamSet();
            //; destructor
        SINOSRampParam m_Param{};
            //; ramp params
        CINCOObject* m_pRegister;
            //; pointer to inco registration of set
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSBaseRampParamSet);
};
#endif
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSRampJob;
class CINOSRampJobPart;
class CINOSRampCache;
class CINOSRampSeg;
class CINOSRampSegTra;
class CINOSRampSegCns;
class CINOSRampSegPos;
class CINOSMapping;
class CINOSBus;
class CINOSBaseRamp
{
    //--- user interface ---------------------------------------------------
 
    public:
 
        // constructor/destructor
 
        explicit CINOSBaseRamp(SINOSBaseRamp* apDesc);
            //; constructor
        virtual ~CINOSBaseRamp();
            //; destructor
        const char* GetName();
            //; get axis generator name
        const char* GetType();
            //; get ramp generator type
        static uint32 GetVersion();
            //; get ramp generator version
        #ifndef INOS_RAMP_DLL
        static CINOSBaseRamp* GetRamp(const char* apAxisName, const char* apRampType);
            //; create ramp and return pointer to it (gets ramp properties from
            //; database table
        static CINOSBaseRamp* GetRamp(const char* apType);
            //; create ramp of type 'apType' return pointer to it or NULL if 'apType'
            //; not available
        #endif
        
        enum EMoveFlags{
            eFlgMoveNone= 0x00000000,
            eFlgMoveWithoutDec1 = 0x00000001,
            eFlgMoveWithoutDec2 = 0x00000002,
            eFlgMoveWithoutDec3 = 0x00000004
        };
 
        // moving functions
 
        virtual bool Move(real64 arPosition, SINOSRampParam* apParam = 0);
            //; move to position with apParam values or actual commanded values if
            //; apParam = 0 and return true if move was really started and false
            //; if move was not started for some reason (e.g. nothing to move or
            //; position range error)
        virtual bool Move(real64 arPosition, real64 arSave1, real64 arSave2,
            real64& arTime, SINOSRampParam* apParam1 = 0, SINOSRampParam* apParam2 = 0);
            //; move to arPosition with apParam values in considering arSave1
            //; and arSave2
        virtual bool MoveApp(real64 arPosition, real64 arPositionVel, real64 arVelocity,
            SINOSRampParam* apParam = 0, EMoveFlags aeFlags = eFlgMoveNone);
            //; move to position with apParam, ensure after arPositionVel a 
            //; velocity that is smaller than or equal to arVelocity
        virtual bool MoveDep(real64 arPosition, real64 arPositionVel, real64 arVelocity,
            SINOSRampParam* apParam = 0);
            //; move to position with apParam, ensure before arPositionVel a 
            //; velocity that is smaller than or equal to arVelocity
        virtual bool Endless(bool abPositive = true, SINOSRampParam* apParam = 0);
            //; start an endless move in the requested direction and return true
            //; if really started
        virtual bool Update(SINOSRampParam* apParam = 0);
            //; update a running Move to apParam values or actual commanded values
            //; if apParam = 0
 
 
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arPosition, real64 arDelta,
                SINOSRampParam* apParam);
        virtual SINOSTimeCharacteristics GetTimeCharacteristics(real64 arStartPosition, real64 arEndPosition,
                real64 arDelta, SINOSRampParam* apParam);
 
 
        virtual real64 GetMoveTime(real64 arPosition, real64 arDelta = REAL64(0.0),
            SINOSRampParam* apParam = 0);
            //; return time [sec] a Move(adPosition) needs until arPosition-arDelta
        virtual real64 GetAccelerationTime(real64 arPosition, real64 arDelta = REAL64(0.0),
            SINOSRampParam* apParam = 0);
            //; return time [sec] a Move(adPosition) needs for the acceleration part
        virtual real64 GetConstTime(real64 arPosition, real64 arDelta = REAL64(0.0),
            SINOSRampParam* apParam = 0);
            //; return time [sec] a Move(adPosition) needs for the const part
        virtual real64 GetDecelerationTime(real64 arPosition, real64 arDelta = REAL64(0.0),
            SINOSRampParam* apParam = 0);
            //; return time [sec] a Move(adPosition) needs for the deceleration part
 
        virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam = 0);
            //; return time [sec] a Move needs from arStartPosition
            //; until arEndPosition-arDelta
        virtual real64 GetAccelerationTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam = 0);
            //; return time [sec] a Move needs for the acceleration part
        virtual real64 GetConstTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam = 0);
            //; return time [sec] a Move needs for the const part
        virtual real64 GetDecelerationTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, SINOSRampParam* apParam = 0);
            //; return time [sec] a Move needs for the deceleration part
 
        virtual real64 GetMoveTime(real64 arStartPosition, real64 arEndPosition,
            real64 arDelta, real64& arDeltaTime, SINOSRampParam* apParam = 0);
            //; return time [sec] a Move needs from arStartPosition
            //; until arEndPosition-arDelta
 
        virtual real64 GetMoveAppTime(real64 arPosition, real64 arPositionVel, 
            real64 arVelocity, real64 arDelta = REAL64(0.0), SINOSRampParam* apParam = 0);
            //; return time [sec] an according MoveApp needs
        virtual real64 GetMoveAppTime(real64 arStartPosition, real64 arEndPosition,
            real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam* apParam = 0);
            //; return time [sec] an according MoveApp needs
        virtual real64 GetMoveDepTime(real64 arPosition, real64 arPositionVel, 
            real64 arVelocity, real64 arDelta = REAL64(0.0), SINOSRampParam* apParam = 0);
            //; return time [sec] an according MoveDep needs
        virtual real64 GetMoveDepTime(real64 arStartPosition, real64 arEndPosition,
            real64 arPositionVel, real64 arVelocity, real64 arDelta, SINOSRampParam* apParam = 0);
            //; return time [sec] an according MoveDep needs
        virtual real64 GetMoveDist(real64 arTime, SINOSRampParam* apParam = 0);
            //; return distance [unit] a Move progresses in arTime [sec]
        virtual real64 GetMoveDist(real64 arPosition, real64 arTime,
            SINOSRampParam* apParam = 0);
            //; return distance [unit] a Move(arPosition) progresses in arTime [sec]
        virtual real64 GetMoveDist(real64 arStartPosition, real64 arEndPosition,
            real64 arTime, SINOSRampParam* apParam = 0);
            //; return distance [unit] a Move from arStartPosition to arEndPosition
            //; progresses in arTime [sec]
        virtual uint64 GetStartTicks(real64 arDelta);
            //; return absolut bus ticks the actual move reaches the start + arDelta
        virtual uint64 GetTargetTicks()
            //; return absolut bus ticks the actual move reaches the target
            { return inos_atomic_gettickcount(&m_uTargetTicks);};
        virtual uint64 GetTargetTicks(real64 arDelta);
            //; return absolut bus ticks the actual move reaches the target - arDelta
 
        // segmentation moving functions
 
        virtual uint32 SegBegin(real64 arSlowMotion = REAL64(1.0), real64 arStartVelocity = REAL64(0.0));
            //; start new segmentation move
        virtual uint32 SegBegin(real64 arSlowMotion, real64 arStartPosition, real64 arStartVelocity);
            //; start new segmentation move
        virtual uint32 SegMove(real64 arPosition, real64 arVelocity = REAL64(0.0), 
            SINOSRampParam* apParam = 0, real64 arAcceleration = REAL64(0.0), real64 arDuration = REAL64(-1.0));
            //; move to 'arPosition', the velocity in 'arPosition' has to be 
            //; 'arVelocity' and the acceleration arAcceleration.
            //; The duration (tim can be stretched by arDuration != -1.0
            //; The base implementation only supports = -1.0
        virtual uint32 SegMoveResult()
            //; get result of last seg move
            { return m_eSegMoveResult;};
        virtual uint32 SegConst(real64 arPosition);
            //; move to 'arPosition' with the actual velocity
        virtual uint32 SegPos(real64 arTime);
            //; stay at 'arPosition' for arTime
        virtual uint32 SegPosSetTime(real64 arTime);
            //; set the requested time of a previous added pos segment
        virtual uint32 SegVelocity(real64 arVelocity, SINOSRampParam* apParam = 0);
            //; stay at 'arPosition' for arTime
        virtual real64 SegTime(bool abRoundedtoCycleTime=true);
            //; return time [sec] the actual SegMove needs already
        virtual uint32 GetSegEnd (real64& arS);
        //; seg job must fit into cycle
        virtual void SegJobMustFitInCycle (bool abMustFitInCycle);
        //; get the end position of the segment
        virtual uint32 SegRun();
            //; run actual segmentation move
        virtual CINOSRampJob* GetSegJob()
            { return m_pSegJob;};
 
        // pulling methods
        
        virtual void Pull(real64 arS, real64 arV, real64 arA, real64 arJ);
            //; add s, v, a, j to the actual pull list (starts pull if not yet done)
        virtual void Pull(SINOSRampData& aData);
            //; add aData to the actual pull list (starts pull if not yet done)
        virtual void Pull(SINOSRampDataEx* apData);
            //; add apData to the actual pull list (starts pull if not yet done)
            //; apData IS deleted after processed
            //; \note Be aware of the following: If an axis is in 'pulling' state
            //;  and the axis was not 'running' before (i.e. m_uNxtState is 'READY')
            //;  if FlushPull() is called, the ramp state will become 'READY'/'PEACE' 
            //;  during the next call to GetData(). Be aware that, if after calling this
            //;  function, a task switch happens that cause the fieldbus task
            //;  calling GetData(), that function will immediately return
            //;  V,A,J = 0.0 - without properly ramping down these properties. 
            //;  Among others, when this happens, calling EmergencyStop afterwards 
            //;  doesn't do anything, because the ramp state is already 'READY'/'PEACE'.
        virtual void FlushPull();
            //; flush actual pending pull list
        void Enable();
            //; enable pull mode
        void Disable()
            //; disable pull mode (needed to be able to fill up pull list without
            //; starting immediately)
            { ClrFlag(DF_INOS_BASE_RAMP_FLAG_ENABLED);};
 
        // stop/break/continue functions
 
        virtual bool Stop(SINOSRampParam* apParam = 0);
            //; stop move with acc/deceleration
        virtual bool StopLive(real64 arSlowMotion = 1.0, SINOSRampParam* apParam = 0);
            //; live stop move with acc/deceleration
        virtual bool StopLiveDelta(real64 arDelta, real64 arSlowMotion = 1.0, SINOSRampParam* apParam = 0);
            //; live stop move with acc/deceleration, the move should be stopped 'arDelta' after current position
        virtual bool Stop(real64 arPosition, SINOSRampParam* apParam = 0);
            //; stop move with acc/deceleration at adPosition
        virtual bool Break(SINOSRampParam* apParam = 0);
            //; break move with acc/deceleration (move still pending)
        virtual bool BreakLive(SINOSRampParam* apParam = 0);
            //; live break move with acc/deceleration (move still pending)
        virtual bool Break(real64 arPosition, SINOSRampParam* apParam = 0);
            //; break move with acc/deceleration at adPosition (move still 
            //; pending)
        virtual bool EmergencyStop();
        virtual bool EmergencyStop(SINOSRampParam* apParam);
        virtual bool EmergencyStop(real64 arPosition, SINOSRampParam* apParam, bool abPosValid = true);
            //; emergency stop as quick as possible
        virtual void EmergencyStopLive();
        virtual void EmergencyStopLive(SINOSRampParam* apParam);
            //; emergency stop as quick as possible (do the calculation live)
        virtual bool Continue(SINOSRampParam* apParam = 0);
            //; continue paused move 
 
        // set/get property functions
        
        enum ECmdFlags{
            eFlgCmdNone = 0x00000000,
            eFlgCmdPeak = 0x00000001
        };
 
        virtual void SetCmdFlags(uint32 auFlags);
            //; set commanded flags
        ICACHE virtual void SetCmdPosition(real64 arPosition);
            //; set commanded axis position
        ICACHE virtual void GetCmdPosition(real64& arPosition);
            //; get commanded axis position
        virtual void SetCmdVelocity(real64 arVelocity);
            //; set commanded velocity
        virtual void GetCmdVelocity(real64& arVelocity, ECmdFlags aeFlags = eFlgCmdNone);
            //; get commanded velocity
        virtual void SetCmdAcceleration(real64 arAcceleration);
            //; set commanded acceleration
        virtual void GetCmdAcceleration(real64& arAcceleration, ECmdFlags aeFlags = eFlgCmdNone);
            //; get commanded acceleration
        virtual void SetCmdDeceleration(real64 arDeceleration);
            //; set commanded deceleration       
        virtual void GetCmdDeceleration(real64& arDeceleration, ECmdFlags aeFlags = eFlgCmdNone);
            //; get commanded deceleration
        virtual void SetCmdCruiseleration(real64 arCruiseleration);
            //; set commanded cruiseleration         
        virtual void GetCmdCruiseleration(real64& arCruiseleration);
            //; get commanded cruiseleration
        virtual void SetCmdJerk(real64 arJerk, uint32 auNumber = DF_INOS_RAMP_JERK_ALL);
            //; set commanded jerk
        virtual void GetCmdJerk(real64& arJerk, uint32 auNumber = 0);
            //; get commanded jerk
        virtual void SetCmdCruiseJerk(real64 arCruiseJerk);
            //; set commanded cruise jerk
        virtual void GetCmdCruiseJerk(real64& arCruiseJerk);
            //; get commanded jerk
        virtual void GetCmdRealJerk(real64& arJerk, uint32 auNumber = 0);
            //; get commanded real jerk and update a running move if requested
        virtual void SetCmdSlowMotion(real64 arSlowMotion, bool abUpdate = false);
            //; set commanded slowmotion factor
        virtual void SetCmdSlowMotion(real64 arSlowMotion, bool abUpdate, bool abStopping);
            //; set commanded slowmotion factor
        virtual void GetCmdSlowMotion(real64& arSlowMotion, SINOSRampParam* apParam = 0);
            //; get commanded slowmotion factor
        virtual void GetActSlowMotion(real64& arSlowMotion, SINOSRampParam* apParam = 0);
            //; get actual slowmotion factor (slowmotion>slowmotionmax?slowmotionmax : slowmotion)
        #ifdef INOS_SAFETY_SUPPORT
        virtual void GetSafetySlowMotion(real64& arSlowMotion, SINOSRampParam* apParam = 0);
            //; get safety slowmotion factor
        #endif
        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
        virtual void SetEmgJerk(real64 arJerk);
            //; set commanded emergency jerk         
        virtual void SetEmgJerk(real64 arJerk, real64 arJerkEnd);
            //; set commanded emergency jerk
        virtual void GetEmgJerk(real64& arJerk);
            //; get commanded emergency jerk
        virtual void GetEmgJerk(real64& arJerk, real64& arJerkEnd);
            //; get commanded emergency jerk
        virtual void SetCmdParam(SINOSRampParam* apParam)
            { *m_pParam = *apParam; };
            //; get pointer to commanded parameters
        virtual SINOSRampParam* GetCmdParam()
            { return m_pParam; };
            //; get pointer to commanded parameters
        ICACHE virtual void SetActPosition(real64 arPosition);
            //; set actual axis position
        ICACHE virtual void AdjActPosition(real64 arPosition);
            //; adjust actual axis position
        ICACHE virtual void GetActPosition(real64& arPosition);
            //; get actual axis position
        ICACHE virtual void GetActPosition(real64& arPosition, uint64 auTicks);
            //; get actual axis position
        virtual void GetPullAdjPosition(real64& arPosition);
            //; get actual position adjust used in pull mode
        virtual void GetStopPosition(real64& arPosition, SINOSRampParam* apParam);
            //; get axis position if we would stop a running move
        virtual void GetBgnPosition(real64& arPosition)
            { arPosition = m_rSbgn;};
            //; get position the actual/last move/endless was started from
        virtual void SetActVelocity(real64 arVelocity);
            //; set actual velocity
        virtual void GetActVelocity(real64& arVelocity);
            //; get actual velocity
        virtual void SetActAcceleration(real64 arAcceleration);
            //; set actual acceleration
        virtual void GetActAcceleration(real64& arAcceleration);
            //; get actual acceleration
        virtual void SetActJerk(real64 arJerk);
            //; set actual jerk
        virtual void GetActJerk(real64& arJerk);
            //; get actual jerk
        virtual void SetAct(SINOSRampData& aAct);
            //; set actuals
        virtual void GetActSVAJ(SINOSRampData& arData, bool abIrqSafe = true);
            //; get all actuals
        virtual void AdjActTime(real64 arDelta);
            //; adjust actual move time
        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 SetMaxVelocity(real64 arVelocity);
            //; set max. allowed velocity
        virtual void GetMaxVelocity(real64& arVelocity, uint32 auFlags = eMaxVelocityNone);
            //; get max. allowed velocity
        virtual void SetMaxSetupVelocity(real64 arVelocity);
            //; set max. allowed velocity in setup mode
        virtual void GetMaxSetupVelocity(real64& arVelocity);
            //; get max. allowed velocity in setup mode
        virtual void SetMaxInitVelocity(real64 arVelocity);
            //; set max. allowed velocity during initialization  
        virtual void GetMaxInitVelocity(real64& arVelocity);
            //; get max. allowed velocity during initialization
        virtual void SetMinVelocity(real64 arVelocity);
            //; set min. allowed velocity
        virtual void GetMinVelocity(real64& arVelocity);
            //; get min. allowed velocity
        virtual void SetTrqVelocity(real64 arVelocity);
            //; set torque velocity
        virtual void GetTrqVelocity(real64& arVelocity);
            //; get torque velocity
        virtual void AdjustMinMaxValues (real64 arFactor);
            //; adjust min max values
        virtual void SetMinAcceleration(real64 arAcceleration);
            //; set min. allowed acceleration
        virtual void GetMinAcceleration(real64& arAcceleration);
            //; get min. allowed acceleration
        virtual void SetMaxAcceleration(real64 arAcceleration);
            //; set max. allowed acceleration
        virtual void GetMaxAcceleration(real64& arAcceleration);
            //; get max. allowed acceleration
        virtual void SetMaxAccelerationPull(real64 arAcceleration);
            //; set max. allowed acceleration during pull
        virtual void GetMaxAccelerationPull(real64& arAcceleration);
            //; get max. allowed acceleration during pull
        virtual void SetTrqAcceleration(real64 arAcceleration);
            //; set torque acceleration
        virtual void GetTrqAcceleration(real64& arAcceleration);
            //; get torque acceleration
        virtual void SetMinDeceleration(real64 arDeceleration);
            //; set min. allowed deceleration
        virtual void GetMinDeceleration(real64& arDeceleration);
            //; get min. allowed deceleration
        virtual void SetMaxDeceleration(real64 arDeceleration);
            //; set max. allowed deceleration
        virtual void GetMaxDeceleration(real64& arDeceleration);
            //; get max. allowed deceleration
        virtual void SetTrqDeceleration(real64 arDeceleration);
            //; set torque deceleration
        virtual void GetTrqDeceleration(real64& arDeceleration);
            //; get torque deceleration
        virtual void SetMinCruiseleration(real64 arCruiseleration);
            //; set min. allowed cruiseleration
        virtual void GetMinCruiseleration(real64& arCruiseleration);
            //; get min. allowed cruiseleration
        virtual void SetMaxCruiseleration(real64 arCruiseleration);
            //; set max. allowed cruiseleration
        virtual void GetMaxCruiseleration(real64& arCruiseleration);
            //; get max. allowed cruiseleration
        virtual void SetMinJerk(real64 arJerk);
            //; set min. allowed jerk
        virtual void GetMinJerk(real64& arJerk);
            //; get min. allowed jerk
        virtual void SetMaxJerk(real64 arJerk);
            //; set max. allowed jerk
        virtual void GetMaxJerk(real64& arJerk);
            //; get max. allowed jerk
 
        virtual void GetCycleTime(real64& arCycleTime);
            //; get ramp cycle time
        virtual void SetCycleTime(real64 arCycleTime);
        //; set ramp cycle time
        virtual uint8 GetOversampling();
            //; get oversampling factor
        virtual void SetOversampling(uint8 auOversampling);
            //; set oversampling factor
        virtual void GetCycleTimeUs(uint32& auCycleTime)
            { auCycleTime = m_uCycleTimeUs;}; 
            //; get ramp cycle time
        virtual void GetCycleTimeNs(uint32& auCycleTime)
            { auCycleTime = m_uCycleTimeNs;}; 
            //; get ramp cycle time
        virtual const char* GetUnit();
            //; get ramping base unit (e.g. mm, deg, ...)
        virtual void SetUnit(const char* apUnit);
            //; get ramping base unit (e.g. mm, deg, ...)
        #ifndef INOS_RAMP_DLL
        virtual uint32 GetCharacteristics();
            //; get ramping base unit inco characteristics
        virtual void SetCharacteristics(uint32 auCharacteristics);
            //; get ramping base unit inco characteristics
        virtual uint8 GetTypeChar() {return m_uTypeChar;};
            //; get type character, e.g. 'T' for temperature ramp
        virtual void SetTypeChar(uint8 auTypeChar) {m_uTypeChar = auTypeChar;};
            //; set type character, e.g. 'T' for temperature ramp
        virtual uint32 GetParam(const char* apName, real64& arResult);
            //; universal get parameter with apName to arResult and return error code
        virtual volatile real64* GetParamAdr(const char* apName);
            //; universal get address of parameter with aName or NULL if not found
        virtual uint32 SetParam(const char* apName, real64 arValue);
            //; universal set parameter with apName to arValue and return error code
        #endif
                    
        void SetFlag(uint32 auFlag)
            { INOS_OR(m_uFlag, auFlag);};
            //; set ramp flags
        void ClrFlag(uint32 auFlag)
            { INOS_AND(m_uFlag, ~auFlag);};
            //; clear ramp flags
        uint32 GetFlag()
            { return m_uFlag & m_uFlagEnb;};
            //; get ramp flags
        void EnbFlag(uint32 auFlag)
            { INOS_OR(m_uFlagEnb, auFlag);};
            //; set ramp flags
        void DisFlag(uint32 auFlag)
            { INOS_AND(m_uFlagEnb, ~auFlag);};
 
        ICACHE void SetState(uint32 auState)
            {
                // set new state
                m_uState = auState;
                // state peace ?
                if (m_uState == DF_INOS_RAMP_STATE_PEACE) {
                    // yes -> clear also m_pActParam to prevent e.g.
                    // following Pulls from inheriting speed set properties
                    // like input shaping or others
                    m_pActParam = nullptr;
                } // end if
            };
            //; set ramp state
        ICACHE uint32 GetState()
            { return m_uState;};
            //; get ramp state
        virtual uint32 GetError();
            //; get ramp error
        virtual uint64 GetErrorEx();
            //; get ramp error
        virtual uint32 GetWarning();
            //; get ramp warning
        virtual uint64 GetWarningEx();
            //; get ramp warning
        virtual void AcceptError(uint32 auError=0xffffffff);
            //; accept ramp error (auError=0xffffffff -> accept all errors)
        virtual void AcceptWarning(uint32 auWarning=0xffffffff);
            //; accept ramp warning (auWarning=0xffffffff -> accept all warnings)
 
        ICACHE virtual void GetS(real64& arS);
            //; get actual S
        ICACHE virtual void GetSV(real64& arS, real64& arV);
            //; get actual S and V
        ICACHE virtual void GetSVA(real64& arS, real64& arV, real64& arA);
            //; get actual S, V and A
        ICACHE virtual void GetSVAJ(real64& arS, real64& arV, real64& arA, real64& arJ);
            //; get actual S, V, A and J
        ICACHE virtual SINOSRampDataEx* GetData();
            //; get actual S, V, A and J
        virtual void GetData (SINOSRampDataEx* apData, bool abSingleSample=false);
 
        // param set functions
        #ifndef INOS_RAMP_DLL
        virtual CINOSBaseRampParamSet* CloneParamSet();
            //; return a copy of the actual param set
        virtual void SelectParamSet(CINOSBaseRampParamSet* apSet);
            //; set actual param set to apSet
        virtual void PreDestroyRampParam(SINOSRampParam* apParam);
            //; use this method to inform geni, that we're about to destroy a previously
            //; used speed set
        #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 moving cache
        void SetEpsilon(real64 arEpsilon);
            //; set new internal 'epsilon' (standard is = 0.0)
        void GetEpsilon(real64& arEpsilon)
            {arEpsilon = m_rEpsilon;};
            //; get internal 'epsilon'
        void SetCacheEpsilon(real64 arEpsilon);
            //; set new cache 'epsilon' (standard is = 0.0)
 
        // miscellaneous functions
 
        virtual CINOSBaseRamp* Clone();
            //; clone myself and return pointer to it
        #ifndef INOS_RAMP_DLL
        SINOSBaseRamp* GetRampDesc()
            { return m_pDesc;};
            //; return pointer to my ramp descritpor
        virtual CINCOObject* GetRegister(const char* apName = "Ramp");
            //; return pointer to my inco object
        void RegisterFlags(CINCOObject* apParent, uint32* auBase);
            //; register flags, used for real flags and flags enable.
        virtual CINCOObject* GetParamSetRegister(CINOSBaseRampParamSet* apSet);
            //; create registration for apSet and return pointer to it
        static CINCOObject* GetBaseParamSetRegister(CINOSBaseRampParamSet* apSet);
            //; create registration for apSet and return pointer to it
        #endif
 
        // 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
 
        // mapping
 
        void SetMapping(CINOSMapping* apMapping, uint32 auIndex)
            { m_pMapping = apMapping; m_uMappingIndex = auIndex;};
            //; set actual axis mapping
        void ResetMapping()
            { m_pMapping = 0; m_uMappingIndex = 0;};
            //; reset actual axis mapping
 
        // setup mode
        
        void EnableSetupMode();
            //; enable setup mode
        void DisableSetupMode();
            //; disable setup mode
        bool CheckSetupMode();
            //; return true if setup mode active and fullfilled
 
        bool CheckPullUnderrun()
        {
            // locals
            real64 rAmax;
            // decide witch Amax to take
            if (m_rAmaxPull != REAL64(0.0))
                rAmax = m_rAmaxPull;
            else
                rAmax = m_rAmax;
            // max. allowed rest V = Amax * cycletime
            real64 rVzero = rAmax * m_rCycleTime;
            // underrun if no data and V!= 0.0
            return (m_pFstData == 0) && ((m_Act->m_rV > rVzero) || (m_Act->m_rV < -rVzero));
        }
 
        // torque limitation
 
        void SetTrqLimitAcceleration(SINOSBaseRampTrqLimit* apLimit)
            { m_pTrqLimitAcc = apLimit; };
        SINOSBaseRampTrqLimit* GetTrqLimitAcceleration()
            { return m_pTrqLimitAcc; };
        void SetTrqLimitDeceleration(SINOSBaseRampTrqLimit* apLimit)
            { m_pTrqLimitDec = apLimit; };
        SINOSBaseRampTrqLimit* GetTrqLimitDeceleration()
            { return m_pTrqLimitDec; };
 
        void UpdateTrqLimit();
 
        // multi core
 
        uint8 GetCoreId()
            { return m_uCoreId; };
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSMapping;
    friend class CINOSShape;
    friend class CINOSBaseAxis;
    friend class CINOSPhysicalAxis;
    friend class CINOSBaseRampTest;
    friend class CINOSMcRobotCmdLinear;
    friend class CINOSRemoteControlWorker;
    friend void _INI_0400_CINOSBaseRamp();
    
    // public member methods but just for internal use
    public :
        virtual const char* GetStateText();
            //; get pointer to actual state text
        virtual CINOSRampJob* iMove(real64 arSbgn, real64 arSend, bool abReturnError,
            SINOSRampParam* apParam);
            //; create a move job from arSbgn to arSend with apParam parameters
        virtual CINOSRampJob* iMove(real64 arPosition, real64 arSave1, real64 arSave2,
            real64& arTime, SINOSRampParam* apParam1, SINOSRampParam* apParam2);
            //; create a move job from arSbgn to arSend with apParam parameters
        virtual CINOSRampJob* iMoveApp(real64 arSbgn, real64 arSend, real64 arSvel,
            real64 arVelocity, bool abReturnError, SINOSRampParam* apParam, EMoveFlags aeFlags);
            //; create a move job from arSbgn to arSend with apParam parameters
        virtual CINOSRampJob* iMoveDep(real64 arSbgn, real64 arSend, real64 arSvel,
            real64 arVelocity, bool abReturnError, SINOSRampParam* apParam);
            //; create a move job from arSbgn to arSend with apParam parameters
        virtual SINOSRampParam* CheckParam(SINOSRampParam* apOrgParam, 
            SINOSRampParam* apTmpParam);
            //; check OrgParam for limits, if OrgParam has to be adjusted, copy
            //; them to tmp param, return pointer to result
        virtual void CopyParam(SINOSRampParam* apDstParam, SINOSRampParam*& apSrcParam);
            //; copy src params to dst params
        
        enum ECalcMoveResult {
            eClcMoveResOk = 0,
            eClcMoveResAdjusted = 1,
            eClcMoveResShrinked = 2,
            eClcMoveResFailed = 3,
        }; //; calc move result
 
        virtual ECalcMoveResult CalcMove(real64 arSlen, SINOSRampParam* apParam, CINOSRampSegTra*& apSegAcc, 
            CINOSRampSegCns*& apSegCns, CINOSRampSegTra*& apSegDec, real64 arVbgn = REAL64(0.0),
            real64 arVend = REAL64(0.0), real64 arAbgn = REAL64(0.0),
            real64 arAend = REAL64(0.0), real64 arDuration = REAL64(-1.0));
            //; calc acc, cns and dec segments for a move to arS and return true
            //; if requested V was adjusted
        virtual void CalcMoveApp(real64 arS, real64 arSred, real64 arVred, 
            SINOSRampParam* apParam, CINOSRampSegTra*& apAcc, CINOSRampSegCns*& apCns,
            CINOSRampSegTra*& apDec1, CINOSRampSegCns*& apDec2, CINOSRampSegTra*& apDec3);
            //; calc acc, cns and dec segments for a moveapp to arS
        virtual void CalcMoveDep(real64 arS, real64 arSred, real64 arVred, 
            SINOSRampParam* apParam, CINOSRampSegTra*& apAcc1, CINOSRampSegCns*& apAcc2,
            CINOSRampSegTra*& apAcc3, CINOSRampSegCns*& apCns, CINOSRampSegTra*& apDec);
            //; calc acc, cns and dec segments for a movedep to arS
        virtual bool CalcStop(uint32 auNxtState, SINOSRampParam* apParam, bool abEmergency=false);
            //; calc dec segment for a stop and return true if a calculation was done
        virtual bool CalcStopLive(uint32 auNxtState, SINOSRampParam* apParam, bool abEmergency=false);
            //; calc dec segment for a stop and return true if a calculation was done
        virtual bool CalcStop(real64 arS, uint32 auNxtState, SINOSRampParam* apParam, bool abEmergency=false);
            //; calc acc, cns and dec segments for a stop at arS and return true
            //; if a calculation was done
        virtual real64 CalcEscape(real64 arSlen, SINOSRampParam* apParam); 
            //; ...
        virtual bool iCalcApp(real64 arS, real64 arSred, real64 arVred, SINOSRampParam* apParam);
            //; calc acc, cns and dec segments for a moveapp at arS and return true
            //; if a calculation was done
        virtual void iStopping();
            //; calc live stopping
 
        enum ECalcSegTraType {
            eClcSegTraCompatible = 0,
            eClcSegTraAccelerate = 1,
            eClcSegTraDecelerate = 2,
            eClcSegTraMiddle = 3
        }; //; calc move result
 
        virtual CINOSRampSegTra* CalcSegTra(
            real64 arVb,                // starting velocity
            real64 arAb,                // starting acceleration
            real64 arVe,                // ending velocity
            SINOSRampParam* apParam,    // requested parameters
            CINOSRampSegTra* apResult=0,// result
            real64 arJb=REAL64(-1.0),   // requested begin jerk                 
            real64 arJe=REAL64(-1.0),   // requested end jerk                   
            ECalcSegTraType aeType = eClcSegTraCompatible
            );
            //; calc transition segment
        virtual void CalcSegApp(
            real64 arSr,                // position of reduced velocity
            real64 arVr,                // reduced velocity
            real64 arVb,                // beginning velocity
            SINOSRampParam* apParam,    // requested parameters
            CINOSRampSegTra*& apResult1,// result seg1 
            CINOSRampSegCns*& apResult2,// result seg2
            CINOSRampSegTra*& apResult3,// result seg3
            uint32 auMoveInMove = 0
            );
        virtual void CalcSegDep(
            real64 arSr,                // position of reduced velocity
            real64 arVr,                // reduced velocity
            real64 arVe,                // ending velocity
            SINOSRampParam* apParam,    // requested parameters
            CINOSRampSegTra*& apResult1,// result seg1 
            CINOSRampSegCns*& apResult2,// result seg2
            CINOSRampSegTra*& apResult3 // result seg3
            );
            //; calc transition segment
        CINOSRampSegCns* CalcSegCns(
            real64 arS,                 // requested length
            real64 arV,                 // requested velocity
            CINOSRampSegCns* aResult=0  // result
            );
            //; calc constant segment
        CINOSRampSegPos* CalcSegPos(
            real64 arS,                 // requested position
            real64 arT,                 // requested time
            CINOSRampSegPos* aResult=0  // result
            );
            //; calc position segment
        bool StartJob(CINOSRampJob* apJob);
            //; start apJob and return true if started
        bool ReleaseJob(CINOSRampJob* apJob);
            //; release job if its handled by me
        bool RestartJob();
            //; restart last given job return true if started
        CINOSRampJob* SwitchJob(CINOSRampJob* apJob, uint32 auNxtState, 
            uint32 auBusTicks, bool bLookAhead = false);
            //; switch to apJob and return old job
        CINOSRampJob* GetActJob(bool abIncRefCounter = true);
            //; return pointer to actual job and increase job reference counter
        real64 RoundUpToCycleTime(real64 arTime);
            //; round arTime up to a multiple of cycletime
        real64 RoundToCycleTime(real64 arTime);
                //; round arTime to a multiple of cycletime
        uint64 RoundUpToBusTicks(real64 arTime);
            //; return number of bus ticks needed for arTime
        void SetBusTicksPerAxisTick(uint32 auBusTicksPerAxisTick)
            //; init target ticks calculation
            { m_uBusTicksPerAxisTick = auBusTicksPerAxisTick; };
        
        real64 CalcVmax(real64 adS, SINOSRampParam* apParam);
            //; calc max. allowed V for S
        double _vx(double p, double s, SINOSRampParam* apParam);
            //; helper function for CalcVmax
        double _vy(double s, SINOSRampParam* apParam);
            //; helper function for CalcVmax
        double _vz(double s, SINOSRampParam* apParam);
            //; helper function for CalcVmax
 
        bool IsGreater(real64 arA, real64 arB, bool bPos);
            //; return a > b sign dependent
        
        bool Enter(uint32 auState, bool abEqual=true);
            //; enter critical section
        bool Exit(bool abExitCode);
            //; exit critical section
            
        void SaveActParam(SINOSRampParam* apParam);
            //; save apParam in m_pActParam
            
        bool Sign(real64& arValue)
            //; return true if sign bit set
            { return (*((uint64*)&arValue)&0x8000000000000000LL) ? true : false;};      
            
        void SetupTrqLimit(real64 arAmax, real64 arVmax, real64 arAtrq,
            real64 arVtrq, class CINCOTable* apPoints, SINOSBaseRampTrqLimit*& apLimit);
        void UpdatedMaximum(real64* apValue, real64 rOld, real64 rNew);
        void UpdateSlowMotion(real64 arFactor = REAL64(0.0));
        real64 GetRequestedJobSlowMotion(CINOSRampJob* apJob);
 
        uint32 GetJobOptions(bool abPositive);
        uint32 GetJobOptions(real64 arSbgn, real64 arSend);
 
        bool PrepareBacklash(bool abPositiveMoveDirection, real64& arBacklash);
        void AppendBacklash(CINOSRampJob* apJob, SINOSRampParam* apParam, real64 arBacklash);
 
        #ifdef INOS_SAFETY_SUPPORT
        virtual void SetSafetyFunction(ESafetyFunction auFunction, real64 arLimit, uint32 auDelay,
            bool abUpdate);
        virtual void SetSafetyFunction(ESafetyFunction auFunction);
        virtual real64 CalcSlsLimit(real64 arSlsLimit);
        void SetSLSVmax(real64 arSLSVmax)
            { m_rSLSVmax = arSLSVmax; m_rSLSValue = arSLSVmax; m_eSLSType = eSLSReduceFixed; };
        #endif
 
        #if defined(INOS_AXIS_EXTENSION_SUPPORT)
        void AddExtension(SINOSParamSetExtension* apExtension);
        void RemoveExtension(const char* apName);
 
        SINOSParamSetExtension* GetParamSetExtension(uint32 auExtensionId)
        {
            // get pointer to actual selected param set
            SINOSRampParam* act = m_pActParam;
            // available ?
            if (0 == act) {
                // no -> use default
                act = m_pParam;
            }
            // locals
            SINOSParamSetExtension* ext = act->m_pExtension;
            // find given extension
            while (ext) {
                // check id
                if (ext->m_uId == auExtensionId) {
                    // found
                    return ext;
                }
                // next
                ext = ext->m_pNext;
            } // end while
 
            // not available
            return 0;
        }
        #endif
 
    // protected member functions
    protected:
        void iCoreMismatchError();
            //; set core mismatch axis error
        void iCoreMismatchWarning();
            //; set core mismatch axis warning
 
    // protected members
    protected:
        uint32 m_uState;
            //; actual state
        uint32 m_uNxtState;
            //; next state
        uint32 m_uError;
            //; actual errors
        uint32 m_uWarning;                            
            //; actual warnings
        uint32 m_uFlag;
            //; actual flags
        uint32 m_uFlagEnb;
            //; actual flags enabled
        uint32 m_uFlagOld;
            //; actual flags at last move
        volatile uint32 m_uAlive;                            
            //; alive counter
        CINOSRampJob* m_pActJob;            
            //; pointer to actual ramp job          
        CINOSRampJob* m_pNxtJob;            
            //; pointer to next ramp job            
        CINOSRampJob* m_pBrkJob;            
            //; pointer to paused ramp job          
        CINOSRampJob* m_pSegJob;            
            //; pointer to segmentation job         
        CINOSRampSegPos* m_pSegPosLast;         
            //; pointer to last added segpos segment
        CINOSRampCache* m_pCache;
            //; pointer to cache of jobs
        bool m_bCacheable;
            //; true if cache enabled 
        bool m_bSetupModeOk;
            //; true if setup mode ok 
        SINOSRampDataEx* m_pFstData;
            //; pointer to first ramp data structure in list
        SINOSRampDataEx* m_pLstData;
            //; pointer to last ramp data structure in list
        bool m_bDataValid;
            //; true if ramp data is valid
        SINOSBaseRamp* m_pDesc;
            //; pointer to object descriptor
        #ifndef INOS_RAMP_DLL
        CINCOObject* m_pRegister;
            //; pointer to inco registration
        CINCOObject* m_pCmd;
            //; pointer to inco registration of commanded values
        CINCOObject* m_pAct;
            //; pointer to inco registration of actual values
        CINCOObject* m_pMax;
            //; pointer to inco registration of max values
        CINCOObject* m_pProp;
            //; pointer to inco registration of properties
        CINCOObject* m_pError;
            //; pointer to inco registration of errors
        CINCOObject* m_pWarning;
            //; pointer to inco registration of warnings
        CINCOObject* m_pFlag;
            //; pointer to inco registration of flags
        CINCOObject* m_pFlagEnb;
            //; pointer to inco registration of flags enable
        uint32 m_uCharacteristics;
            //; inco registration characteristics
        uint8 m_uTypeChar;
            //; type character, e.g. 'T' for temperature
        #endif
        const char* m_pType;
            //; ramp type
        inosName32 m_cName;
            //; ramp name
        inosName m_cUnit;
            //; ramp unit
        
        // cycle time
        
        real64 m_rCycleTime;
            //; cycle time in sec
        real64 m_rCycleTimeOversampled;
            //; cycle time in sec inclusive oversampling factor
        real64 m_rCycleTime_1;
            //; 1/cycle time
        uint32 m_uCycleTimeUs;
            //; cycle time in us
        uint32 m_uCycleTimeNs;
            //; cycle time in ns 
        uint8 m_uOversampling;
            //; oversampling factor 
        real64 m_rMiMTol;
            //; move in move constant segment tolerance [sec]
        real64 m_rLastOvrs;
            //; last oversampled value
 
        // commanded values
 
        real64 m_rScmd;
            //; commanded position
        real64 m_rBemg;
            //; commanded emergency deceleration
        real64 m_rJemg;
            //; commanded emergency jerk (only valid before the deceleration phase)
        real64 m_rJeemg;
            //; commanded end emergency jerk (only valid before stop)
        real64 m_rPausedEnd;
            //; commanded end position at Break command (needed for Continue)
        SINOSRampParam* m_pParam;
            //; commanded acc,dec,vel,jerk
        SINOSRampParam* m_pActParam;
            //; commanded acc,dec,vel,jerk of actual running move
        SINOSRampParam* m_pStartParam;
            //; commanded acc,dec,vel,jerk at last startjob
        SINOSRampParam m_sSavParam;
            //; saved commanded acc,dec,vel,jerk of actual running move (this is
            //; only used if the given speed set pointed to stack memory of the
            //; calling task, if this is the case a copy is taken to avoid working
            //; with an invalid speedset pointer in later commands , e.g. Stop, ..)
        real64 m_rVpeak;
            //; peak velocity of current/last move
        real64 m_rApeak;
            //; peak acceleration of current/last move
        real64 m_rBpeak;
            //; peak deceleration of current/last move
 
        // segmentation moves
        
        real64 m_rSseg;
            //; requested position at end of actual segment
        real64 m_rVseg;
            //; requested velocity at end of actual segment
        real64 m_rAseg;
            //; requested velocity at end of actual segment
        ECalcMoveResult m_eSegMoveResult;
            //; result of last seg move
 
        // actual values
 
        real64 m_rAdjPos;
            //; actual requested position adjust
        SINOSRampDataEx* m_Act;
            //; actual values
        real64 m_rSbgn;
            //; position the actual/last move/endless was started from
        
        // min./max. values
 
        real64 m_rSmin;
            //; min. allowed position
        real64 m_rSmax;
            //; max. allowed position
        real64 m_rVmin;
            //; min. allowed velocity
        real64 m_rVmax;
            //; max. allowed velocity
        real64 m_rVmaxSetup;
            //; max. allowed velocity in setup mode
        real64 m_rVmaxInit;
            //; max. allowed velocity during initialization
        real64 m_rVmaxLimit;
            //; max. allowed velocity during pull (1.01*m_rVmax)
        real64 m_rVtrq;
            //; max. allowed velocity
        real64 m_rAmin;
            //; min. allowed acceleration
        real64 m_rAmax;
            //; max. allowed acceleration
        real64 m_rAmaxPull;
            //; max. allowed acceleration during pull
        real64 m_rArms;
            //; max. allowed rms acceleration
        real64 m_rAtrq;
            //; max. allowed acceleration
        real64 m_rBmin;
            //; min. allowed deceleration
        real64 m_rBmax;
            //; max. allowed deceleration
        real64 m_rBtrq;
            //; max. allowed deceleration
        real64 m_rCmin;
            //; min. allowed cruiseleration
        real64 m_rCmax;
            //; max. allowed cruiseleration
        real64 m_rJmin;
            //; min. allowed jerk
        real64 m_rJmax;
            //; max. allowed jerk
        real64 m_rEpsilon;
            //; calculation epsilon
            
        // torque limitation
 
        SINOSBaseRampTrqLimit* m_pTrqLimitAcc;
        SINOSBaseRampTrqLimit* m_pTrqLimitDec;
 
        uint64 m_uTickCount;
            //; bus tickcount at last ramp handle
        // target ticks calculation
        uint64 m_uTargetTicks;
            //; bus tickcount the actual move reaches the target
        uint64 m_uStartTicks;
            //; bus tickcount at target ticks calculation
        uint64 m_uStartTicks_;
            //; bus tickcount at target ticks calculation
        uint32 m_uBusTicksPerAxisTick;
            //; number of bus ticks per axis tick
        uint32 m_uNxtTicks;
            //; number of ticks the next job needs
        uint16 m_uIterCount;
            //; iteration counter
        uint16 m_uIterCountMax;
            //; max. ever reached iteration counter
        uint16 m_uStopAliveDelta;
            //; number of alive ticks during stop calculation
        uint16 m_uStopAliveDeltaMax;
            //; max. ever reached alive delta
        int16 m_iStoppingState;
            //; stopping state
        real64 m_rStoppingJerk;
 
        CINOSRampSegTra* m_pStopLiveSeg;
        real64 m_rStopLiveSegV;
        real64 m_rStopLiveSegB;
        real64 m_rStopLiveSegJ2;
        real64 m_rStopLiveSegJ3;
        real64 m_rStopLiveSegDelta;
        real64 m_rStopLiveTime;
        real64 m_rStopLivePos;
        real64 m_rStopLiveDelta;
        real64 m_rStopLiveSlowMotion;
 
        // move safe
        bool m_bMoveSafeMin;
            //; actual move safe min valid
        real64 m_rMoveSafeMin;
            //; actual move safe min
        real64 m_rMoveSafeFact1;
            //; actual move safe factor for safe1
        real64 m_rMoveSafeFact2;
            //; actual move safe factor for safe2
        
        // backlash
 
        enum {
            eFlgBacklashCompensationRequired = 0x00000001,
        };
        uint32 m_uBacklashFlags;
        real64 m_rBacklash;
        real64 m_rBacklashSlowmotion;
 
        // safety
 
        #ifdef INOS_SAFETY_SUPPORT
        enum ESLSType {
            eSLSReduceAbsolute = 0, // Vmax = m_rSafetyLimit - m_rSLSValue
            eSLSReducePercent = 1,  // Vmax = m_rSafetyLimit * (100.0 - m_rSLSValue) / 100.0
            eSLSReduceFixed = 2,    // Vmax = m_rSLSValue;
        };
        ESLSType m_eSLSType;
        real64 m_rSLSValue;
        real64 m_rSLSJerk;
        real64 m_rSLSVmax;
 
        ESafetyFunction m_eSafetyFunction;
        uint8 m_uSafetyType;
        real64 m_rSafetyLimit;
        uint32 m_uSafetyDelay;
        #endif
 
        // mapping
        CINOSMapping* m_pMapping;
            //; pointer to actual mapping
        uint32 m_uMappingIndex;
            //; index this axis has in the actual mapping
        static char m_cStateCombo[494]; 
            //; ramp state INCO item text. Use 494 (=defMaxDataLength). I fear
            //; to include inco_com.h here, that's why a plain number is used)
 
        // timing
 
        uint32 m_uTimMoveCalcAct;
        uint32 m_uTimMoveCalcMin;
        uint32 m_uTimMoveCalcMax;
        uint32 m_uTimStopCalcAct;
        uint32 m_uTimStopCalcMin;
        uint32 m_uTimStopCalcMax;
 
        // multi core
        uint8 m_uCoreId = DF_INOS_CORE_DEFAULT;
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSBaseRamp);
};
 
 
//------------------------------------------------------------------------------
// class registration
//------------------------------------------------------------------------------
 
typedef CINOSBaseRamp *(*TCreateRamp)(const char* apAxisName);
 
class CINOSRegisterBaseRamp 
{   
    // after this function you can register new ramps
    friend void _INI_0000_CINOSBaseRamp();
    
    //--- internals --------------------------------------------------------
 
    // private members 
private:
    // pointer to the first registered ramp
    static CINOSRegisterBaseRamp* m_pFirst; 
    // pointer to the next ramp
    CINOSRegisterBaseRamp* m_pNext; 
    // create funtion for the ramp
    TCreateRamp m_pCreate;
    // ramp type name
    const char* m_pType;
        
    //--- user interface ---------------------------------------------------
 
public:
    // register a new ramp type
    CINOSRegisterBaseRamp(TCreateRamp apFunction, const char* apRampType);
    
    // create and return and new ramp instance
    static CINOSBaseRamp* GetRamp(const char* apType);
    // create and return and new ramp instance
    static CINOSBaseRamp* GetRamp(const char* apAxisName, const char* apType);
};
 
//------------------------------------------------------------------------------
//--- helper macros ------------------------------------------------------------
//------------------------------------------------------------------------------
//
#if defined(INOS_MULTICORE)
#define INOS_RAMP_CORE_MISMATCH_IS_ERROR(ret)                               \
if ((m_uCoreId != DF_INOS_CORE_DEFAULT) && (::GetCoreId() != m_uCoreId)) {  \
    if (!(GetFlag() & DF_INOS_BASE_RAMP_FLAG_IGNORE_CORE)) {                \
        iCoreMismatchError();                                               \
        return ret;                                                         \
    }                                                                       \
}
#define INOS_RAMP_CORE_MISMATCH_IS_WARNING(ret)                             \
if ((m_uCoreId != DF_INOS_CORE_DEFAULT) && (::GetCoreId() != m_uCoreId)) {  \
    if (!(GetFlag() & DF_INOS_BASE_RAMP_FLAG_IGNORE_CORE)) {                \
        iCoreMismatchWarning();                                             \
        return ret;                                                         \
    }                                                                       \
}
#else
#define INOS_RAMP_CORE_MISMATCH_IS_ERROR(ret)
#define INOS_RAMP_CORE_MISMATCH_IS_WARNING(ret)
#endif
 
//------------------------------------------------------------------------------
//--- fast math functions ------------------------------------------------------
//------------------------------------------------------------------------------
//
extern double inos_sqrt(double adValue);
//
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSBASERAMP_H