doxygen/inos/cinosbasecontrol_8h_source.html

//******************************************************************************

//******************************************************************************


#ifndef INC_CINOSBASECONTROL_H

#define INC_CINOSBASECONTROL_H


//------------------------------------------------------------------------------

// defines

//------------------------------------------------------------------------------

//

#define DF_INOS_BASE_CONTROL_DBT    "INOS-BASE-CONTROL"// db table name

//

// --- controller states -------------------------------------------------------

//

#define DF_INOS_CONTROL_STATE_PEACE             0   // peace

#define DF_INOS_CONTROL_STATE_ACTIVATING        1   // activating

#define DF_INOS_CONTROL_STATE_ACTIVE            2   // active

#define DF_INOS_CONTROL_STATE_INACTIVATING      3   // inactivating

//

// --- controller sub states ---------------------------------------------------

//

// sub states for state ACTIVE

#define DF_INOS_CONTROL_SUBSTATE_ACTIVE_HALT    0   // active halt

#define DF_INOS_CONTROL_SUBSTATE_ACTIVE_RUN     1   // active run

#define DF_INOS_CONTROL_SUBSTATE_ACTIVE_UMOVE   2   // active micro move (used by safety)

//

// --- controller errors -------------------------------------------------------

//

// Base mcrobot error number 0x4003Nxxx

//

#define ER_INOS_BASE_CONTROL_MCROBOT_ERROR_BASE 0x00000000  // sac like controllers

#define ER_INOS_GSB_CONTROL_MCROBOT_ERROR_BASE  0x40031300  // gsb like controllers

#define ER_INOS_SL2_CONTROL_MCROBOT_ERROR_BASE  0x40032300  // sl2 like controllers

#define ER_INOS_HSSI_CONTROL_MCROBOT_ERROR_BASE 0x40033300  // hssi like controllers

//

#define ER_INOS_CONTROL_POSCHK      0x00000001  // controller pos check error

#define ER_INOS_CONTROL_POSOVR      0x00000002  // pos channel overrun detected

#define ER_INOS_CONTROL_OSCICHK     0x00000004  // oscillation detected

#define ER_INOS_CONTROL_ENBMISSING  0x00000008  // enable missing

#define ER_INOS_CONTROL_HOMEFAILED  0x00000010  // homing failed

#define ER_INOS_CONTROL_SAFE_SYNCFAILED 0x00000020  // safe sync failed

#define ER_INOS_CONTROL_WATCHDOG    0x00000040  // fieldbus watchdog detected

#define ER_INOS_CONTROL_POSCHN      0x00001000  // no pos channel available

#define ER_INOS_CONTROL_ACTIVATE    0x00002000  // activation error

#define ER_INOS_CONTROL_EXTERN      0x00004000  // external controller error

#define ER_INOS_CONTROL_OFFLINE     0x00008000  // pos channel offline

//

// --- controller warnings -----------------------------------------------------

//

#define WR_INOS_CONTROL_INTLIMIT    0x00000001  // integrator limit reached

#define WR_INOS_CONTROL_FSLIMIT     0x00000002  // full scale limit reached

#define WR_INOS_CONTROL_EXTERN      0x00004000  // external controller warning

//

// --- controller flags --------------------------------------------------------

//

#define DF_INOS_BASE_CONTROL_FLAG_CHK_POS   0x00000001  // check position error

#define DF_INOS_BASE_CONTROL_FLAG_SIM_POS   0x00000002  // simulate actual position

#define DF_INOS_BASE_CONTROL_FLAG_SIM_OUT   0x00000004  // simulate output

#define DF_INOS_BASE_CONTROL_FLAG_SIM_ACT   0x00000008  // simulate activate

#define DF_INOS_BASE_CONTROL_FLAG_ENB_NRD   0x00000010  // enable noise reduction

#define DF_INOS_BASE_CONTROL_FLAG_DEAD_INC  0x00000020  // Add dead time caused by the "fieldbus delays" (cycletime + fieldbustime + residual). Resulting Deadtime = DeadTime (from dt2 file) +  "fieldbus delays"

#define DF_INOS_BASE_CONTROL_FLAG_ENB_SYN   0x00000040  // enable sync

#define DF_INOS_BASE_CONTROL_FLAG_ENB_NRM   0x00000080  // enable norm

#define DF_INOS_BASE_CONTROL_FLAG_POS_OVRS  0x00000100  // poschannel overrun supervision

#define DF_INOS_BASE_CONTROL_FLAG_FFV_100   0x00000200  // feed forward V 100% based

#define DF_INOS_BASE_CONTROL_FLAG_NO_PID    0x00000400  // No pid calculation. Implicitly '1' if "feed forward V 100%"=1 and "Without master position error"=0

#define DF_INOS_BASE_CONTROL_FLAG_POS_ABS   0x00000800  // position channel contains absolute encoder positions, e.g. used during axis init

#define DF_INOS_BASE_CONTROL_FLAG_NO_MPE    0x00001000  // Without master position error: do not send master position (maspos) error to controller

#define DF_INOS_BASE_CONTROL_FLAG_POSEX     0x00002000  // Support 2nd position channel (PositionEx). Usually enabled if a 2nd position measurment system is available

#define DF_INOS_BASE_CONTROL_FLAG_INIT_V_ADJ_DIS    0x00004000  // Do not adjust axis init speed even if "feed forward V 100% based" is disabled.

#define DF_INOS_BASE_CONTROL_FLAG_DEAD_INC2 0x00008000  // Add dead time caused by the "fieldbus delays" by another formula (0.5*cycletime + fieldbustime + residual). Resulting Deadtime = DeadTime (from dt2 file) +  "fieldbus delays"

#define DF_INOS_BASE_CONTROL_FLAG_LIFETIME  0x00010000  // lifetime distance support

#define DF_INOS_BASE_CONTROL_FLAG_NRM_POS   0x00020000  // norm to only positive values

#define DF_INOS_BASE_CONTROL_FLAG_DISTANCE_CODED_CALIB  0x00040000  // supports distance coded calib

#define DF_INOS_BASE_CONTROL_FLAG_INC_FRACT 0x00080000  // fractional increments support

//                                          0x01000000  // RESERVED for subclasses

//                                          0x02000000  // RESERVED for subclasses

//                                          0x04000000  // RESERVED for subclasses

//                                          0x08000000  // RESERVED for subclasses

#define DF_INOS_BASE_CONTROL_FLAG_ENB_SAFE_SYNC 0x40000000  // temporarly enabled safe sync

#define DF_INOS_BASE_CONTROL_FLAG_DIS_SERR  0x80000000  // temporarly disable Serr calculation

//

// --- controller options ------------------------------------------------------

//

#define DF_INOS_BASE_CONTROL_OPT_DEAD_INC   0x00000001

#define DF_INOS_BASE_CONTROL_OPT_POS_OVRS   0x00000002

#define DF_INOS_BASE_CONTROL_OPT_FFV_100    0x00000004

#define DF_INOS_BASE_CONTROL_OPT_NO_PID     0x00000008

#define DF_INOS_BASE_CONTROL_OPT_POS_ABS    0x00000010

#define DF_INOS_BASE_CONTROL_OPT_NO_MPE     0x00000020

#define DF_INOS_BASE_CONTROL_OPT_POSEX      0x00000040

#define DF_INOS_BASE_CONTROL_OPT_INIT_V_ADJ_DIS 0x00000080

#define DF_INOS_BASE_CONTROL_OPT_DEAD_INC2  0x00000100

#define DF_INOS_BASE_CONTROL_OPT_DISTANCE_CODED_CALIB 0x00000200

#define DF_INOS_BASE_CONTROL_OPT_CUSTOMER1_SYNC_INTERFACE 0x00000400

#define DF_INOS_BASE_CONTROL_OPT_LIMIT_OUT  0x00000800

#define DF_INOS_BASE_CONTROL_OPT_IGNORE_CYCLEID 0x00001000

#define DF_INOS_BASE_CONTROL_OPT_INC_FRACT  0x00002000

#define DF_INOS_BASE_CONTROL_OPT_EXT_POS_ERR    0x00004000


//

//------------------------------------------------------------------------------

// includes

//------------------------------------------------------------------------------

//

// system

#include <cinosprocessimage.h>

#include <inco_com.h>

//

// C++

//

// project

#ifdef INOS_SAFETY_SUPPORT

#include <cinosjerkramp.h>

#endif // INOS_SAFETY_SUPPORT

//

//------------------------------------------------------------------------------

//--- structures ---------------------------------------------------------------

//------------------------------------------------------------------------------

//


struct SINOSBaseControl

{

    inosName64 m_cName;


    inosName64 m_cPosName;


    inosName64 m_cDacName;


    inosName64 m_cEnbName;


    inosName m_cUnit;


    real64 m_rCycleTime;


    real64 m_rDeadTime;


    real64 m_rSmax;


    real64 m_rSmaxRun;


    real64 m_rDelayToHalt;


    real64 m_rPosExUnitsPerInc;


    real64 m_rSINOSBaseControl_Internal0[2];


    uint32 m_uOptions;


    uint8 m_uDigits;


    uint8 m_uVfilter;


    uint8 m_uOversampling;


    uint8 m_rSINOSBaseControl_Internal1;


    real64 m_rMicroMoveTime;


    // constructor

    SINOSBaseControl();

};


//------------------------------------------------------------------------------

// forward declarations

//------------------------------------------------------------------------------

//

struct SINOSRampData;

struct SINOSRampDataEx;

class CINOSOscillationDetector;


//------------------------------------------------------------------------------

// class definition

//------------------------------------------------------------------------------

//


class CINOSBaseControl

{

    //--- user interface ---------------------------------------------------


    // public member functions

    public :


        // constructor/destructor


        explicit CINOSBaseControl(SINOSBaseControl* apDesc);

            //; constructor

        virtual ~CINOSBaseControl();

            //; destructor

        static CINOSBaseControl* GetControl(const char* apAxisName,

            const char* apControlType);

            //; create controller and return pointer to it


        virtual uint32 Connect();


        // activate / inactivate


        virtual void Activate(bool abCheckPos = true, bool abSimulatePos = false,

            bool abSimulateOut = false, bool abSimulateAct = false);

            //; activate controller

        virtual void InActivate();

            //; inactivate controller


        // pull


        ICACHE virtual uint32 Pull(SINOSRampDataEx* apData);

            //; follow apData

        ICACHE virtual uint32 Pull(real64 arPosition, real64 arVelocity,

            real64 arAcceleration, real64 arJerk);

            //; follow arPosition with arVelocity and arAcceleration


        virtual void GetCmdPosition(real64& arPosition);

            //; get commanded position

        virtual void GetCmdVelocity(real64& arVelocity);

            //; get commanded velocity

        virtual void GetCmdAcceleration(real64& arAcceleration);

            //; get commanded acceleration

        virtual void GetCmdJerk(real64& arJerk);

            //; get commanded jerk

        ICACHE virtual void SetActPosition(real64 arPosition);

            //; set actual position to arPosition

        ICACHE virtual void AdjActPosition(real64 arPosition);

            //; set actual position to arPosition

        ICACHE virtual void GetActPosition(real64& arPosition);

            //; get position

        ICACHE virtual void GetActPositionEx(real64& arPosition);

            //; get position ex

        INOS_INLINE void GetActPositionFst(real64& arPosition)

            { arPosition = m_rSact; };

        virtual void GetActVelocity(real64& arVelocity, bool abFiltered = false);

            //; get actual velocity

        virtual void GetActAcceleration(real64& arAcceleration);

            //; get actual acceleration

        virtual void GetActJerk(real64& arJerk);

            //; get actual jerk

        virtual void GetActPosError(real64& arPosError);

            //; get actual position error

        virtual void GetActVelocityError(real64& arVelocityError, bool abFiltered = false);

            //; get actual velocity error


        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

        virtual void SetIncsPerUnit(real64 arIncs);

            //; set number of incs per unit

        virtual void SetUnitsPerInc(real64 arUnits);

            //; set number of units per inc

        virtual void OnGearRatioChanged(){};

            //; called whenever the axis gear ratio has changed, it gives the controller

            //; the chance to recalculate internal values if necessary


        void SetFlag(uint32 auFlag)

            { INOS_OR(m_uFlag, auFlag);};

            //; set controller flags

        void ClrFlag(uint32 auFlag)

            { INOS_AND(m_uFlag, ~auFlag);};

            //; clear controller flags

        uint32 GetFlag() const

            { return m_uFlag;};

            //; get controller flags

        const char* GetType()

            { return m_pType; };

            //; get controller state

        ICACHE virtual uint32 GetState();

            //; get controller state

        ICACHE virtual uint32 GetState(uint32& auSubState);

            //; get controller state and sub state

        virtual uint32 SetError(uint32 auError);

            //; set controller error and return old ones

        ICACHE virtual uint32 GetError(bool abResolveExternal = false);

            //; get controller error

        ICACHE virtual uint64 GetErrorEx(bool abResolveExternal = false);

            //; get extended controller error

        ICACHE virtual real64 GetPosError()

            { return m_rSerr; }

            //; get controller error

        virtual bool IsErrorFatal();

            //; return true if error is fatal

        virtual uint32 GetWarning(bool abResolveExternal = false);

            //; get controller warning

        virtual uint64 GetWarningEx(bool abResolveExternal = false);

            //; get extended controller warning

        virtual void AcceptError(uint64 auError=0xffffffffffffffffLL);

            //; accept controller error (auError=0xffffffff -> accept all errors)

        virtual void AcceptWarning(uint64 auWarning=0xffffffffffffffffLL);

            //; accept controller warning (auWarning=0xffffffff -> accept all warnings)


        virtual bool Sync(real64 arPosition);

            //; enable sync mechanism and set pos to arPosition on sync

        ICACHE virtual void AbortSync();

            //; abort sync mechanism

        virtual bool GetZeroImpuls();

            //; return state of 'zero impuls' input

        virtual void GetSyncPos(real64& arSyncPos)

            { arSyncPos = m_rSyncPos;};

            //; return actual sync pos

        virtual void SetSyncPos(real64 arSyncPos);

            //; set sync pos

        virtual void GetSyncCnt(uint32& auSyncCnt)

            { auSyncCnt = m_uSyncCnt;};

            //; return actual sync counter

        virtual void SetSyncCnt(uint32 auSyncCnt)

            { m_uSyncCnt = auSyncCnt;};

            //; set sync pos

        virtual void GetSyncCor(real64& arSyncCor)

            { arSyncCor = m_rSyncCor;};

            //; return actual sync counter

        virtual void SetNormPos(real64 arNormPos);

            //; set norm pos

        void SetPathS(real64 arSpath)

            { m_rSpath = arSpath; };


        void SetLifetimeDistance(real64 arDistance);

        void GetLifetimeDistance(real64& arDistance);


        ICACHE virtual void SetAxisEnable(bool abEnable);

            //; enable/disable axis

        ICACHE virtual bool GetAxisEnable();

            //; get axis enable state

        ICACHE virtual bool GetAxisEnabled();

            //; get axis enabled state

        ICACHE virtual bool GetAxisReady();

            //; get axis ready state

        ICACHE virtual void SetSyncEnable(bool abEnable);

            //; enable/disable sync

        ICACHE virtual bool GetSyncEnabled();

            //; get sync enabled state

        ICACHE virtual void ResetSync();

            //; disable sync/synced

        ICACHE virtual void ResetEnabled();

            //; disable enabled

        ICACHE virtual void SetControlOut(real64 arControl);

            //; set control output

        ICACHE virtual void SetSerrorOut(real64 arError);

            //; set error output

        virtual bool GetAutoComRequested();

            //; return true if autocommutation requested

        virtual void OnActivated(){};

            //; called at activating -> active

        virtual void OnInActivated(){};

            //; called at active -> activating -> activated


        virtual void BorderRelaxStart();

            //; inform controller about a touched border

        virtual void BorderRelaxStop();

            //; inform controller about border relax time has expired


        ICACHE virtual void SetCoupled(bool abCoupled);

            //; set coupled

        ICACHE virtual bool GetCoupled();

            //; get coupled


        virtual bool SafeSyncEnable();

            //; enable safe syncing mechanism and return true if available

        virtual void SafeSyncDisable();

            //; disable safe syncing mechanism

        virtual bool SafeSyncCheck()

            //; return true if safe sync was successful

            {

                return (m_pInpSyncDeltaOk && m_pInpSyncDeltaOk->Test());

            }

        virtual bool SafeSyncAvailable()

            //; return true if safe sync is available

            {

                return (nullptr != m_pInpSyncDeltaOk);

            }


        virtual void GetCycleTime(real64& arCycleTime, bool abOversampled=false);

            //; get controller cycle time [sec]

        virtual void SetCycleTime(real64 arCycleTime);

            //; set controller cycle time [sec]

        virtual uint8 GetOversampling()

            { return m_uOversampling;};

            //; get controller oversampling factor

        virtual uint16 GetCycleNumber();

            //; get controller cycle number

        virtual uint16 GetCycleId();

            //; get controller cycle id

        virtual uint8 GetBusId();

            //; get controller bus id

        virtual void SetDeadTime(real64 arDeadTime);

            //; set dead time [sec]

        virtual void GetDeadTime(real64& arDeadTime);

            //; set dead time [sec]


        virtual CINOSPosChannel* GetPosChannel();

            //; return pointer to my pos channel or NULL if not yet available

        virtual CINOSBit* GetOutActivate()

            //; return pointer to my activation output (if available)

            { return m_pOutActivate;}

        virtual CINOSBit* GetPowerReady()

            //; return pointer to my Ucc input (if available)

            { return m_pInpUccOk;}

        virtual bool IsOnline() const;

            //; \return true if the poschannel is online. false otherwise. The

            //; poschannel is online, when the poschannel's slave is physically

            //; connected to the master.

            //; \note So far, once a poschannel was online, it'll always be

            //; online (due to the fact that the poschannel will not be deleted

            //; when its slave is being disconnected from the bus). This

            //; behaviour may change in the future.


        virtual CINCOObject* GetRegister();

            //; do inco registration and return pointer to it


        virtual uint32 GetMcRobotBaseCode()

            { return ER_INOS_BASE_CONTROL_MCROBOT_ERROR_BASE; };


        const char* GetAxisName() const

            { return m_pDesc->m_cName; }


        void SetAxisEnableInput(const char* apInputName);

        void GetAxisEnableInput(char* apResult, uint32 auSize) const;


        #ifdef INOS_SAFETY_SUPPORT

        // safety related


        virtual bool MoveMicro();

            //; initiate a micro move used to prevent a sincoshalt safety error

            //; \return true if the move was successfully initiated


        virtual bool CalcMoveMicroParams(CINOSBaseRamp* apRamp);

            //; (pre-)calculates parameters related to micro moves

            //; based on the current safety configuration

            //; \return true if all parameters successfully calculated


        virtual bool IsMoveMicroSupported(bool abVerbose = false);

            //; checks whether micro moves are supported with the current

            //; system configuration

            //; \param abVerbose flag indicating if additional info

            //; should be traced if micro moves not supported


        #endif // INOS_SAFETY_SUPPORT


    //--- internals --------------------------------------------------------


    friend class CINOSPhysicalAxis;

    friend class CINCODelayToHalt;

    friend class CINCODeadTimeMs;

    friend class CINCOactSEx;

    friend class CINCOlifeS;

    friend void _INI_0400_CINOSBaseControl();


    // protected member functions

    protected:

        virtual void Reset();

            //; reset controller values (called whenever the controller is

            //; switched on)

        virtual void Control();

            //; do a control cycle

        virtual void Activating() {};

            //; called during activation

        virtual void InActivating() {};

            //; called during inactivation

        void iCalcDeadTime();

            //; calc m_rDeadTime from m_rDeadTimeMs

        real64 GetSyncCor()

            { return m_rSyncCor;};

            //; return sync correction

        int64 iCalcSinc(real64 arPosition);

            //; calc inc's from pos

        ICACHE real64 iCalcSact(int64 aiPosition);

            //; calc pos from inc's

        ICACHE real64 iCalcSactEx(int64 aiPositionEx);

            //; calc pos ex from inc's

        ICACHE void iCalcSerr();

            //; calc pos from inc's

        bool HasExtendedErrorWarning();

            //; return true if external controller supports extended errors/warnings

        ICACHE uint32 iGetError()

            { return (uint32) m_uError; };

            //; get controller error

        ICACHE uint32 iGetWarning()

            { return (uint32) m_uWarning; };

            //; get controller warning

        void iRegisterTrqCurrent();

            //; register trq current

        virtual void UpdateCycleId(uint16 auCycleId);

            //; update cycle id the axis controller is running in

        void SetMaxVelocity(real64 arVmax)

            {if (arVmax > REAL64(0.0)) m_rVmax_1 = REAL64(1.0)/arVmax; else m_rVmax_1 = REAL64(0.0);}

        bool iSetAxisEnableInput();


    // public member methods but just for internal use

    public :

        virtual const char* GetStateText();

            //; get pointer to actual state text


    // protected members

    protected:

        uint32 m_uState;

            //; actual state

        uint32 m_uSubState;

            //; actual sub state

        uint64 m_uError;

            //; actual errors

        uint64 m_uWarning;

            //; actual warnings

        uint32 m_uFlag;

            //; actual flags

        uint32 m_uFlagCpy;

            //; copy of actual flags

        bool m_bStartup;

            //; startup flag


        // pointers


        CINCOObject* m_pRegister;

            //; pointer to inco registration

        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_pCmd;

            //; pointer to inco registration of commanded values

        CINCOObject* m_pAct;

            //; pointer to inco registration of actual values

        CINCOObject* m_pLife;

            //; pointer to inco registration of lifetime values

        CINCOObject* m_pErr;

            //; pointer to inco registration of error values

        CINCOObject* m_pMax;

            //; pointer to inco registration of max values

        CINCOObject* m_pMisc;

            //; pointer to inco registration of miscelanselous values

        CINOSPosChannel* m_pPosChannel;

            //; pointer to according pos channel

        CINOSPosChannel* m_pPosChannelEx;

            //; pointer to according pos channel ex

        uint32* m_pPosConfig;

            //; pointer to pos channel config

        uint32* m_pPosOffline;

            //; pointer to pos channel offline config

        int32* m_pPosPosition;

            //; pointer to pos channel position

        int32* m_pPosPositionEx;

            //; pointer to pos channel position ex

        SINOSBaseControl* m_pDesc;

            //; pointer to controller descriptor

        const char* m_pType;

            //; controller type

        CINOSBus* m_pBus{};

            //; pointer to the fieldbus that handles at least the pos channel

        uint8 m_uBusCategory{};

            //; fieldbus category of the pos channel


        // new style pointers


        CINOSBit* m_pOutActivate;

        CINOSBit* m_pOutSyncEnb;

        CINOSBit* m_pOutSyncEnbEx;

        CINOSBit* m_pOutCurLimit;

        CINOSBit* m_pOutCurAdd;

        CINOSBit* m_pOutCurCmd;

        CINOSBit* m_pOutPosRelax;

        CINOSBit* m_pOutCoupled;


        CINOSBit* m_pInpActivated;

        CINOSBit* m_pInpAutoCom;

        CINOSBit* m_pInpWarning;

        CINOSBit* m_pInpError;

        CINOSBit* m_pInpFatalError;

        CINOSBit* m_pInpSynced;

        CINOSBit* m_pInpSyncDeltaOk;

        CINOSBit* m_pInpSync;

        CINOSBit* m_pInpUccOk;


        CINOSDacChannel* m_pOutSpeed;

        void* m_pOutSpeedRaw;

        real64 m_rOutSpeedRawGain;

        CINOSDacChannel* m_pOutSerror;

        void* m_pOutSerrorRaw;

        real64 m_rOutSerrorRawGain;

        CINOSDacChannel* m_pOutTrqCurrent;


        CINOSAdcChannel* m_pInpTrqCurrent;


        // cfg masks


        uint32 m_uMaskCfgError;

        uint32 m_uMaskCfgWarning;

        uint32 m_uMaskCfgSynced;


        // cycle time


        real64 m_rCycleTime;

            //; cycle time in s

        real64 m_rCycleTimeMs;

            //; cycle time in ms

        real64 m_rDeadTime;

            //; dead time in s

        real64 m_rDeadTimeMs;

            //; dead time in ms

        real64 m_rDelayToHalt;

            //; delay [ms] before switching from run to halt parameters

        uint16 m_uCycleId;

            //; cycle id

        uint8 m_uOversampling;

            //; oversampling


        // commanded values


        real64 m_rScmd;

            //; commanded position

        real64 m_rVcmd;

            //; commanded velocity

        real64 m_rAcmd;

            //; commanded acceleration

        real64 m_rJcmd;

            //; commanded jerk

        real64 m_rSpath;

            //; original position (used together with movepath functionality)


        // actual values


        real64 m_rSact;

            //; actual position

        real64 m_rSactEx;

            //; actual position ex

        real64 m_rSactExOffset;

            //; actual position ex offset

        real64 m_rSactDiff;

            //; actual position - actual position ex

        real64 m_rVact;

            //; actual velocity

        real64 m_rVactFiltered;

            //; actual filtered velocity

        real64 m_rAact;

            //; actual acceleration

        real64 m_rJact;

            //; actual jerk


        // lifetime values


        int64 m_iLifetimeDistance;


        // error values


        real64 m_rSerr;

            //; actual position error

        real64 m_rVerr;

            //; actual velocity error

        real64 m_rVerrFiltered;

            //; actual filtered velocity error

        real64 m_rSmax;

            //; max. allowed position error

        real64 m_rSmaxRun;

            //; factor to calculate max. allowed position error at move

            //; maxSerr = m_rSmax*(1.0 + m_rSmaxRun*(V/Vmax))

        real64 m_rSmaxAct;

            //; actual max. allowed position error

        real64 m_rVmax_1;

            //; 1.0/m_rVmax

        real64 m_rSerrMax;

            //; max. reached position error

        real64 m_rSerrMin;

            //; min. reached position error

        real64 m_rSerrMaxPos;

            //; max. reached position error in positive direction

        real64 m_rSerrMinPos;

            //; min. reached position error in positive direction

        real64 m_rSerrMaxNeg;

            //; max. reached position error in negative direction

        real64 m_rSerrMinNeg;

            //; min. reached position error in negative direction


        // extended position error calculation


        uint16 m_uCmdMsk{};

        uint16 m_uCmdWrt{};

        uint16 m_uCmdDdT{};

        uint16 m_uCmdWait{};

        real64 m_rCmdT{};

        SINOSRampData* m_pCmdBuf{};


        // factors


        real64 m_rKnf_s;

            //; factor : inc = pos * m_rKnf_s

        real64 m_rKnf_1s;

            //; factor : pos = inc * m_rKnf_1s

        real64 m_rKnf_1sEx;

            //; factor : posex = inc * m_rKnf_1sEx

        real64 m_rKnf_1v;

            //; factor : pos/s = inc/t * m_rKnf_1v

        real64 m_rKnf_1vf;

            //; factor : pos/s = inc/t * m_rKnf_1v / filter size

        real64 m_rKnf_1a;

            //; factor : pos/s^2 = inc/t^2 * m_rKnf_1a


        int64 m_iPosition;

            //; internal 64 bit position

        real64 m_rPositionFract;

            //; internal fractional part of m_iPosition

        int64 m_iPositionEx;

            //; internal 64 bit positionex

        int32 m_iOldS;

            //; old S [inc]

        int32 m_iOldSEx;

            //; old S ex[inc]

        int32 m_iOlderS;

            //; older S [inc]

        int32* m_pSarray;

            //; pointer to S array (used for V filter

        uint16 m_uSarraySize;

            //; size of S array

        uint16 m_uSarrayIndex;

            //; index in S array

        uint32 m_uCharacteristics;

            //; inco registration characteristics

        uint32 m_uDelayToHalt;

            //; delay [ticks] before switching from run to halt parameters

        int32 m_iDelayToHalt;

            //; actual delay [ticks]


        // sync data

        real64 m_rSyncPos;

            //; requested sync position

        real64 m_rSyncCor;

            //; correction made at sync

        uint32 m_uSyncCnt;

            //; number of sync's made

        int32 m_iSyncInc;

            //; requested sync position [inc]

        real64 m_rNormPos;

            //; requested norm position

        uint32 m_uNormInc;

            //; norm incs

        static char m_cStateCombo[494];

            //; controller state INCO item text. Use 494 (=defMaxDataLength). I

            //; fear to include inco_com.h here, that's why a plain number is

            //; used)


        // extended error/warning handling


        enum {

            eExtErWrUnknown,

            eExtErWrNo,

            eExtErWrYes

        } m_eExtErWr;


        // local copy of sync enable

        bool m_bSyncEnb;


        // oscillation checking

        CINOSOscillationDetector* m_pOsciChk;


        // enable supervision

        uint32* m_pDiEnable = nullptr;

        uint32 m_uDiEnableMask = 0;

        inosName64 m_cDiEnable{};


        // safety

        #ifdef INOS_SAFETY_SUPPORT


        // micromove related members

        CINOSJerkRamp m_MicroMoveRamp {};

            //; ramp used to pre-calculate micromoves

        bool m_bMicroMoveParamsValid = false;

            //; flag indicating if micromove params are valid

        bool m_bMicroMoveReturning = false;

            //; flag indicating if micromove is in the "move back" phase

        real64 m_rMicroMoveDistance = 0;

            //; relative distance (one-way) for micromoves [axis units]


        #endif // INOS_SAFETY_SUPPORT


    // allow dynamic object handling (new/delete)

    DECLARE_DYNAMIC(CINOSBaseControl);

};


//------------------------------------------------------------------------------

// helper macros

//------------------------------------------------------------------------------


#define INOS_BASECONTROL_UPDATE_CMD_BUFFER()\

    if (nullptr != m_pCmdBuf) {\

        m_uCmdWrt = (m_uCmdWrt + 1) & m_uCmdMsk;\

        m_pCmdBuf[m_uCmdWrt].m_rS = apData->m_rS;\

        m_pCmdBuf[m_uCmdWrt].m_rV = apData->m_rV;\

        m_pCmdBuf[m_uCmdWrt].m_rA = apData->m_rA;\

        m_pCmdBuf[m_uCmdWrt].m_rJ = apData->m_rJ;\

    }\


//------------------------------------------------------------------------------

// class registration

//------------------------------------------------------------------------------


typedef CINOSBaseControl *(*TCreateControl)(const char* apAxisName);


class CINOSRegisterBaseControl

{

    // after this function you can register new controllers

    friend void _INI_0000_CINOSBaseControl();


    //--- internals --------------------------------------------------------


    // private members

private:

    // pointer to the first registered controller

    static CINOSRegisterBaseControl* m_pFirst;

    // pointer to the next controller

    CINOSRegisterBaseControl* m_pNext;

    // create funtion for the controller

    TCreateControl m_pCreate;

    // controller type name

    const char* m_pControlType;


    //--- user interface ---------------------------------------------------


public:

    // register a new controller type

    CINOSRegisterBaseControl(TCreateControl apFunction,

        const char* apControlType);


    // create and return and new controller instance

    static CINOSBaseControl* GetControl(const char* apAxisName,

        const char* apControlType);

};


//------------------------------------------------------------------------------

// end of file

//------------------------------------------------------------------------------


#endif  // INC_CINOSBASECONTROL_H

cinosjerkramp.h
CINOSJerkRamp declaration file.

DECLARE_DYNAMIC
#define DECLARE_DYNAMIC(aClass)
Definition cinospartitionmemory.h:328

cinosprocessimage.h
Short comment.

CINOSAdcChannel
Definition cinosadcchannel.h:53

CINOSBaseControl
Definition cinosbasecontrol.h:319

CINOSBaseControl::m_uMaskCfgSynced
uint32 m_uMaskCfgSynced
synced mask
Definition cinosbasecontrol.h:765

CINOSBaseControl::GetActVelocity
virtual void GetActVelocity(real64 &arVelocity, bool abFiltered=false)
get actual position fast

CINOSBaseControl::m_pOutActivate
CINOSBit * m_pOutActivate
pointer to activate output
Definition cinosbasecontrol.h:705

CINOSBaseControl::m_rOutSerrorRawGain
real64 m_rOutSerrorRawGain
serror raw gain
Definition cinosbasecontrol.h:751

CINOSBaseControl::m_pInpActivated
CINOSBit * m_pInpActivated
pointer to activated input
Definition cinosbasecontrol.h:722

CINOSBaseControl::m_pOutTrqCurrent
CINOSDacChannel * m_pOutTrqCurrent
pointer to trqcurrent output
Definition cinosbasecontrol.h:753

CINOSBaseControl::m_pInpSynced
CINOSBit * m_pInpSynced
pointer to synced input
Definition cinosbasecontrol.h:732

CINOSBaseControl::m_uMaskCfgWarning
uint32 m_uMaskCfgWarning
warning mask
Definition cinosbasecontrol.h:763

CINOSBaseControl::m_pOutCurLimit
CINOSBit * m_pOutCurLimit
pointer to currentlimit bit
Definition cinosbasecontrol.h:711

CINOSBaseControl::m_pInpWarning
CINOSBit * m_pInpWarning
pointer to warning input
Definition cinosbasecontrol.h:726

CINOSBaseControl::m_pOutCurAdd
CINOSBit * m_pOutCurAdd
pointer to current add bit
Definition cinosbasecontrol.h:713

CINOSBaseControl::m_pOutCurCmd
CINOSBit * m_pOutCurCmd
pointer to current cmd bit
Definition cinosbasecontrol.h:715

CINOSBaseControl::SetLifetimeDistance
void SetLifetimeDistance(real64 arDistance)
set lifetime distance (only used at startup by either mcrobot or user code)

CINOSBaseControl::m_pOutSpeed
CINOSDacChannel * m_pOutSpeed
pointer to speed output
Definition cinosbasecontrol.h:741

CINOSBaseControl::m_pOutSyncEnbEx
CINOSBit * m_pOutSyncEnbEx
pointer to extended sync enable output
Definition cinosbasecontrol.h:709

CINOSBaseControl::SetAxisEnableInput
void SetAxisEnableInput(const char *apInputName)
set name of axis enable input

CINOSBaseControl::m_iLifetimeDistance
int64 m_iLifetimeDistance
lifetime distance in inc
Definition cinosbasecontrol.h:819

CINOSBaseControl::m_pOutPosRelax
CINOSBit * m_pOutPosRelax
pointer to pos relax (used at border)
Definition cinosbasecontrol.h:717

CINOSBaseControl::m_pInpSync
CINOSBit * m_pInpSync
pointer to sync input
Definition cinosbasecontrol.h:736

CINOSBaseControl::GetLifetimeDistance
void GetLifetimeDistance(real64 &arDistance)
get current lifetime distance

CINOSBaseControl::m_rOutSpeedRawGain
real64 m_rOutSpeedRawGain
speed raw gain
Definition cinosbasecontrol.h:745

CINOSBaseControl::m_uMaskCfgError
uint32 m_uMaskCfgError
error mask
Definition cinosbasecontrol.h:761

CINOSBaseControl::Connect
virtual uint32 Connect()
Connect control to hardware.

CINOSBaseControl::m_pInpUccOk
CINOSBit * m_pInpUccOk
pointer to ucc ok input
Definition cinosbasecontrol.h:738

CINOSBaseControl::m_pInpAutoCom
CINOSBit * m_pInpAutoCom
pointer to autocom input
Definition cinosbasecontrol.h:724

CINOSBaseControl::m_pOutSerror
CINOSDacChannel * m_pOutSerror
pointer to error output
Definition cinosbasecontrol.h:747

CINOSBaseControl::m_pInpSyncDeltaOk
CINOSBit * m_pInpSyncDeltaOk
pointer to syncdeltaok input
Definition cinosbasecontrol.h:734

CINOSBaseControl::m_pOutSerrorRaw
void * m_pOutSerrorRaw
pointer to error output
Definition cinosbasecontrol.h:749

CINOSBaseControl::m_pInpError
CINOSBit * m_pInpError
pointer to error input
Definition cinosbasecontrol.h:728

CINOSBaseControl::m_pInpFatalError
CINOSBit * m_pInpFatalError
pointer to fatal error input
Definition cinosbasecontrol.h:730

CINOSBaseControl::m_pOutSyncEnb
CINOSBit * m_pOutSyncEnb
pointer to sync enable output
Definition cinosbasecontrol.h:707

CINOSBaseControl::m_pInpTrqCurrent
CINOSAdcChannel * m_pInpTrqCurrent
pointer to trqcurrent input
Definition cinosbasecontrol.h:756

CINOSBaseControl::iSetAxisEnableInput
bool iSetAxisEnableInput()
set name of axis enable input

CINOSBaseControl::GetAxisEnableInput
void GetAxisEnableInput(char *apResult, uint32 auSize) const
get name of axis enable input

CINOSBaseControl::m_pOutCoupled
CINOSBit * m_pOutCoupled
pointer to coupled
Definition cinosbasecontrol.h:719

CINOSBaseControl::m_pOutSpeedRaw
void * m_pOutSpeedRaw
pointer to speed output
Definition cinosbasecontrol.h:743

CINOSBaseRamp
Definition cinosbaseramp.h:752

CINOSBit
Definition cinosbit.h:54

CINOSBus
Definition cinosbus.h:600

CINOSDacChannel
Definition cinosdacchannel.h:52

CINOSJerkRamp
definition of the CINOSJerkRamp class
Definition cinosjerkramp.h:72

CINOSPhysicalAxis
Provides physical aka real axis functionality.
Definition cinosphysicalaxis.h:286

CINOSPosChannel
Definition cinosposchannel.h:59

CINOSRegisterBaseControl
Definition cinosbasecontrol.h:976

INOS_INLINE
#define INOS_INLINE
Definition inosdefine.h:60

INOS_OR
#define INOS_OR(variable, mask)
Definition inosmacro.h:201

INOS_AND
#define INOS_AND(variable, mask)
Definition inosmacro.h:210

SINOSBaseControl
Descriptor structure used to configure a controller. It is usually defined in a corresponding xxx....
Definition cinosbasecontrol.h:197

SINOSBaseControl::m_rCycleTime
real64 m_rCycleTime
Axis cycletime the controller generator should work with [ms]. Do not configure this value in modern ...
Definition cinosbasecontrol.h:228

SINOSBaseControl::m_uOversampling
uint8 m_uOversampling
Requested oversampling, e.g. axis sampling rate is 96kHz and fieldbus cycle time 16kHz -> oversamplin...
Definition cinosbasecontrol.h:290

SINOSBaseControl::m_cUnit
inosName m_cUnit
Axis unit, e.g. m, mm, deg, ... The string has no special meaning and is just for displaying purposes...
Definition cinosbasecontrol.h:221

SINOSBaseControl::m_rSmaxRun
real64 m_rSmaxRun
factor to calculate max. allowed position error at move maxSerr = m_rSmax*(1.0 + m_rSmaxRun*(V/Vmax))
Definition cinosbasecontrol.h:245

SINOSBaseControl::m_cPosName
inosName64 m_cPosName
Position channel name. If working with Indel motor controllers this name is equal to the axis name.
Definition cinosbasecontrol.h:205

SINOSBaseControl::m_rSmax
real64 m_rSmax
Max. allowed position check error [unit].
Definition cinosbasecontrol.h:240

SINOSBaseControl::m_rMicroMoveTime
real64 m_rMicroMoveTime
Duration used for a 'micromove' in milliseconds (one-way, e.g. moving there and back again takes twic...
Definition cinosbasecontrol.h:300

SINOSBaseControl::m_uVfilter
uint8 m_uVfilter
Size of requested speed filter.
Definition cinosbasecontrol.h:285

SINOSBaseControl::m_rPosExUnitsPerInc
real64 m_rPosExUnitsPerInc
Units per increment factor for a possible extended position channel.
Definition cinosbasecontrol.h:253

SINOSBaseControl::m_rDelayToHalt
real64 m_rDelayToHalt
Delay [ms] before the controller should switch from run to halt parameters.
Definition cinosbasecontrol.h:249

SINOSBaseControl::m_rDeadTime
real64 m_rDeadTime
Controller dead time [ms]. is calculated incrementally to the fieldbus delays if option DF_INOS_BASE_...
Definition cinosbasecontrol.h:236

SINOSBaseControl::m_cEnbName
inosName64 m_cEnbName
Optional enable input channel name. This parameter can be used to define the name of a digital input,...
Definition cinosbasecontrol.h:216

SINOSBaseControl::m_uDigits
uint8 m_uDigits
Number of digits to use in INCO explorer. This parameter has no functional meaning and has just displ...
Definition cinosbasecontrol.h:281

SINOSBaseControl::m_cDacName
inosName64 m_cDacName
Optional dac channel name. This parameter is only used if one uses a stone aged analog interface to a...
Definition cinosbasecontrol.h:210

SINOSBaseControl::m_cName
inosName64 m_cName
Axis name.
Definition cinosbasecontrol.h:200

SINOSBaseControl::m_uOptions
uint32 m_uOptions
Controller options, see DF_INOS_BASE_CONTROL_OPT_DEAD_INC, DF_INOS_BASE_CONTROL_OPT_POS_OVRS,...
Definition cinosbasecontrol.h:276

SINOSRampDataEx
extended ramp data
Definition cinosbaseramp.h:617

SINOSRampData
ramp data
Definition cinosbaseramp.h:602