cinoscontrol.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSCONTROL_H
#define INC_CINOSCONTROL_H
//
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
// --- controller states -------------------------------------------------------
//
#define DF_INOS_CTRL_STATE_UNDEFINED    0   // static state 'undefined'
#define DF_INOS_CTRL_STATE_ACTIVE       1   // static state 'active'
#define DF_INOS_CTRL_STATE_READY        2   // static state 'ready'
#define DF_INOS_CTRL_STATE_PULL         3   // static state 'pull'
#define DF_INOS_CTRL_STATE_ACTIVATING   8   // dynamic state 'activating'
#define DF_INOS_CTRL_STATE_INACTIVATING 9   // dynamic state 'inactivating'
#define DF_INOS_CTRL_STATE_MOVING       11  // dynamic state 'moving'
#define DF_INOS_CTRL_STATE_TOGGLE       13  // dynamic state 'toggle'
#define DF_INOS_CTRL_STATE_STOPPING     14  // dynamic state 'stopping'
#define DF_INOS_CTRL_STATE_TUNING       32  // dynamic state 'tuning'
#define DF_INOS_CTRL_STATES             33  // number of states
//
// --- controller commands -----------------------------------------------------
//
#define DF_INOS_CTRL_CMD_ACTIVATE   0x00000001  // command 'Activate'
#define DF_INOS_CTRL_CMD_INACTIVATE 0x00000002  // command 'InActivate'
#define DF_INOS_CTRL_CMD_MOVE       0x00000008  // command 'Move'
#define DF_INOS_CTRL_CMD_STOP       0x00000020  // command 'Stop'
#define DF_INOS_CTRL_CMD_UPDATE     0x00000200  // command 'Update'
#define DF_INOS_CTRL_CMD_TOGGLE     0x00000400  // command 'Toggle'
#define DF_INOS_CTRL_CMD_CURSOR     0x00008000  // command 'Cursor'
#define DF_INOS_CTRL_CMD_TUNE       0x00010000  // command 'Tune'
//
// --- controller errors -------------------------------------------------------
//
#define ER_INOS_CTRL_REJECTED       0x00000001  // command rejected
#define ER_INOS_CTRL_FAILED         0x00000002  // command failed
#define ER_INOS_CTRL_REMOTE_NOT_FOUND   0x00000004  // remote target not found
#define ER_INOS_CTRL_REMOTE_OFFLINE     0x00000008  // remote target offline
#define ER_INOS_CTRL_REMOTE_COMM_ERR    0x00000010  // remote target communication error
#define ER_INOS_CTRL_REMOTE_REJECTED  0x00000020  // attached to remote, command rejected
#define ER_INOS_CTRL_GROUP          0x00000800  // group member on error
#define ER_INOS_CTRL_BUS            0x00001000  // fieldbus on error
#define ER_INOS_CTRL_TARGET         0x00002000  // target on error
#define ER_INOS_CTRL_CONTROL        0x00004000  // control error pending
#define ER_INOS_CTRL_RAMP           0x00008000  // ramp error pending
#define ER_INOS_CTRL_SAFETY         0x00010000  // safety error pending
#define ER_INOS_CTRL_APPLICAT       0x00020000  // application specific error pending
 
#define ER_INOS_CTRL_REMOTE (ER_INOS_CTRL_REMOTE_NOT_FOUND | ER_INOS_CTRL_REMOTE_OFFLINE | ER_INOS_CTRL_REMOTE_COMM_ERR | ER_INOS_CTRL_REMOTE_REJECTED)
//
// --- controller warnings -----------------------------------------------------
//
#define WR_INOS_CTRL_RAMP           0x00008000  // ramp warning pending
#define WR_INOS_CTRL_CONTROL        0x00004000  // control warning pending
#define WR_INOS_CTRL_IGNORED        0x00000001  // command ignored
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <cinosbus.h>
#include <cinosbaseramp.h>
#include <cinosbasecontroller.h>
//
// C++
//
// project
//
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSControl;
class CINOSControlParamSet
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
        virtual uint32 SetParam(const char* apName, real64 arValue);
            //; universal set parameter with aName to aValue and return error code
        virtual uint32 GetParam(const char* apName, real64& arResult);
            //; universal get parameter with aName to aResult and return error code
        virtual CINCOObject* GetRegister(CINOSControl* apControl);
            //; return pointer to my inco object
 
        virtual CINOSBaseRampParamSet* GetRamp() {return m_pRamp;};
 
    //--- internals --------------------------------------------------------
 
    // my axis is my friend
    friend class CINOSControl;
    
    // public but just for internal use
    public:
        int operator < (CINOSControlParamSet& aSet) const
            { return (strcmp(m_cName, aSet.m_cName)<0);}
        int operator == (CINOSControlParamSet& aSet) const
            { return (strcmp(m_cName, aSet.m_cName)==0);}
        int operator < (const char* apName) const
            { return (strcmp(m_cName, apName)<0);}
        int operator == (const char* apName) const
            { return (strcmp(m_cName, apName)==0);}
        friend int operator == (CINOSControlParamSet& aSet1, CINOSControlParamSet& aSet2)
            { return (strcmp(aSet1.m_cName, aSet2.m_cName)==0);}
 
    // public but just for internal use
    public:
        explicit CINOSControlParamSet(const char* apName);
            //; constructor
        virtual ~CINOSControlParamSet();
            //; destructor
 
    // protected members
    protected:
        inosName32 m_cName;
            //; set name
        CINCOObject* m_pRegister;
            //; pointer to inco registration of set
        CINOSBaseRampParamSet* m_pRamp;
            //; pointer to ramp param set
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSControlParamSet);
};
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
struct SINOSControlErrorHook;
struct SINOSCollectedControlData;
 
class CINOSControl
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        // constructor/destructor
 
        CINOSControl(const char* apName, const char* apRamp, 
            const char* apController, const char* apInpName, const char* apOutName);
            //; constructor
        virtual ~CINOSControl();
            //; destructor
        static CINOSControl* GetControl(uint32 auIndex);
            //; return pointer to controller auNumber or NULL if not found
        static CINOSControl* GetControl(const char* apName);
            //; return pointer to controller apName or NULL if not found
        static CINOSControl* Find(const char* apName);
        static uint32 Add(CINOSControl* apControl);
        static uint32 Remove(CINOSControl* apControl);
        
        virtual uint32 Activate(bool abCheckVal = true, bool abSimulateVal = false,
            bool abSimulateOut = false, bool abSimulateAct = false, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; activate axis
        virtual uint32 InActivate(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; inactivate axis
        virtual uint32 ReActivate(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; reactivate axis
        
        virtual void CreateRemoteTargetControl(const char* apTarget,
                real64 arRemoteUpdateTime,
                CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual void AttachRemoteTargetControl(const char* apTarget,
            real64 arRemoteUpdateTime,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        virtual uintptr DoCollectData();
            //; start collecting data in every control cycle
 
        // moving functions
 
        virtual uint32 Move(real64 arValue, 
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; move to value with commanded jerk, acc/deceleration and velocity
        virtual uint32 Move(real64 arValue, SINOSRampParam* apParam,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; move to value with apParam
        virtual uint32 Move(real64 arPosition, const char* apParam,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; move to value with apParam
        virtual uint32 Toggle(real64 arvalue, real64 arValue2);
            //; starts an endless toggle between pos1 and pos2
        virtual uint32 Update(CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
            //; update a running Move to actual commanded values (acc,dec,vel,jerk)
            //; signal apSync if constant velocity reached (acc = 0)
        virtual uint32 Update(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
            //; update a running Move to apParam values (acc,dec,vel,jerk)
            //; signal apSync if constant velocity reached (acc = 0)
        virtual uint32 Update(const char* apParam, CINOSSync* apSync = DF_INOS_ASYNCHRONOUS);
            //; update a running Move to apParam values (acc,dec,vel,jerk)
            //; signal apSync if constant velocity reached (acc = 0)
        virtual real64 GetMoveTime(real64 arValue);
            //; return time [sec] a Move(arValue) needs until arValue
        virtual real64 GetMoveTime(real64 arValue, SINOSRampParam* apParam);
            //; return time [sec] a Move(arValue) needs until arValue
        virtual real64 GetMoveTime(real64 arValue, const char* apParam);
            //; return time [sec] a Move(arValue) needs until arValue
        virtual real64 GetMoveTime(real64 arValue, real64 arDelta);
            //; return time [sec] a Move(arValue) needs until arValue-arDelta
        virtual real64 GetMoveTime(real64 arValue, real64 arDelta, SINOSRampParam* apParam);
            //; return time [sec] a Move(arValue) needs until arValue-arDelta
        virtual real64 GetMoveTime(real64 arValue, real64 arDelta, const char* apParam);
            //; return time [sec] a Move(arValue) needs until arValue-arDelta
        virtual real64 GetMoveTime(real64 arStartValue, real64 arEndValue,
            real64 arDelta);
            //; return time [sec] a Move needs from arStartValue
            //; until arEndValue-arDelta
        virtual real64 GetMoveTime(real64 arStartValue, real64 arEndValue,
            real64 arDelta, SINOSRampParam* apParam);
            //; return time [sec] a Move needs from arStartValue
            //; until arEndValue-arDelta
        virtual real64 GetMoveTime(real64 arStartValue, real64 arEndValue,
            real64 arDelta, const char* apParam);
            //; return time [sec] a Move needs from arStartValue
            //; until arEndValue-arDelta
        virtual uint32 GetMoveTicks(real64 arValue);
            //; return bus ticks a Move(arValue) needs until arValue
        virtual uint32 GetMoveTicks(real64 arPosition, SINOSRampParam* apParam);
            //; return bus ticks a Move(adPosition) needs until arValue
        virtual uint32 GetMoveTicks(real64 arValue, const char* apParam);
            //; return bus ticks a Move(adPosition) needs until arValue
        virtual uint32 GetMoveTicks(real64 arValue, real64 arDelta);
            //; return bus ticks a Move(adPosition) needs until arValue-arDelta
        virtual uint32 GetMoveTicks(real64 arValue, real64 arDelta, SINOSRampParam* apParam);
            //; return bus ticks a Move(adPosition) needs until arValue-arDelta
        virtual uint32 GetMoveTicks(real64 arValue, real64 arDelta, const char* apParam);
            //; return bus ticks a Move(adPosition) needs until arValue-arDelta
        virtual uint32 GetMoveTicks(real64 arStartValue, real64 arEndValue,
            real64 arDelta);
            //; return bus ticks [sec] a Move needs from arStartValue
            //; until arEndValue-arDelta
        virtual uint32 GetMoveTicks(real64 arStartValue, real64 arEndValue,
            real64 arDelta, SINOSRampParam* apParam);
            //; return bus ticks [sec] a Move needs from arStartValue
            //; until arEndValue-arDelta
        virtual uint32 GetMoveTicks(real64 arStartValue, real64 arEndValue,
            real64 arDelta, const char* apParam);
            //; return bus ticks [sec] a Move needs from arStartValue
            //; until arEndValue-arDelta
        virtual real64 GetMoveDist(real64 arValue, real64 arTime);
            //; return distance [unit] a Move(arValue) progresses in arTime [sec]
        virtual real64 GetMoveDist(real64 arValue, real64 arTime,
            SINOSRampParam* apParam);
            //; return distance [unit] a Move(arValue) progresses in arTime [sec]
        virtual real64 GetMoveDist(real64 arValue, real64 arTime,
            const char* apParam);
            //; return distance [unit] a Move(arValue) progresses in arTime [sec]
        virtual real64 GetMoveDist(real64 arValue, uint32 auTicks);
            //; return distance [unit] a Move(arValue) progresses in auTicks [bus ticks]
        virtual real64 GetMoveDist(real64 arValue, uint32 auTicks,
            SINOSRampParam* apParam);
            //; return distance [unit] a Move(arValue) progresses in auTicks [bus ticks]
        virtual real64 GetMoveDist(real64 arValue, uint32 auTicks,
            const char* apParam);
            //; return distance [unit] a Move(arValue) progresses in auTicks [bus ticks]
        virtual real64 GetMoveDist(real64 arStartValue, real64 arEndValue,
            real64 arTime);
            //; return distance [unit] a Move from arStartValue to arEndValue
            //; progresses in arTime [sec]
        virtual real64 GetMoveDist(real64 arStartValue, real64 arEndValue,
            real64 arTime, SINOSRampParam* apParam);
            //; return distance [unit] a Move from arStartValue to arEndValue
            //; progresses in arTime [sec]
        virtual real64 GetMoveDist(real64 arStartValue, real64 arEndValue,
            real64 arTime, const char* apParam);
            //; return distance [unit] a Move from arStartValue to arEndValue
            //; progresses in arTime [sec]
        virtual real64 GetMoveDist(real64 arStartValue, real64 arEndValue,
            uint32 auTicks);
            //; return distance [unit] a Move from arStartValue to arEndValue
            //; progresses in auTicks [bus ticks]
        virtual real64 GetMoveDist(real64 arStartValue, real64 arEndValue,
            uint32 auTicks, SINOSRampParam* apParam);
            //; return distance [unit] a Move from arStartValue to arEndValue
            //; progresses in auTicks [bus ticks]
        virtual real64 GetMoveDist(real64 arStartValue, real64 arEndValue,
            uint32 auTicks, const char* apParam);
            //; return distance [unit] a Move from arStartValue to arEndValue
            //; progresses in auTicks [bus ticks]
        virtual uint64 GetTargetTicks();
            //; return absolut bus ticks the actual move reaches the target
 
        // pulling
 
        virtual uint32 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
        void EnableRamp()
            //; enable ramp geni
            { m_pRamp->Enable();};
        void DisableRamp()
            //; disable ramp geni (needed to be able to fill up pull list without
            //; starting immediately)
            { m_pRamp->Disable();};
 
        // stop/break/continue functions
 
        virtual uint32 Stop(CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; stop move with acc/deceleration
        virtual uint32 Stop(SINOSRampParam* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; stop move with acc/deceleration
        virtual uint32 Stop(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; stop move with acc/deceleration
        virtual uint32 Stop(real64 arValue,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; stop move with acc/deceleration at arValue
        virtual uint32 Stop(real64 arPosition, SINOSRampParam* apParam,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; stop move with acc/deceleration at arPosition
        virtual uint32 Stop(real64 arValue, const char* apParam,
            CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
            //; stop move with acc/deceleration at arValue
        
        // tuning
 
        virtual uint32 Tune(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
        virtual uint32 TuneAccept(const char* apParam, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        // get/set property functions
 
        virtual const char* GetName();
            //; return control name
        virtual const char* GetUnit();
            //; return control unit
        virtual uint32 GetCharacteristics();
            //; return control characteristics
        virtual void SetCmdValue(real64 arValue);
            //; set commanded controller value
        virtual void GetCmdValue(real64& arValue);
            //; get commanded controller value
        virtual void SetCmdVelocity(real64 arVelocity);
            //; set commanded velocity
        virtual void GetCmdVelocity(real64& arVelocity);
            //; get commanded velocity
        virtual void SetCmdAcceleration(real64 arAcceleration);
            //; set commanded acceleration
        virtual void GetCmdAcceleration(real64& arAcceleration);
            //; get commanded acceleration
        virtual void SetCmdDeceleration(real64 arDeceleration);
            //; set commanded deceleration       
        virtual void GetCmdDeceleration(real64& arDeceleration);
            //; get commanded deceleration
        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 GetCmdRealJerk(real64& arJerk, uint32 auNumber = 0);
            //; get commanded real jerk
        virtual void SetCmdSlowMotion(real64 arSlowMotion);
            //; set commanded slowmotion factor
        virtual void GetCmdSlowMotion(real64& arSlowMotion);
            //; get commanded slowmotion factor
        virtual uint32 SetActValue(real64 arValue);
            //; set actual commanded position
        virtual void GetActValue(real64& arValue);
            //; get actual commanded position
        virtual void GetActVelocity(real64& arVelocity);
            //; get actual commaned velocity
        virtual void GetActAcceleration(real64& arAcceleration);
            //; get actual commanded acceleration
        virtual void GetActJerk(real64& arJerk);
            //; get actual commanded jerk
        virtual uint32 SetRealValue(real64 arValue);
            //; set actual real value
        virtual void GetRealValue(real64& arValue);
            //; get actual real value
        virtual void SetMinValue(real64 arValue);
            //; set min. allowed value
        virtual void GetMinValue(real64& arValue);
            //; get min. allowed value
        virtual void SetMaxValue(real64 arValue);
            //; set max. allowed value
        virtual void GetMaxValue(real64& arValue);
            //; get max. allowed value
        virtual void SetMaxVelocity(real64 arVelocity);
            //; set max. allowed velocity
        virtual void GetMaxVelocity(real64& arVelocity);
            //; get max. allowed velocity
        virtual void SetMaxAcceleration(real64 arAcceleration);
            //; set max. allowed acceleration
        virtual void GetMaxAcceleration(real64& arAcceleration);
            //; get max. allowed acceleration
        virtual void SetMaxDeceleration(real64 arDeceleration);
            //; set max. allowed deceleration
        virtual void GetMaxDeceleration(real64& arDeceleration);
            //; get max. allowed deceleration
        virtual void SetMaxJerk(real64 arJerk);
            //; set max. allowed jerk
        virtual void GetMaxJerk(real64& arJerk);
            //; get max. allowed jerk
        virtual void SetCycleTime(real64 arCycleTime);
            //; set controller cycle time [sec]
        virtual void GetCycleTime(real64& arCycleTime);
            //; get controller cycle time [sec]
        virtual uint16 GetCycleNumber();
            //; get controller cycle number
        virtual uint16 GetCycleId();
            //; get controller cycle id
        virtual uint8 GetBusId();
            //; get axis bus id
        virtual uint32 SetParam(const char* apName, real64 arValue);
            //; universal set parameter with aName to aValue and return error code
        virtual uint32 GetParam(const char* apName, real64& arResult);
            //; universal get parameter with aName to aResult and return error code
        virtual volatile real64* GetParamAdr(const char* apName);
            //; universal get address of parameter with aName or NULL if not found
        void SetFlag(uint32 auFlag)
            { INOS_OR(m_uFlag, auFlag);};
            //; set controller flags
        void ClrFlag(uint32 auFlag)
            { INOS_AND(m_uFlag, ~auFlag);};
            //; clear controller flags
        uint32 GetFlag()
            { return m_uFlag;};
            //; get controller flags
        virtual uint32 GetState();
            //; get controller state
        virtual uint32 GetState(uint32& auRmpState, uint32& auCtrState);
            //; get controller, ramp and controller state
        virtual uint32 GetError();
            //; get controller error
        virtual uint32 GetError(uint32& auRmpError, uint32& auCtrState);
            //; get controller, ramp and controller error
        virtual uint32 GetWarning();
            //; get controller warning
        virtual uint32 GetWarning(uint32& auRmpWarning, uint32& auCtrWarning);
            //; get controller, ramp and controller warning
        virtual void AcceptError();
            //; accept all errors
        virtual void AcceptError(uint32 auError);
            //; accept error
        virtual void AcceptError(uint32 auError, uint32 auRmpError, uint32 auCtrError);
            //; accept error
        virtual void AcceptWarning();
            //; accept all warnings
        virtual void AcceptWarning(uint32 auWarning);
            //; accept warning
        virtual void AcceptWarning(uint32 auWarning, uint32 auRmpWarning, uint32 auCtrError);
            //; accept warning
 
        // param set functions
        virtual void eCreateParamSet(const char* apSetName);
            //; Same as CreateParamSet but for INCO registration (as it doesn't return 
            //; a pointer)
        virtual CINOSControlParamSet* CreateParamSet(const char* apSetName);
            //; create new param set with name apSetName and return pointer to it
        virtual void DestroyParamSet(const char* apSetName);
            //; destroy param set with name apSetName
        virtual bool SelectParamSet(const char* apSetName);
            //; select param set with name apSetName
        virtual CINOSControlParamSet* GetParamSet(const char* apSetName);
            //; get pointer to param set with name apSetName
 
        static void eCreateGlobalParamSet(const char* apSetName);
            //; Same as CreateGlobalParamSet but for INCO registration (as it doesn't return 
            //; a pointer)
        static CINOSControlParamSet* CreateGlobalParamSet(const char* apSetName);
            //; create new param set with name apSetName and return pointer to it
        static void DestroyGlobalParamSet(const char* apSetName);
            //; destroy param set with name apSetName
        static CINOSControlParamSet* GetGlobalParamSet(const char* apSetName);
            //; get pointer to param set with name apSetName
 
        // miscellaneous functions
 
        virtual CINCOObject* GetRegister();
            //; do inco registration and return pointer to it
        virtual void SetRamp(CINOSBaseRamp* apRamp);
            //; set new ramp geni   
        CINOSBaseRamp* GetRamp()
            { return m_pRamp;};
            //; return pointer to ramp geni 
        virtual uintid RegisterErrorHook(void* apHandler, void* apObject = 0);
            //; register error hook and return hook id
        virtual void UnRegisterErrorHook(uintid auHookId);
            //; unregister error hook 
        virtual const char* GetInputName();
            //; return control input name
        virtual const char* GetOutputName();
            //; return control output name
        virtual const char* GetEnbOutputName();
            //; return enable output name
        virtual const char* GetActivateOutputName();
            //; return output name for m_pActiveOutput
 
        static void SetBusError();
            //; bus error occured
        static void AcceptBusError();
            //; accept bus error
        static void SetSafetyError();
            //; safety error occured
        static void AcceptSafetyError();
            //; accept safety error
        static void SetApplicationError();
            //; target error occured
        static void AcceptApplicationError();
            //; accept application error
 
        virtual void UpdateIncoItems(bool i_bForceUpdate);
        
        CINOSBaseController* GetController() { return m_pController; }
            //; return controller       
        
    //--- internals --------------------------------------------------------
 
    friend void _INI_0400_CINOSControl();
    friend class CINOSRemoteControlWorker;
    
    // operators (for binary tree of shapes)
    public:
        int operator < (CINOSControl& aControl)
            { return (strcmp(GetName(), aControl.GetName())<0);}
        int operator == (CINOSControl& aControl)
            { return (strcmp(GetName(), aControl.GetName())==0);}
        int operator < (const char* aName)
            { return (strcmp(GetName(), aName)<0);}
        int operator == (const char* aName)
            { return (strcmp(GetName(), aName)==0);}
 
    // protected member functions
    protected:
        void Signal(CINOSSync*& apSync);
            //; signal sync object if requested
        virtual void SetError(uint32 auErrors);
            //; set axis error (and call error hook if nessecary)
        bool Enter(uint32 auCommand, CINOSSync* apSync = 0);
            //; check if command allowed in current state and return false if not
        void Exit ();
            //; leave critical section
        void Exit (CINOSSync*& apCmdSync, CINOSSync* apSync);
            //; leave critical section and wait if nessecary
        bool IsCritical()
            { return m_CmdLock.GetOwner() != 0;};
            //; return true if somebody stays in critical section
        virtual void iInActivate();
            //; inactivate controller
        virtual void iStop(SINOSRampParam* apParam);
            //; internal stop
        virtual SINOSRampParam* iGetRampParam(const char* apSetName);
            //; get pointer to ramp param of set apSetName
        virtual void iControl();
            //; main control handler
        virtual void iPostWrite();
            //; post bus write handler 
        static void SetTargetError();
            //; target error occured
        void OnTargetError();
            //; target error occured
        void OnBusError();
            //; bus error occured
        void OnSafetyError();
            //; safety error occured
        void OnApplicationError();
            //; safety error occured
        CINOSBit* SearchOutput(const char* apName) const;
            //; searches an output in the 'g_pOutputs', 'g_pFlags' and creates
            //; creates it as a new flag if it doesn't exist.
        virtual void CallErrorHooks();
            //; call error hooks
 
    // private member functions (external versions, because until now we are not
    // able to register functions with default parameters)
    private:
        CINOSBus& GetBus();
            //; Gets this controller's INOS bus. Assertion fails if no bus is available
        void eActivate();
            //; activate controller
        void eActivate(bool abCheckVal, bool abSimulateVal, bool abSimulateOut,
            bool abSimulateAct);
            //; activate controller
        void eReActivate();
            //; reactivate controller
        void eInActivate();
            //; inactivate controller
        void eAttachRemoteTargetControl(const char* apTarget, real64 arRemoteUpdateTime, bool abCreate);
            //; create remote target controller
        void eMove(real64 arPosition, const char* apParam);
            //; move to position with acc/deceleration and velocity
        void eStop();
            //; stop move with acc/deceleration
        void eVal1();
            //; move to val 1 
        void eVal2();
            //; move to val 2
        void eToggle();
            //; toggle between pos 1 and pos 2
        void eAcceptError();
            //; accept all pending errors
        void eAcceptWarning();
            //; accept all pending warnings
        void eTune(const char* apParam);
            //; tune controller
        void eTuneAccept(const char* apParam);
            //; accept tune results
        void iToggling();
            //; toggle handler (called cyclic)
 
    // protected members
    protected:
        uint32 m_uState;
            //; actual state
        uint32 m_uSubState;
            //; actual sub state
        uint32 m_uNxtState;
            //; next state
        uint32 m_uPrvState;
            //; previous state
        uint32 m_uRmpState;
            //; state of ramp geni before GetSVAJ
        uint32 m_uError;
            //; actual errors
        uint32 m_uErrorDis;
            //; actual disabling errors
        uint32 m_uErrorMask;
            //; actual error mask
        uint32 m_uMaskFatal;
            //; mask of fatal errors
        uint32 m_uWarning;
            //; actual warnings
        uint32 m_uWarningMask;
            //; actual warning mask
        uint32 m_uFlag;
            //; controller flags
 
        inosName64 m_cName;
            //; control name
        CINCOObject* m_pRegister;
            //; pointer to inco registration
        CINCOObject* m_pCommand;
            //; pointer to inco registration of commands
        CINCOObject* m_pTest;
            //; pointer to inco registration of controller test
        CINCOObject* m_pError;
            //; pointer to inco registration of errors
        CINCOObject* m_pErrorDis;
            //; pointer to inco registration of disabling errors
        CINCOObject* m_pErrorMask;
            //; pointer to inco registration of error mask
        CINCOObject* m_pWarning;
            //; pointer to inco registration of warnings
        CINCOObject* m_pWarningMask;
            //; pointer to inco registration of warning mask
        CINCOObject* m_pFlag;
            //; pointer to inco registration of controller flags
        CINCOObject* m_pState;
            //; pointer to inco registration of controller state
        CINOSBaseRamp* m_pRamp;
            //; pointer to ramp generator
        CINOSBaseController* m_pController;
            //; pointer to controller
        CINOSMutex m_CmdLock;
            //; mutex to guarantee mutual exclusion in command handling
        CINOSSync* m_pActivate;
            //; pointer to synch object to be signaled on end of activate
        CINOSSync* m_pInActivate;
            //; pointer to synch object to be signaled on end of inactivate
        CINOSSync* m_pMove;
            //; pointer to synch object to be signaled on end of move
        CINOSSync* m_pStop;
            //; pointer to synch object to be signaled on end of stop
        CINOSSync* m_pVelocity;
            //; pointer to synch object to be signaled on velocity reached
        CINOSSync* m_pTune;
            //; pointer to synch object to be signaled on tune ended
        uintid m_uHookId;
            //; id of main hook
        uintid m_uPostHookId;
            //; id of post hook
        uintid m_uCmdHookId;
            //; id of command hooks (e.g. toggle)
        uintid m_uBusErrorHookId;
            //; id of bus error hook
        SINOSControlErrorHook* m_pErrorHooks;
            //; pointer to list of error hooks
        TINOSNameBalancedBinaryTree<CINOSControlParamSet>* m_pParamSets;
            //; pool of all param sets
        static TINOSNameBalancedBinaryTree<CINOSControlParamSet>* m_pGlobalParamSets;
            //; pool of all param sets
        real64 m_rCycleTimeMs;
            //; requested cycle time [ms]
        uint32 m_uCycleTime;
            //; cycletime [us]
        uint32 m_uHookTime;
            //; cycletime [us]
        uint32 m_uTimer;
            //; cycletime [us]   
        inosName64 m_cInputName;
            //; input name      
        inosName64 m_cOutputName;
            //; output name
        inosName64 m_cEnbOutputName;
            //; enable output name
        inosName64 m_cActivateOutputName;
            //; output name for m_pActiveOutput
        inosName64 m_cSelectedParamName;
            //; last selected param name
        inosName64 m_cRemoteTargetName;
            //; remote target name (using local control if empty).
        CINOSBusModule* m_pRemoteControlModule;
            //; remote target module (using local control if nullptr).
        uint32 m_uRemoteUpdateTime;
            //; requested remote update time [ms].
 
        CINOSBit* m_pEnbOutput;
            //; pointer to enable output
        CINOSBit* m_pActiveOutput;
            //; output will reflect the activation state. If controller
            //; is active, the output will be set, otherwise cleared.
        bool m_bEmgSet;
            //; true if I 've set the emg output
 
        // test values
        
        real64 m_rVal1;
            //; toggle value 1
        real64 m_rVal2;
            //; toggle value 2
        uint32 m_uDelay;
            //; delay in ms between toggles
        int32 m_iTicks;
            //; system ticks to handle delay
        
        bool m_bUpdatePending = false;
            //; remote INCO items need to be updated
        SINOSCollectedControlData* m_pCollectedData = nullptr;
            //; collected data pointer
        uint32 m_uRemoteCollectedDataAddr = 0;
            //; collected data address from remote target
        uint32 m_uRemoteCollectedDataVersion = 0;
            //; version of collected data frame used by remote target (sender)
    // command parameters
    private:
        uint32 m_uActivateCheckVal;
            //; param : CheckVal
        uint32 m_uActivateSimulateVal;
            //; param : SimulateVal
        uint32 m_uActivateSimulateOut;
            //; param : SimulateOut
        uint32 m_uActivateSimulateAct;
            //; param : SimulateAct
        real64 m_rMoveValue;
            //; param : Value
        inosName32 m_cMoveParam;
            //; param
        inosName32 m_cCreateRemoteControlTarget;
            //; param
        real64 m_cCreateRemoteControlUpdateTime;
        bool m_bCreate{false};
            //; remote target
        char m_cTuneParam[64];
            //; tune param
 
    // inco explorer methods
    private :
        static uint32 eCreate(char* apName, char* apRamp, char* apController,
            char* apInpName, char* apOutName);
        static uint32 eDestroy(char* apName);
 
    // static private members
    private:
        static TINOSNameBalancedBinaryTree<CINOSControl>* m_pControls;
        static CINCOObject* m_psRegister;
        static CINCOObject* m_psCmd;
        static CINCOObject* m_psEntity;
        static char m_ceName[64];
        static char m_ceRamp[32];
        static char m_ceController[32];
        static char m_ceInput[32];
        static char m_ceOutput[32];
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSControl);
};
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSCONTROL_H