cinosbasecontroller.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSBASECONTROLLER_H
#define INC_CINOSBASECONTROLLER_H
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
// --- controller states -------------------------------------------------------
//
#define DF_INOS_CONTROLLER_STATE_PEACE          0   // peace
#define DF_INOS_CONTROLLER_STATE_ACTIVATING     1   // activating
#define DF_INOS_CONTROLLER_STATE_ACTIVE         2   // active
#define DF_INOS_CONTROLLER_STATE_INACTIVATING   3   // inactivating
#define DF_INOS_CONTROLLER_STATE_TUNING         4   // tuning
//
// --- controller sub states ---------------------------------------------------
//
// sub states for state ACTIVE
#define DF_INOS_CONTROLLER_SUBSTATE_ACTIVE_HALT     0   // active halt
#define DF_INOS_CONTROLLER_SUBSTATE_ACTIVE_RUN      1   // active run
#define DF_INOS_CONTROLLER_SUBSTATE_ACTIVE_JUMP     2   // active jump
#define DF_INOS_CONTROLLER_SUBSTATE_ACTIVE_SETTLE   3   // active settle
//
// --- controller errors -------------------------------------------------------
//
#define ER_INOS_CONTROLLER_VALCHK       0x00000001  // controller value check error
#define ER_INOS_CONTROLLER_SETTLE       0x00000002  // settling timeout
#define ER_INOS_CONTROLLER_OUTCHN       0x00000800  // output channel not found
#define ER_INOS_CONTROLLER_INPCHN       0x00001000  // input channel not found
#define ER_INOS_CONTROLLER_ACTIVATE     0x00002000  // activation error
#define ER_INOS_CONTROLLER_EXTERN       0x00004000  // external controller error
#define ER_INOS_CONTROLLER_OFFLINE      0x00008000  // value channel offline
//
// --- controller warnings -----------------------------------------------------
//
#define WR_INOS_CONTROLLER_INTLIMIT     0x00000001  // integrator limit reached
#define WR_INOS_CONTROLLER_NOTSUP       0x00000002  // not supported
//
// --- controller flags --------------------------------------------------------
//                       
#define DF_INOS_BASE_CONTROLLER_FLAG_CHK_VAL        0x00000001  // check value error
#define DF_INOS_BASE_CONTROLLER_FLAG_SIM_VAL        0x00000002  // simulate actual value
#define DF_INOS_BASE_CONTROLLER_FLAG_SIM_OUT        0x00000004  // simulate output
#define DF_INOS_BASE_CONTROLLER_FLAG_SIM_ACT        0x00000008  // simulate activate
#define DF_INOS_BASE_CONTROLLER_FLAG_ENB_BLZ        0x00000010  // enable boltzmann feed forward
#define DF_INOS_BASE_CONTROLLER_FLAG_IGN_ALM_ACT    0x00000020
#define DF_INOS_BASE_CONTROLLER_FLAG_ZERO_INT_JUMP  0x00000040
#define DF_INOS_BASE_CONTROLLER_FLAG_KEEP_CMDS      0x20000000  // keep cmdS at activate
#define DF_INOS_BASE_CONTROLLER_FLAG_SUP_JFW        0x40000000  // supports jump forward
#define DF_INOS_BASE_CONTROLLER_FLAG_SUP_JBW        0x80000000  // supports jump backward
//
#define DF_INOS_BASE_CONTROLLER_MAX_V_FILTER    16          // max. allowed V filter length
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <cinosprocessimage.h>
#include <inco_com.h>
//
// C++
//
// project
//
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
struct SINOSRampData;
class CINOSControl;
class CINOSBaseController
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        // constructor/destructor
 
        CINOSBaseController(const char* apInpName, const char* apOutName);
            //; constructor
        virtual ~CINOSBaseController();
            //; destructor
        static CINOSBaseController* GetController(const char* apType,
            const char* apInpName, const char* apOutName);
            //; create controller of type 'apType' return pointer to it or NULL 
            //; if 'apType' not available
        
        // activate / inactivate
 
        virtual void Activate(bool abCheckVal = true, bool abSimulateVal = false,
            bool abSimulateOut = false, bool abSimulateAct = false);
            //; activate controller
        virtual void InActivate();
            //; inactivate controller
        
        // Tune
        
        virtual uint32 Tune(const char* apParam);
            //; tune controller
 
        // pull
 
        ICACHE virtual uint32 Pull(SINOSRampData* apData);
            //; follow apData
        ICACHE virtual uint32 Pull(real64 arValue, real64 arVelocity,
            real64 arAcceleration, real64 arJerk);
            //; follow arValue with arVelocity and arAcceleration
            
        virtual void GetCmdValue(real64& arValue);
            //; get commanded value
        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 SetActValue(real64 arValue, bool abIgnorePosError=false);
            //; set actual value to arValue
        ICACHE virtual void GetActValue(real64& arValue);
            //; get value
        virtual void GetActVelocity(real64& arVelocity);
            //; get actual velocity
        virtual void GetActAcceleration(real64& arAcceleration);
            //; get actual acceleration
        virtual void GetActJerk(real64& arJerk);
            //; get actual jerk
        virtual void GetActValError(real64& arValError);
            //; get actual value 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
                    
        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
        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
        virtual uint32 GetWarning();
            //; get controller warning
        virtual void AcceptError(uint32 auError=0xffffffff);
            //; accept controller error (auError=0xffffffff -> accept all errors)
        virtual void AcceptWarning(uint32 auWarning=0xffffffff);
            //; accept controller warning (auWarning=0xffffffff -> accept all warnings)
 
        virtual void GetCycleTime(real64& arCycleTime);
            //; get controller cycle time [sec]
        virtual void SetCycleTime(real64 arCycleTime);
            //; set controller cycle time [sec]
        virtual uint16 GetCycleNumber();
            //; get controller cycle number
        virtual uint16 GetCycleId();
            //; get controller cycle id
        virtual uint8 GetBusId();
            //; get controller bus id
 
        virtual const char* GetUnit()
            { return m_cUnit; };
            //; get ramping base unit (e.g. mm, deg, ...)
        virtual uint32 GetCharacteristics()
            { return m_uCharacteristics; }; 
            //; get ramping base unit inco characteristics
        virtual uint8 GetTypeChar() {return m_uTypeChar;};
            //; get type character, e.g. 'T' for temperature ramp
        virtual void SetParent(CINOSControl* apParent)
            { m_pParent = apParent;};
            //; set pointer to my parent controller
        virtual const char* GetType() {return m_pType;};
            //; get type string
 
        virtual CINCOObject* GetRegister();
            //; do inco registration and return pointer to it
        
        virtual bool OnEmergency()
            { return (m_uError & m_uErrorDis) != 0;};
 
        virtual CINOSProcessImageChannel* GetInput() { return m_pInpChannel;};
        virtual CINOSProcessImageChannel* GetOutput() { return m_pOutChannel;};
 
    //--- internals --------------------------------------------------------
 
    friend class CINCOpidDelayToHalt;
    friend class CINOSControl;
    friend class CINOSRemoteControlWorker;
 
    // protected member functions
    protected:
        virtual void Reset();
            //; reset controller values (called whenever the controller is 
            //; switched on)
        virtual void StopJump();
            //; stop controller jump
        virtual void StopTune();
            //; stop controller tune
        virtual void Jump(real64 arSrc, real64 arDst){};
            //; jump detected
        virtual void PreControl(){};
            //; called before control
        virtual void Control();
            //; do a control cycle
        virtual void SetOutput(real64 arOutput);
            //; set output
        virtual void CalcError();
            //; calc actual Serr and Verr
        virtual bool IsSettled(bool abAdjAllowed=false)
            { return true;};
            //; return  true if settled
 
        void GetInpChannel();
        void GetOutChannel();
 
    // 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
        uint32 m_uError;
            //; actual errors
        uint32 m_uErrorMask;
            //; errors to be masked out
        uint32 m_uErrorDis;
            //; errors which disable the cotroller
        uint32 m_uMaskFatal;
            //; mask of fatal errors
        uint32 m_uWarning;
            //; actual warnings
        uint32 m_uWarningMask;
            //; warnings to be masked out
        uint32 m_uFlag;
            //; actual flags
        uint32 m_uLiveCount;
            //; actual flags
        bool m_bStartup;
            //; startup flag
        CINOSControl* m_pParent;
            //; pointer to parent controller
 
        // pointers
        CINCOObject* m_pRegister;
            //; pointer to inco registration
        CINCOObject* m_pError;
            //; pointer to inco registration of errors
        CINCOObject* m_pErrorMask;
            //; pointer to inco registration of error mask
        CINCOObject* m_pErrorDis;
            //; pointer to inco registration of disabling errors
        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 flags
        CINCOObject* m_pCmd;
            //; pointer to inco registration of commanded values
        CINCOObject* m_pAct;
            //; pointer to inco registration of actual values
        CINCOObject* m_pErr;
            //; pointer to inco registration of error values
        CINCOObject* m_pMax;
            //; pointer to inco registration of max values (obsolete)
        CINCOObject* m_pProp;
            //; pointer to inco registration of controller properties
        CINOSProcessImageChannel* m_pInpChannel;
            //; pointer to according input channel
        CINOSProcessImageChannel* m_pOutChannel;
            //; pointer to according output channel
        const char* m_pType;
            //; controller type
        uint8 m_uTypeChar;
            //; type character, e.g. 'T' for temperature
        inosName m_cUnit;
            //; controller unit
        inosName64 m_cInpChannel;
        inosName64 m_cOutChannel;
 
        // cycle time
 
        real64 m_rCycleTime;
            //; cycle time in s
        real64 m_rCycleTime_1;
            //; 1 / CYCLETIME
        real64 m_rCycleTimeMs;
            //; cycle time in ms
        real64 m_rDelayToHalt;
            //; delay [ms] before switching from run to halt parameters
        real64 m_rActivateTimeout;
            //; activation timeout {ms]
        int32 m_iActivateStart;
            //; activation starting ticks
 
        // settling
        real64 m_rSettleTime;
            //; requested settling time
        real64 m_rSettleTimeout;
            //; max. allowed settling time
        int32 m_iSettleStart;
            //; settling starting ticks
 
        // commanded values
        
        real64 m_rScmd;
            //; commanded position
        real64 m_rVcmd;
            //; commanded velocity
        real64 m_rAcmd;
            //; commanded acceleration
        real64 m_rJcmd;
            //; commanded jerk
 
        // actual values
 
        real64 m_rSact;
            //; actual position
        real64 m_rVact;
            //; actual velocity
        uint32 m_uVactLength;
            //; act v filter length
        uint32 m_uVactIndex;
            //; act v calc index
        real64 m_rVactSum;
            //; actual velocity
        real64 m_rVactRaw[DF_INOS_BASE_CONTROLLER_MAX_V_FILTER];
            //; actual raw velocity
        real64 m_rAact;
            //; actual acceleration
        real64 m_rJact;
            //; actual jerk
        real64 m_rOutact;
            //; actual output
        real64 m_rOutmin;
            //; minimal output
        real64 m_rOutmax;
            //; maximal output
        real64 m_rOutfct;
            //; output factor
        real64 m_rSstart;
            //; position at start of jump/run
            
        // error values
 
        real64 m_rSerr;
            //; actual position error
        real64 m_rVerr;
            //; actual velocity error
        real64 m_rSmax;
            //; max. allowed position error in state 'halt'
        real64 m_rSmaxRun;
            //; max. allowed position error in state 'run'
        real64 m_rSerrMax;
            //; max. reached position error
        real64 m_rSerrMin;
            //; min. reached position error
 
        // factors
 
        uint32 m_uCharacteristics;
            //; inco registration characteristics
        uint32 m_uDelayToHalt;
            //; delay [ticks] before switching from run to halt parameters
        int32 m_iDelayToHalt;
            //; actual delay [ticks]
            
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSBaseController);
};
 
 
//------------------------------------------------------------------------------
// class registration
//------------------------------------------------------------------------------
 
typedef CINOSBaseController *(*TCreateController)(const char*, const char*);
 
class CINOSRegisterBaseController
{   
    // after this function you can register new controllers
    friend void _INI_0000_CINOSBaseController();
    
    //--- internals --------------------------------------------------------
 
    // private members 
private:
    // pointer to the first registered controller
    static CINOSRegisterBaseController* m_pFirst; 
    // pointer to the next controller
    CINOSRegisterBaseController* m_pNext; 
    // create function for the controller
    TCreateController m_pCreate;
    // controller type name
    const char* m_pType;
        
    //--- user interface ---------------------------------------------------
 
public:
    // register a new controller type
    CINOSRegisterBaseController(TCreateController apFunction,
        const char* apType);
    
    // create and return and new controller instance
    static CINOSBaseController* GetController(const char* apType,
        const char* apInpName, const char* apOutName);
};
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSBASECONTROLLER_H