doxygen/inos/cinosbasecontroller_8h_source.html

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

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


#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