cinosmcmodule.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSMCMODULE_H
#define INC_CINOSMCMODULE_H
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
#define INOS_MCMODULE_STEP_INST(_inst_,_msg_)                                   \
    if (!(_msg_->GetData() && (_msg_->GetData()->GetFlag()&CINOSMcDataInst::eFlgIgnoreStep)) &&\
        !_msg_->GetTrigger() &&                             \
        !IsDispatcher(_msg_->GetSender()) &&                                    \
        ((_inst_.GetMode() == CINOSMcModule::eModStep) ||                       \
        ((_inst_.GetParent()&&(_inst_.GetParent()->GetMode() == CINOSMcModule::eModStep)) &&\
        ((_inst_.GetParent()&&(!_inst_.GetParent()->GetModule(_msg_->GetSender()->GetName()))))))){\
            char msg[256];                                                      \
            inos_strncpy(msg, _msg_->GetName(), sizeof(msg));                                       \
            uint32 uRes = SendMessage(INOS_MCMSG_TYPE_STEP, INOS_MCMSG_CODE_MODULE_STEP,\
                INOS_MCMSG_FLAG_RESUME|INOS_MCMSG_FLAG_SKIP|                    \
                INOS_MCMSG_FLAG_CANCEL|INOS_MCMSG_FLAG_STOP,                    \
                msg);                                                           \
            if (uRes & INOS_MCMSG_FLAG_CANCEL){                                 \
                _inst_.iStepCanceled(_msg_);                                    \
                return _inst_.MsgDone(_msg_, CINOSTaskEx::eRplCanceled, 0);     \
            }                                                                   \
            if (uRes & INOS_MCMSG_FLAG_STOP){                                   \
                _inst_.iStepStopped(_msg_);                                     \
                return _inst_.MsgDone(_msg_, CINOSTaskEx::eRplStopped, 0);      \
            }                                                                   \
            if (uRes & INOS_MCMSG_FLAG_SKIP){                                   \
                _inst_.iStepSkipped(_msg_);                                     \
                return _inst_.MsgDone(_msg_, CINOSTaskEx::eRplSkipped, 0);      \
            }                                                                   \
    }
#define INOS_MCMODULE_STEP(_msg_) INOS_MCMODULE_STEP_INST((*this), _msg_)
//
typedef char inosResName[128];
#define DF_INOS_MCMODULE_MAXCOUNT       8   // max. number of counters
#define DF_INOS_MCMODULE_MAXAVERAGE     32  // max. average
#define DF_INOS_MCMODULE_EMGDELAY       100 // default emergency delay
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <inos_1ms.h>
#include <cinosprocessimage.h>
#include <cinosphysicalaxis.h>
#include <cinoscontrol.h>
#include <cinosserialinout.h>
#include <cinostaskex.h>
#include <cinosmcmessage.h>
#include <cinosmcjob.h>
#include <cinosmcscript.h>
#include <cinosmcdata.h>
#include <cinosmccron.h>
//
// C++
//
// project
//
//------------------------------------------------------------------------------
// forward declarations
//------------------------------------------------------------------------------
//
#if defined(INOS_COORDINATOR_SUPPORT)
class CINOSMcCoord;  
class CINOSMcScript;
#endif
class CINOSMcLua;
struct lua_State;
class CINOSMcFastLoad;
class CINOSMcGuardian;
class CINOSMcJob;
class CINOSMcData;
class CINOSBaseAxis;
class CINOSMcModuleWaitObj;
class CINOSMcModule;
class CINOSMcValves;
 
//------------------------------------------------------------------------------
// types
//------------------------------------------------------------------------------
//
using TINOSMcModuleCondFunc = std::function<bool()>;
using TINOSMcModuleCondHandler = std::function<uint32()>;
 
 
//------------------------------------------------------------------------------
// class CINOSMcModuleRes
//------------------------------------------------------------------------------
//
#define INOS_RESOURCE_TYPE(type,id) ((type&0xF) + ((id&0xfff)<<4))
//
class CINOSMcModuleRes : public CINCOstring
{
    //--- user interface ---------------------------------------------------
 
    // public enumerations
    public:
        // resource types
 
        // IMPORTANT : Do NOT change these numbers, as these are part of the
        // mcrobot message sourceid -> customer code on PC side relies on them
        enum {
            eResModule = 0,
            eResDigInp = 1,
            eResDigOut = 2,
            eResAnaInp = 3,
            eResAnaOut = 4,
            eResDigFlg = 5,
            eResPos = 6,
            eResAxis = 7,
            eResControl = 8,
            eResSio = 9,
        };
 
        // resource flags
        enum EResFlag {
            eResFlgNone             = 0x00000000,
            eResFlgMandatory        = 0x00000001,
            eResFlgCountUp          = 0x00000002,
            eResFlgCountDown        = 0x00000004,
            // count both rising and falling edges
            eResFlgCountUpDown      = (eResFlgCountUp + eResFlgCountDown),
            // any kind of statistics
            eResFlgStat             = eResFlgCountUpDown
        };
 
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSMcModule;
    friend class CINOSMcRobot;
 
    // public members
    public :
        CINOSMcModuleRes(const char* apName, const inosResName* apValue, void* apPtr,
            uint32 auType, CINOSMcModule* apModule, uint32 auFlags);
        uint32 GetResState();
        void Update();
        void Handle();
        void EnbResource()
            {m_bEnabled=true;};
        void DisResource()
            {m_bEnabled=false;};
        void SetOut(real64 arValue);
        bool GetIO(real64& arValue) const;
        void SetSetId(int16 aiSetId, const char* apParam=0);
        void SetClrId(int16 aiClrId, const char* apParam=0);
        uint32 GetResType()
            { return m_uResTyp;};
        uint32 GetResId() const
            { return m_uResId;};
        const char* GetOrgName()
            { return &m_cName[0];};
        const char* GetFullName()
            { return &m_cFullName[0];};
        const char* GetIncoName()
            { return &m_cFullName[m_uIncoIndex];};
        const char* GetUnit()
            { return &m_cUnit[0];};
        void RegisterStat(CINCOObject* apParent);
        // get resource
        template <class T> void GetResource(T*& apResource);
        void SetObj(CINCOObject* apObj)
            { m_pObj = apObj; }
        CINCOObject* GetObj()
            { return m_pObj; }
        bool GetHookInfo(uint8& aoBusId, uint16& aoCycleId, uint32& aoCycleTime) const;
        
        // resource state
        enum {
            eStaUndefined,
            eStaOk,
            eStaNotFound,
            eStaSetNotFound,
            eStaClrNotFound
        };
 
        inosName64 m_cFullName;
        inosResName m_cName;
        inosName64 m_cPureName;
        inosName m_cUnit;
        char* m_pCmdSet;
        char* m_pCmdClr;
        CINOSMcModule* m_pModule;
        void* m_pResPtr;
        void* m_pDummy;
        uint32 m_uResTyp;
        uint32 m_uResId;
        uint32 m_uResState;
        uint32 m_uResFlags;
        bool m_bEnabled;
        bool m_bSet;
        intptr m_iSetId;
        int16 m_iSetType;
        // set command sub-code
        uint32 m_uSetSubId;
        intptr m_iClrId;
        int16 m_iClrType;
        uint16 m_uIncoIndex;
        inosName32 m_cSetParam;
        inosName32 m_cClrParam;
 
        nvuint32 m_uCounter;
        CINCOObject* m_pObj{};
 
    // public member functions
    public:
        // put 'aSource' to item
        virtual long Put(void* aSource, long aIndex=0, long aOffset=0);
 
    DECLARE_DYNAMIC(CINOSMcModuleRes);
};
 
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSMcModule : public CINOSTaskEx
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        // module commands
 
        virtual CMcResult On(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Off(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Safe(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Init(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Home(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Recover(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Start(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Stop();
 
        virtual CMcResult Stop(CINOSSync* apSync);
 
        virtual CMcResult Stop(const char* apParam);
 
        virtual CMcResult Pause(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Resume(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Cancel();
 
        virtual CMcResult Cancel(CINOSSync* apSync);
 
        virtual CMcResult Cancel(const char* apParam);
 
        virtual CMcResult Retry(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Confirm(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Manual(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Prepare(real64 arStage, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Backup(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult Restore(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        
        virtual CMcResult CreateSubModule(const char* apName, 
            const char* apType, const char* apParam, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult DestroySubModule(const char* apName, 
            CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        TINOSTaskExCmdMsg<CINOSMcModule, const char*, bool> SetItems {
            "SetItems", &CINOSMcModule::iSetItems, nullptr, *this,
            { "Values", "", nullptr, CINOSTaskExMsgParam::eFlgStructure},
            { "Overwrite", false},
            0xFFFFFFFF,
            "Cmd=SetItems"
        };
 
        virtual CMcResult CreateData(const char* apName, 
                                          const char* apType,
                                          const char* apParam,
                                          CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        
        virtual CMcResult DestroyData(const char* apName, 
                                          CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult MoveData(const char* apSrcName, const char* apDstModule,
            const char* apDstName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult CreateJob(const char* apName,
                                          const char* apType,
                                          const char* apParam,
                                          CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult DestroyJob(const char* apName,
                                          CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult CreateScript(const char* apName,
                                          const char* apType,
                                          const char* apParam,
                                          CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult DestroyScript(const char* apName,
                                          CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult RunJob(const char* apName, const char* apParam,
            CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult RunScript(const char* apName, const char* apData,
            const char* apParam, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult SetMode(const char* apName,
            CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult SetModeAuto(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult SetModeStep(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult SetModeSetup(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult ClrModeSetup(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult SetOut(const char* apName, real64 arValue,
            CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult GetIO(const char* apName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult WaitBitEx(const char* apName, real64 arValue, real64 arTimeout,
            real64 arErrorType, real64 arErrorCode, real64 arErrorFlags, 
            const char* apErrorText, real64 arErrorSend, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult WaitInp(const char* apName, real64 arValue, real64 arTimeout,
                CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult WaitAdcNB(const char* apName, uint32 auSlope, real64 arValue, real64 arTimeout,
                CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult WaitPosNB(const char* apName, uint32 auSlope, real64 arValue, real64 arTimeout,
                CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult WaitAxis(const char* apName, uint32 auSlope, real64 arValue, real64 arTimeout,
                CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult WaitAxisEx(const char* apName, uint32 auSlope, real64 arValue, real64 arTimeout, uint32 auFlags,
                CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult CntInc(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult CntDec(CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult CntAdj(int32 aiValue, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult SetCounter(uint32 auType, uint32 auNbr, uint32 auValue,
            CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
 
        virtual CMcResult CronEnable(const char* apName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult CronDisable(const char* apName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult CronTouch(const char* apName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        virtual CMcResult CronCount(const char* apName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        
        virtual CMcResult IsActionAllowed(const char* apScriptName, CINOSSync* apSync=DF_INOS_SYNCHRONOUS);
        
        virtual CMcResult ValveActivate(const char* apName, CINOSSync *apSync = DF_INOS_SYNCHRONOUS);
        virtual CMcResult ValveRelease(const char* apName, CINOSSync *apSync = DF_INOS_SYNCHRONOUS);
        
        CINOSMcModule* GetParent() const;
        virtual CINOSMcModule* GetModule(uint32 auIndex);
        virtual CINOSMcModule* GetModule(const char* apName);
 
        virtual CINOSMcModule* FindSubModule(const char* apName);
        static CINOSMcModule* FindModule(const char* apName);
 
        virtual CINOSMcGuardian* GetGuardian() const;
        #if defined(INOS_COORDINATOR_SUPPORT)
        virtual CINOSMcCoord* GetCoord();
        #endif
        #if defined(INOS_LUAINTERPRETER)
        virtual CINOSMcLua* GetLua();
        #endif
        virtual CINOSMcBaseJob* GetJob(const char* apName);
        virtual CINOSMcBaseScript* GetScript(uint32 auNr);
        virtual CINOSMcBaseScript* GetScript(const char* apName);
        virtual void RemScript(const char* apName);
        virtual CINOSMcData* GetData(uint32 auNr);
        virtual CINOSMcData* GetData(const char* apName);
        virtual CINOSMcData* GetData(const char* apPrefix, uint32 auNr);
        virtual CINOSMcData* GetData(const char* apPrefix, const char* apName);
 
        virtual bool GetEmergency();
        virtual uint32 GetEmergencyDelay();
        virtual void EmergencyOnPurposeFollows();
        virtual CINOSBit* GetEmergencyInput()
            { return m_pDiEmergency; };
        virtual bool DoPostEmergencyMessage()
            { return true; };
        virtual bool DoPostSTOMessage()
            { return true; };
        virtual uint32 GetSimLevel();
        virtual void SetSimLevel(uint32 auSimLevel, bool abNonVolatile);
        virtual real64 GetSlowMotion();
        virtual void SetSlowMotion(real64 arSlowMotion, bool abNonVolatile);
        virtual real64 GetProp(const char* apName, real64 arDefValue, CINOSTaskExMsg* apMsg);
        virtual void GetProp(const char* apName, char* apBuffer, uint32 auLength, CINOSTaskExMsg* apMsg);
        virtual real64 GetProp(const char* apName, real64 arDefValue, CINOSMcData* apData);
        virtual void GetProp(const char* apName, const char* apDefault, char* apBuffer, uint32 auLength, CINOSMcData* apData);
 
        // get resource
        template<class T> T* GetResource(const char* apName);
        // get digital input resource named 'Inp.apName'
        CINOSBit* GetInpResource(const char* apName);
        // get digital output resource named 'Out.apName'
        CINOSBit* GetOutResource(const char* apName);
        // get digital flag resource named 'Flg.apName'
        CINOSBit* GetFlgResource(const char* apName);
        // get analog input resource named 'Adc.apName'
        CINOSAdcChannel* GetAdcResource(const char* apName);
        // get analog output resource named 'Dac.apName'
        CINOSDacChannel* GetDacResource(const char* apName);
        // get poschannel resource named 'Pos.apName'
        CINOSPosChannel* GetPosResource(const char* apName);
        // get axis resource named 'Axes.apName'
        virtual CINOSPhysicalAxis* GetAxisResource(const char* apName) { return NULL; };
        tMsgId AddInpResource(const char* apResName, const char* apImageName, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
        tMsgId AddOutResource(const char* apResName, const char* apImageName, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
        tMsgId AddAdcResource(const char* apResName, const char* apImageName, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
        tMsgId AddDacResource(const char* apResName, const char* apImageName, CINOSSync* apSync = DF_INOS_SYNCHRONOUS);
 
        uint32 RegisterHook(uintid& aoHookId, const char* apResName, void* apHandler, void* apObject, int32 aiOrder);
 
        uint32 UnRegisterHook(uintid aoHookId, const char* apResName);
 
        virtual CINCOObject* GetResObj();
                                           
        virtual uint32 GetMode()
            { return m_uMode;};
        
        virtual uint32 GetCntValue(uint32 auType, uint32 auNbr);
 
        virtual const char* GetModuleName()
            { return GetTreeName();};
 
        static CINOSMcModule* GetMachine(const char* apName);
 
        static CINOSMcModule* GetMachine(uint32 auIndex);
 
        static uint32 CreateMachine(CINOSMcModule* &apNewModule,
                const char* apName,
                const char* apType,
                const char* apParam);
 
        static uint32 DestroyMachine(const char* apName);
 
        static uint32 ShutdownRequest();
 
        virtual void AddCommand(const char* apName, uint32 auCode, 
            CINCOProcedure* apProc) override;
        virtual void AddCommand(CINOSTaskExMsg* apMsg,
                                uint64 aChar,               // characteristics of object
                                uint16 aKeyLevel,           // keylevel of object
                                bool abRegisterInco=true) override;
        virtual void AddCommand(const char* apName, uint32 auCode, uint32 auType=eMsgCmd) override;
        virtual void RemCommand(const char* apName) override;
        virtual void AddChildCommand(const char* apModuleName,
                const char* apFunctionName,
                CINOSTaskExMsg* apCmdMsg,
                bool abRegisterInco = true) override;
        virtual void RemChildCommand(const char* apModuleName, const char* apFunctionName) override;
 
        virtual void AddChildModule(const char* apModuleName) override;
        virtual void RemChildModule(const char* apModuleName) override;
 
        constexpr static int GetLastCmd() {
            return eCmdINOSMcModuleLast;
        }
        constexpr static int GetLastUsr() {
            return eUsrINOSMcModuleLast;
        }
 
    //--- internals --------------------------------------------------------
 
    friend class CINOSMcModuleRes;
    friend class CINOSMcModuleWaitObj;
    friend class CINOSMcValve;
    friend class CINOSMcFastLoad;
    friend void _INI_0000_CINOSMcModule();
    friend void _INI_0300_CINOSMcModule();
    friend void _INI_0500_CINOSMcModule();
    friend void _INI_1000_CINOSMcModule();
    
    friend int l_add_command(lua_State *L);
 
    // public members (used by container class)
    public:
        CINOSMcModule (const char* apName, const char* apParam);
        CINOSMcModule (const char* apName, const char* apType, const char* apParam);
        virtual ~CINOSMcModule ();
        virtual void PostCreate(void* apParent) override;
        virtual bool PreDestroy(bool& bDeleteSelf) override;
 
        // command codes
        enum {
            eCmdINOSMcModuleFirst = eCmdINOSTaskExLast+1, 
            eCmdOn,  
            eCmdOff,
            eCmdSafe,
            eCmdInit,  
            eCmdHome,  
            eCmdRecover,  
            eCmdStart,  
            eCmdStop,  
            eCmdPause,  
            eCmdResume,  
            eCmdCancel,  
            eCmdRetry,  
            eCmdConfirm,  
            eCmdManual,  
            eCmdPrepare,  
            eCmdBackup,  
            eCmdRestore, 
            eCmdCreateSubModule, 
            eCmdDestroySubModule, 
            eCmdCreateData, 
            eCmdDestroyData,
            eCmdMoveData,
            eCmdMoveDataInt,
            eCmdCreateJob,
            eCmdDestroyJob,
            eCmdCreateScript,
            eCmdDestroyScript,
            eCmdRunJob,  
            eCmdRunScript, 
            eCmdRunRegisteredLuaFunction, 
            eCmdSetMode,  
            eCmdSetModeAuto,  
            eCmdSetModeStep,  
            eCmdSetModeSetup,  
            eCmdClrModeSetup,  
            eCmdSetOut,
            eCmdGetIO,
            eCmdWaitBitEx,  
            eCmdWaitInp,
            eCmdWaitAdc,
            eCmdWaitPos,
            eCmdWaitAxis,
            eCmdSetCounter,  
            eCmdCntInc,  
            eCmdCntDec,  
            eCmdCntAdj,
            eCmdCronEnable,
            eCmdCronDisable,
            eCmdCronTouch,
            eCmdCronCount,
            eCmdCanLoad,
            eCmdValveActivate,
            eCmdValveRelease,
            eCmdAddInpResource,
            eCmdAddOutResource,
            eCmdAddAdcResource,
            eCmdAddDacResource,
            eCmdINOSMcModuleLast
        };      
 
        // user command codes
        enum {
            eUsrINOSMcModuleFirst = eUsrINOSTaskExLast+1, 
            eUsrEmgSet,  
            eUsrEmgClr,  
            eUsrSTOSet,
            eUsrSTOClr,
            eUsrMsgSet,  
            eUsrMsgAck,  
            eUsrSlowMotionChanged,  
            eUsrSimLevelChanged,
            eUsrLinkDown,
            eUsrSTOConfirmSet,
            eUsrSTOConfirmClr,
            eUsrSafetyConfigUpdate,
            eUsrINOSMcModuleLast
        };      
        // internal command codes
        enum {
            eIntINOSMcModuleFirst = eIntINOSTaskExLast  + 1,
            eIntGetResource,
            eIntWaitTimeout,
            eIntINOSMcModuleLast
        };
 
        // states
        enum {
            eStaINOSMcModuleFirst = eStaINOSTaskExLast+1,
            eStaINOSMcModuleLast
        };      
 
        // modes
        enum {
            eModAuto,
            eModSequential,
            eModStep,
            eModLast
        };      
 
        // simulation levels
        enum {
            eSimNo,
            eSimSemi,
            eSimFull
        };      
 
        // act job states
        enum {
            eStaJobNone,
            eStaJobRunning,
            eStaJobCompleted,
            eStaJobStopped,
            eStaJobCanceled,
            eStaJobFailed,
            eStaJobError,
            eStaJobFatal,
            eStaJobRejected,
            eStaJobIgnored,
            eStaJobInComplete,
            eStaJobPaused
        };      
 
        // options
        enum {
            eOptCoord   = 0x00000100,       // coordintator support
            eOptMode    = 0x00000200,       // mode support        
            eOptGuard   = 0x00000400,       // guardian support
            eOptConc    = 0x00000800,       // job/script concurrency support
            eOptCron    = 0x00001000,       // cron support
            eOptSafety  = 0x00002000,       // safety support
            eOptResMcM4 = 0x00004000,       // reserved for future use
            eOptResMcM5 = 0x00008000        // reserved for future use
        };      
 
        // flags (R - read only, W - read/write)
        enum EFlags : uint64 {
            eFlgResource= 0x00000100,       // R resource ok
            eFlgOn      = 0x00000200,       // R on ok
            eFlgInit    = 0x00000400,       // R init ok
            eFlgSetup   = 0x00000800,       // R setup ok
            eFlgJob     = 0x00001000,       // R job running
            eFlgBackup  = 0x00002000,       // R backup ok
            eFlgPaused  = 0x00004000,       // R paused         
            eFlgSafe    = 0x00008000,       // R safe
            eFlgCreated = 0x0000010000000000LL// R module creation completed
        };      
 
        // requests
        enum {
            eReqOff     = 0x00000100,       // R off request
            eReqStop    = 0x00000200,       // R stop request
            eReqCancel  = 0x00000400,       // R cancel request
            eReqStep    = 0x00000800,       // R step request
            eReqStart   = 0x00001000,       // R start request
            eReqPause   = 0x00002000,       // R pause request
            eReqSafe    = 0x00004000,       // R safe request
            eReqSetup   = 0x00008000        // R setup request
        };      
 
        // critical sections
        enum {
            eCrtWaitObj = 0x00000100,       // waiting for object
            eCrtResMcM1 = 0x00000200,       // reserved for future use
            eCrtResMcM2 = 0x00000400,       // reserved for future use
            eCrtResMcM3 = 0x00000800,       // reserved for future use
            eCrtResMcM4 = 0x00001000,       // reserved for future use
            eCrtResMcM5 = 0x00002000,       // reserved for future use
            eCrtResMcM6 = 0x00004000,       // reserved for future use
            eCrtResMcM7 = 0x00008000        // reserved for future use
        };      
 
        // wait object handling
        enum ETypWait {
            eTypWaitGt=0,
            eTypWaitGte=1,
            eTypWaitLt=2,
            eTypWaitLte=3,
            eTypWaitEq=4,
            eTypWaitNe=5,
        };
 
    // protected members
    protected :
        virtual bool DispatchCmd(CINOSTaskExMsg* apMsg) override;
        virtual bool DispatchTmd(CINOSTaskExMsg* apMsg) override;
        virtual bool DispatchUser(CINOSTaskExMsg* apMsg) override;
        virtual bool DispatchEvent(CINOSTaskExMsg* apMsg) override;
        virtual bool DispatchReply(CINOSTaskExMsg* apReply) override;
        virtual bool DispatchInternal(CINOSTaskExMsg* apMsg) override;
 
 
    // public (but just for internal use)
    public :
        virtual CINOSMcModuleRes* AddResource(const char* apName, uint32 auType,
                uint32 auFlags = CINOSMcModuleRes::eResFlgMandatory, CINCOObject* apObj = 0);
        virtual CINOSMcModuleRes* AddResource(const char* apName, inosResName* apValue,
                uint32 auType, uint32 auFlags = CINOSMcModuleRes::eResFlgMandatory,
                CINCOObject* apObj = 0);
        virtual CINOSMcModuleRes* AddResource(const char* apName, void* apPtr,
                uint32 auType, uint32 auFlags = CINOSMcModuleRes::eResFlgMandatory,
                CINCOObject* apObj = 0);
        virtual CINOSMcModuleRes* AddResource(const char* apName, inosResName* apValue,
                void* apPtr, uint32 auType, uint32 auFlags = CINOSMcModuleRes::eResFlgMandatory,
                CINCOObject* apObj = 0);
        // get resource
        virtual CINOSMcModuleRes* iGetResource(const char* apName);
        // get resource
        virtual CINOSMcModuleRes* iGetResource(uint32 auNumber);
        template <typename F>
        void iForEachResource(F&& f) {
            m_pRes->ForEach(std::move(f));
        }
        // enable resource
        virtual void EnbResource(char* apName);
        // disable resource
        virtual void DisResource(char* apName);
        virtual CMcResult PutMsg(CINOSTaskExMsg* apMsg, tMsgId aMsgId=0) override;
 
        #ifdef INOS_SAFETY_SUPPORT
        virtual void SafetyConfigUpdate();
        virtual void iSafetyConfigUpdate(CINOSTaskExMsg* apMsg);
        #endif
 
    // protected members
    protected :
        virtual void AdjTrigger(CINOSTaskExMsg* apMsg, real64 arCmdTime);
        virtual void AdjTrigger(CINOSTaskExMsg* apMsg, CINOSBaseAxis* m_pAxis,
            real64 arStart, real64 arEnd, const char* apParam);
 
        virtual void iStartup(CINOSTaskExMsg* apMsg) override;
        virtual void iStartup(real64 arStage) override;
        virtual bool iPostStartup() override;
        virtual void iStartupDone();
        virtual void iShutdown(CINOSTaskExMsg* apMsg) override;
        virtual void iCheckRes(CINOSTaskExMsg* apMsg);
        virtual void iLinkDown(CINOSTaskExMsg* apMsg);
 
        #ifdef INOS_MULTICORE
        virtual uint32 iSwitchCore(uint8 auCoreId) override;
        #endif
 
        virtual void iEmgSet(CINOSTaskExMsg* apMsg);
        virtual void iEmgClr(CINOSTaskExMsg* apMsg);
 
        #ifdef INOS_SAFETY_SUPPORT
        virtual void iSTOSet(CINOSTaskExMsg* apMsg);
        virtual void iSTOClr(CINOSTaskExMsg* apMsg);
        virtual void iSTOConfirmSet(CINOSTaskExMsg* apMsg);
        virtual void iSTOConfirmClr(CINOSTaskExMsg* apMsg);
        #endif
 
        //  Implements step support for all commands of type TINOSTaskExCmd. 
        //  It also calls the base pre dispatcher form CINOSTaskEx
        virtual bool PreDispatchMsg(CINOSTaskExMsg* apMsg) override;
 
        virtual void PostEmergency();
        virtual CMcResult PostEmergencyStopMessage();
        virtual void iOn(CINOSTaskExMsg* apMsg);
        virtual void iiOn(CINOSTaskExMsg* apMsg);
        virtual void irplOn(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iOff(CINOSTaskExMsg* apMsg);
        virtual void iiOff();
        virtual void irplOff(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iSafe(CINOSTaskExMsg* apMsg);
        virtual void irplSafe(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iInit(CINOSTaskExMsg* apMsg); 
        virtual void irplInit(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iHome(CINOSTaskExMsg* apMsg); 
        virtual void irplHome(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iRecover(CINOSTaskExMsg* apMsg); 
        virtual void irplRecover(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iStart(CINOSTaskExMsg* apMsg); 
        virtual void iStop(CINOSTaskExMsg* apMsg); 
        virtual void iiStop();
        virtual void irplStop(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iPause(CINOSTaskExMsg* apMsg); 
        virtual void irplPause(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iResume(CINOSTaskExMsg* apMsg); 
        virtual void iCancel(CINOSTaskExMsg* apMsg); 
        virtual void iiCancel(bool abHandleOffRequest = true);
        virtual void irplCancel(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iRetry(CINOSTaskExMsg* apMsg); 
        virtual void iConfirm(CINOSTaskExMsg* apMsg); 
        virtual void iManual(CINOSTaskExMsg* apMsg); 
        virtual void iPrepare(CINOSTaskExMsg* apMsg); 
        virtual void iBackup(CINOSTaskExMsg* apMsg); 
        virtual void iRestore(CINOSTaskExMsg* apMsg); 
        virtual void irplRestore(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iCreateSubModule(CINOSTaskExMsg* apMsg);
        virtual uint32 iCreateSubModule(const char* apName, const char* apType, const char* apParam);
        virtual void iDestroySubModule(CINOSTaskExMsg* apMsg);
        virtual uint32 iDestroySubModule(const char* apName);
        virtual void iSetItems(CINOSTaskExMsg* apMsg);
        virtual void iCreateData(CINOSTaskExMsg* apMsg);
        virtual void iDestroyData(CINOSTaskExMsg* apMsg);
        virtual void iMoveData(CINOSTaskExMsg* apMsg);
        virtual void iMoveDataInt(CINOSTaskExMsg* apMsg);
        virtual void iCreateJob(CINOSTaskExMsg* apMsg);
        virtual void iDestroyJob(CINOSTaskExMsg* apMsg);
        virtual void iCreateScript(CINOSTaskExMsg* apMsg);
        virtual void iDestroyScript(CINOSTaskExMsg* apMsg);
        virtual void iRunJob(CINOSTaskExMsg* apMsg); 
        virtual void irplRunJob(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        virtual void iRunScript(CINOSTaskExMsg* apMsg); 
    public:
        // This methods need to be public because Scripts use 'double dispatch'.
        #if defined(INOS_COORDINATOR_SUPPORT)
        virtual void iRunCoordJob(CINOSTaskExMsg* apMsg);
        virtual void iRunCoordScript(CINOSTaskExMsg* apMsg);
        #endif
        #if defined(INOS_LUAINTERPRETER)
        virtual void iRunLuaJob(CINOSTaskExMsg* apMsg, const char* apFunction);
        virtual void iRunLuaScript(CINOSTaskExMsg* apMsg, const char* apFunction);
        #endif
    protected:
        virtual void irplRunScript(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl); 
        #if defined(INOS_LUAINTERPRETER)
        virtual void iRunRegisteredLuaFunction(CINOSTaskExMsg* apMsg); 
        virtual void irplRunRegisteredLuaFunction(CINOSTaskExMsg* apMsg, CINOSTaskExMsg* apRpl);
        #endif
        virtual void iSetMode(CINOSTaskExMsg* apMsg); 
        virtual void iSetModeAuto(CINOSTaskExMsg* apMsg); 
        virtual void iSetModeStep(CINOSTaskExMsg* apMsg); 
        virtual void iSetModeSetup(CINOSTaskExMsg* apMsg); 
        virtual void iClrModeSetup(CINOSTaskExMsg* apMsg); 
        virtual void iSetMode(const char* apName); 
        virtual bool iCheckSetupMode();    
        virtual void iSetOut(CINOSTaskExMsg* apMsg); 
        virtual void iGetIO(CINOSTaskExMsg* apMsg);
        virtual void iWaitBitEx(CINOSTaskExMsg* apMsg); 
        virtual void iWaitInp(CINOSTaskExMsg* apMsg);
        virtual void iWaitAdc(CINOSTaskExMsg* apMsg);
        virtual void iWaitPos(CINOSTaskExMsg* apMsg);
        virtual void iWaitAxis(CINOSTaskExMsg* apMsg);
        void WaitCond(
            TINOSMcModuleCondFunc aFunc,
            TINOSMcModuleCondHandler aSuccessFunc,
            TINOSMcModuleCondHandler aTimeoutFunc,
            real64 arTimeout = 0.0,
            real64 arSimTimeout = 0.0
        );
        tMsgId MsgDeferWait(CINOSTaskExMsg* apMsg, CINOSMcModuleWaitObj* apWaitObj,
            real64 arTimeout = 0.0);
 
        virtual void ihndlWait(CINOSTaskExMsg* apMyMsg, CINOSTaskExMsg* apNewMsg);
        virtual void iWaitTimeout(CINOSTaskExMsg* apMsg);
        virtual void iCntInc(CINOSTaskExMsg* apMsg); 
        virtual void iCntDec(CINOSTaskExMsg* apMsg); 
        virtual void iCntAdj(CINOSTaskExMsg* apMsg); 
 
        virtual void iSetCounter(CINOSTaskExMsg* apMsg); 
        
        virtual void iCronEnable(CINOSTaskExMsg* apMsg); 
        virtual void iCronDisable(CINOSTaskExMsg* apMsg); 
        virtual void iCronDisableAll(); 
        virtual void iCronTouch(CINOSTaskExMsg* apMsg); 
        virtual void iCronCount(CINOSTaskExMsg* apMsg);
        
        virtual void iIsActionAllowed(CINOSTaskExMsg* apMsg);
        
        virtual void iValveActivate(CINOSTaskExMsg* apMsg);
        virtual void iValveRelease(CINOSTaskExMsg* apMsg);
 
        virtual void iGetResource(CINOSTaskExMsg* apMsg);
 
        virtual void iOnCntSet(CINOSTaskExMsg* apMsg); 
        virtual void iOnCntInc(CINOSTaskExMsg* apMsg); 
        virtual void iOnCntDec(CINOSTaskExMsg* apMsg); 
        virtual void iOnCntSet(uint32 auType, uint32 auNbr, uint32 auVal,
            uint64 auTb); 
        virtual void iSetCntCmd(uint32 auNbr, uint32 auVal); 
 
        virtual void iOnMsgSet(CINOSTaskExMsg* apMsg); 
        virtual void iOnMsgAck(CINOSTaskExMsg* apMsg); 
 
        virtual void iOnSlowMotionChanged(CINOSTaskExMsg* apMsg); 
        virtual void iOnSimLevelChanged(CINOSTaskExMsg* apMsg);
        virtual void iOnSimLevelChanged(uint32 auOldLevel, uint32 auNewLevel);
 
        virtual void MsgDone(CINOSTaskExMsg* apMsg, uint32 auResult = 0) override;
        virtual void MsgDone(CINOSTaskExMsg* apMsg, ERplId aRplId, uint32 auResult = 0) override;
        virtual void iUpdate();
        
        virtual void SetFlag(uint64 auFlag, bool abUpdateState = false) override
            {
                // call base
                CINOSTaskEx::SetFlag(auFlag, abUpdateState);
                // update state ?
                if (abUpdateState) iUpdate();
            };
        virtual void ClrFlag(uint64 auFlag, bool abUpdateState = false) override
            {
                // call base
                CINOSTaskEx::ClrFlag(auFlag, abUpdateState);
                // update state ?
                if (abUpdateState) iUpdate();
            };
        
        virtual bool IsModeAllowed(const char* apMode);
 
        virtual void iStepCanceled(CINOSTaskExMsg* apMsg){};        
        virtual void iStepStopped(CINOSTaskExMsg* apMsg){};     
        virtual void iStepSkipped(CINOSTaskExMsg* apMsg){};     
 
        virtual void iMsgRejected(CINOSTaskExMsg* apMsg){};     
 
        void iAddInpResource(CINOSTaskExMsg* apMsg);
        void iAddOutResource(CINOSTaskExMsg* apMsg);
        void iAddAdcResource(CINOSTaskExMsg* apMsg);
        void iAddDacResource(CINOSTaskExMsg* apMsg);
 
        virtual ERplId WaitMs(real64 arTime);
        virtual ERplId WaitBit(CINOSBit* apBit, uint32 auValue, real64 arTimeout,
            real64& arUsed);
        virtual ERplId WaitAdc(CINOSAdcChannel* apAdc, ETypWait aeTypWait, 
            real64 arValue, real64 arTimeout, real64& arUsed);
        virtual ERplId WaitPos(CINOSPosChannel* apPos, ETypWait aeTypWait, 
            int32 aiValue, real64 arTimeout, real64& arUsed);
        virtual ERplId WaitPos(CINOSPhysicalAxis* apAxis, ETypWait aeTypWait, 
            real64 arValue, real64 arTimeout, real64& arUsed);
        virtual ERplId WaitVar(CINOSTaskExMsg* apMsg, const char* apName, ETypWait aeTypWait, 
            real64 arValue, real64 arTimeout, real64& arUsed);
        template<class T> ERplId WaitVar(T* apVar, ETypWait aeTypWait, real64 arValue,
            real64 arTimeout, real64& arUsed);
        virtual bool TestBit(const char* apName);
        virtual void SetBit(const char* apName);
        virtual void ClrBit(const char* apName);
 
        void SetModuleBase(const char* apAllowedBases);
        void AddInp(CINOSMcModuleRes* apInp);
        void AddOut(CINOSMcModuleRes* apOut);
 
        uint32 CreateModule(const char* apName, const char* apType, const char* apParam);
        uint32 DestroyModule(const char* apName);
        
        CINOSContainer<CINOSMcData>* GetDataContainer()
            { return m_pData; };
        
        // job helpers
        
        // increment actual job counter
        virtual void JobCounterInc();
        // decrement actual job counter
        virtual void JobCounterDec();
 
        void DisableModuleHlpHook();
        void EnableModuleHlpHook();
        virtual void iModuleHlpHook();
        virtual void OnTargetError();
 
    // private members
    private :
        void Create();
        void AddInp(CINOSMcModuleRes* apInp, const char* apCmdName, 
            intptr& aiSetId, uint32& auSetSubId, int16& aiSetType, inosName32& apSetParam,
            intptr& aiClrId, int16& aiClrType, inosName32& apClrParam);
        void ParseResCmd(const char* apSrc, inosName32& aCmd, inosName32& aParam);
        void AddResources(const char* apName, uint32 auType);
        void RunStream(const char* apName);
        void RunStreams();     
        // ! run lua scripts
        #if defined(INOS_LUAINTERPRETER)
        bool RunLuaScripts();
        #endif
        virtual const char* GetModuleScriptName(const char* apCmd);
        
        friend class CINOSMcCron;
        bool IsDone(tMsgId aCmdId);
 
        // wait object handling
        
        virtual void iWaitObjReply(ERplId aeReply);
        virtual void iWaitObjReply(ERplId aeReply, tMsgId atMsgId,
                                   real64 arTimeout);
 
        void WaitObjReplyAll(ERplId aeReply);
 
        void iWaitObjHook();
 
        void RegisterWaitObjHookLazy();
        void UnregisterWaitObjHook();
 
        virtual void RequestScriptMutex()
            {
                m_ScriptMutex.Request();
            }
        virtual void ReleaseScriptMutex()
            {
                m_ScriptMutex.Release();
            }
 
    // private members
    private :
        #if defined(INOS_COORDINATOR_SUPPORT)
        CINOSMcCoord* m_pCoord;  
        #endif
        
        #if defined(INOS_LUAINTERPRETER)
        CINOSMcLua* m_pLua;
        #endif
        
        #if !defined(INOS_DESKTOP)
        CINOSMcFastLoad* m_pFastLoad{};
        #endif
        
        CINOSMcGuardian* m_pGuardian;
        
        CINCOObject* m_piRes;
        CINCOObject* m_piCounter;
 
        CINOSContainer<CINOSMcModule>* m_pModule;
        CINOSContainer<CINOSMcBaseJob>* m_pJob;
        CINOSContainer<CINOSMcBaseScript>* m_pScript;
        CINOSContainer<CINOSMcData>* m_pData;
        CINOSContainer<CINOSMcCron>* m_pCron;
 
        // mutex to protect m_pData
        CINOSMutex m_DataMutex;
        // mutex to protect m_pScript
        CINOSMutex m_ScriptMutex;
 
        bool m_bInpListChanged;
        bool m_bOutListChanged;
        TINOSDoubleLinkedList<CINOSMcModuleRes>* m_pRes;
        TINOSDoubleLinkedList<CINOSMcModuleRes>* m_pInp;
        TINOSDoubleLinkedList<CINOSMcModuleRes>* m_pOut;
        CListNode* m_pInpNode;
        CListNode* m_pOutNode;
        tMsgId m_uOnOrgId;
        tMsgId m_OnMsgId;
        bool m_bOnPending;
        bool m_bIgnoreUph[DF_INOS_MCMODULE_MAXCOUNT];
 
        uintid m_uModuleHlpHookId;
        bool m_bEmgFirstOn;
        bool m_bEmergency;
        bool m_bEmergencyOnPurpose;
        uint32 m_uEmergencyCnt;
 
        // wait object handling
        
        CINOSSync m_sWaitObj;
        ERplId m_eWaitObj;
        CINOSMcModuleWaitObj* m_pWaitObj = nullptr;
        uintid m_uWaitObjHookId = 0;
        tMsgId m_uReplyId = 0;
        TINOSDoubleLinkedList<CINCOTable> m_LuaScripts; 
 
        // safety
 
        bool iHasEmergency();
        bool iIsEmergency();
        bool iIsSTO();
 
    // protected members
    protected :
 
        tMsgId m_uEmergencyMessageId;
        tMsgId m_uSTOMessageId;
 
        bool m_bUniqueResourceNaming;
 
 
        nvstring m_cJobName;
        nvstring m_cJobParam;
 
        inosName32 m_cMode;
        uint32 m_uMode;
        int32 m_iSimLevel;
        nvuint32 m_uSimLevel;
        nvreal64 m_rSlowMotion;
        nvreal64 m_rSlowMotionSetup;
        nvreal64 m_rOnDelay;
        nvuint32 m_uAutoInit;
        uint32 m_uActJobs;      
        uint32 m_uEmgDelay;     
        uint32 m_uEmgFilter;
        
 
        nvstring m_cActJobName;
        nvuint32 m_uActJobState;
        nvuint32 m_uActJobResult;
        nvlstring m_cActScriptName;
        nvuint32 m_uActChecksum;
        #if defined(INOS_KERNEL_MSGID_64)
        nvuint64 m_uActCmdId;
        #else
        nvuint32 m_uActCmdId;
        #endif
        tMsgId m_uActJobId;
 
        uint32 m_uCntNbr;
        nvuint32* m_pCntCmd[DF_INOS_MCMODULE_MAXCOUNT];
        nvuint32* m_pCntAct[DF_INOS_MCMODULE_MAXCOUNT];
        nvuint32* m_pCntBad[DF_INOS_MCMODULE_MAXCOUNT];
        nvuint32* m_pCntUph[DF_INOS_MCMODULE_MAXCOUNT];
        nvuint32* m_pCntUphType[DF_INOS_MCMODULE_MAXCOUNT];
        nvreal64* m_pCntUphFactor[DF_INOS_MCMODULE_MAXCOUNT];
        nvuint32* m_pCntUphStart[DF_INOS_MCMODULE_MAXCOUNT];
        nvuint32* m_pCntUphAverage[DF_INOS_MCMODULE_MAXCOUNT];
        nvreal64* m_pCntTim[DF_INOS_MCMODULE_MAXCOUNT];
        nvreal64* m_pCntLft[DF_INOS_MCMODULE_MAXCOUNT];
        uint64* m_pCntTimeBase[DF_INOS_MCMODULE_MAXCOUNT];
        uint8 m_uCntTimeBaseIndex[DF_INOS_MCMODULE_MAXCOUNT];
        inosName m_cCntUnit[DF_INOS_MCMODULE_MAXCOUNT];
        CINOSMcValves* m_pValves;
        CINOSMcDataInst* m_pOffDataInst = nullptr;
        
        // link down check
        
        enum {
            eLcSoff,
            eLcSon,
            eLcSdown
        } m_eLcState;
        uint8 m_uLcMask;        
        
        // module resources
        
        bool m_bResRegistred;
        CINOSBit* m_pDiEmergency;
 
        #ifdef INOS_SAFETY_SUPPORT
        CINOSBit* m_pDiSTOConfirm = nullptr;
        #endif
        uint32 m_uTgtErrorFlags = 0;
 
        // root modules container (called machine for backwards compatibility)
        static CINOSContainer<CINOSMcModule>* m_pMachine;
        // mutex to protect m_pMachine
        static CINOSMutex s_MachineMutex;
 
        static bool s_bRegisterInContainer;
 
    DECLARE_DYNAMIC(CINOSMcModule);
};
 
 
 
 
//------------------------------------------------------------------------------
//
template <class T> void CINOSMcModuleRes::GetResource(T*& apResource)
{
    // default is NULL
    apResource = (T*) NULL;
    if (*((uint32*)m_pResPtr)) {
        // cast it to the right type
        switch (m_uResTyp){
            case CINOSMcModuleRes::eResDigInp :
            case CINOSMcModuleRes::eResDigOut :
            case CINOSMcModuleRes::eResDigFlg : 
            case CINOSMcModuleRes::eResAnaInp :
            case CINOSMcModuleRes::eResAnaOut :
            case CINOSMcModuleRes::eResPos : {
                // get pointer to resource
                CINOSProcessImageChannel* chn = *((CINOSProcessImageChannel**)m_pResPtr);
                apResource = dynamic_cast<T*>(chn);
                // thats it
                break;
            } // end case               
            case CINOSMcModuleRes::eResAxis : {
                // get pointer to resource
                CINOSPhysicalAxis* axs = *((CINOSPhysicalAxis**)m_pResPtr);
                apResource = dynamic_cast<T*>(axs);
                // thats it
                break;
            } // end case               
            case CINOSMcModuleRes::eResControl : {
                // get pointer to resource
                CINOSControl* ctr = *((CINOSControl**)m_pResPtr);
                apResource = dynamic_cast<T*>(ctr);
                // thats it
                break;
            } // end case               
            case CINOSMcModuleRes::eResSio : {
                // get pointer to resource (this is not nice, but because we create
                // the resource ourselves, we can be sure that it is of correct type
                // -> dynamic_cast is not possible with class CINOSSerialInOut)
                apResource = *((T**)m_pResPtr);
                // thats it
                break;
            } // end case               
            case CINOSMcModuleRes::eResModule : {
                // get pointer to resource
                CINOSMcModule* mod = *((CINOSMcModule**)m_pResPtr);
                apResource = dynamic_cast<T*>(mod);
                // thats it
                break;
            } // end case               
        } // end switch     
    } // end if
    
} // end CINOSMcModuleRes::GetResource
 
//------------------------------------------------------------------------------
//
template <class T> T* CINOSMcModule::GetResource(const char* apName)
{
    CINOSMcModuleRes* res = iGetResource(apName);
    if (res) {
        T* s;
        res->GetResource(s);
        return s;
    } 
    return NULL;
    
} // end CINOSMcModule::GetResourceEx
 
//------------------------------------------------------------------------------
// class CINOSMcModuleWaitObj
//------------------------------------------------------------------------------
 
class CINOSMcModuleWaitObj
{
    friend class CINOSMcModule;
    friend class CINOSMcModuleWaitBit;
    friend class CINOSMcModuleWaitAdc;
public:
    CINOSMcModuleWaitObj(){
        // init members
        m_bSignaled = false;
        m_pModule = dynamic_cast<CINOSMcModule*>(ActualTask());
        ASSERT_ALWAYS(m_pModule);
        m_pNext = 0;
        m_pMsg = NULL;
        m_iStart = g_pINOS1ms->GetTickCount();
    };
    virtual ~CINOSMcModuleWaitObj(){};
    virtual void SetMsg(CINOSTaskExMsg* apMsg) {
        INOS_CONCURRENCY_CHECK_FREE(apMsg);
        m_pMsg = apMsg;
    };
    virtual void Handle()=0;
    void Reply(CINOSTaskEx::ERplId aeReply){
        // already signaled ?
        if (!m_bSignaled) {
            // set signaled
            m_bSignaled = true;
            if(m_pMsg != NULL) {
                m_pModule->iWaitObjReply(aeReply, m_pMsg->GetId(), g_pINOS1ms->GetTickDelta(m_iStart));
            }
            else {
                m_pModule->iWaitObjReply(aeReply);
            }
        } // end if
    };
    virtual uint32 Complete(CINOSMcModule* apModule, CINOSTaskEx::ERplId& aeReply, real64 arTimeout) {
        m_pMsg->AddResult(arTimeout);
        return 0;
    }
    CINOSMcModule* m_pModule;
    CINOSTaskExMsg* m_pMsg;
    int32 m_iStart;
    bool m_bSignaled;
    CINOSMcModuleWaitObj* m_pNext;
    DECLARE_DYNAMIC(CINOSMcModuleWaitObj);
};
 
//------------------------------------------------------------------------------
// class CINOSMcModuleWaitVar
//------------------------------------------------------------------------------
 
template <class T> class CINOSMcModuleWaitVar : public CINOSMcModuleWaitObj
{
    friend class CINOSMcModule;
    CINOSMcModuleWaitVar(T* apVar, uint32 auType, real64 arValue)
        :  CINOSMcModuleWaitObj() {
        // init members
        m_pVar = apVar;
        m_uType = auType;
        m_rValue = arValue;
    };
    virtual void Handle(){
        // check if already signaled
        if (m_bSignaled) return;
        // locals
        real64 rValue = real64(*m_pVar);
        // check adc
        switch (m_uType) {
            // case eTypWaitGt
            case 0 : {
                // do compare
                if (rValue>m_rValue){
                    // ok -> signal module
                    Reply(CINOSTaskEx::eRplOk);         
                    // thats it
                    return;
                } // end if
                break;
            } // end case eTypWaitGt        
            // case eTypWaitGte
            case 1 : {
                // do compare
                if (rValue>=m_rValue){
                    // ok -> signal module
                    Reply(CINOSTaskEx::eRplOk);         
                    // thats it
                    return;
                } // end if
                break;
            } // end case eTypWaitGte       
            // case eTypWaitLt
            case 2 : {
                // do compare
                if (rValue<m_rValue){
                    // ok -> signal module
                    Reply(CINOSTaskEx::eRplOk);         
                    // thats it
                    return;
                } // end if
                break;
            } // end case eTypWaitLt        
            // case eTypWaitLte
            case 3 : {
                // do compare
                if (rValue<=m_rValue){
                    // ok -> signal module
                    Reply(CINOSTaskEx::eRplOk);         
                    // thats it
                    return;
                } // end if
                break;
            } // end case eTypWaitLte       
            // case eTypWaitEq
            case 4 : {
                // do compare
                if (rValue==m_rValue){
                    // ok -> signal module
                    Reply(CINOSTaskEx::eRplOk);         
                    // thats it
                    return;
                } // end if
                break;
            } // end case eTypWaitLte       
        } // end switch
    };
    T* m_pVar;
    uint32 m_uType;
    real64 m_rValue;
    DECLARE_DYNAMIC_T(CINOSMcModuleWaitVar, T);
};
IMPLEMENT_DYNAMIC_T(CINOSMcModuleWaitVar, T);
 
//------------------------------------------------------------------------------
//
template <class T> CINOSTaskEx::ERplId CINOSMcModule::WaitVar(T* apVal, ETypWait aeTypWait, 
    real64 arValue, real64 arTimeout, real64& arUsed)
{
    // check if we have to wait (if no adc pointer is given -> assume ok)
    T val = *apVal;
    if (((aeTypWait==eTypWaitGt) && (real64(val)>arValue)) ||
        ((aeTypWait==eTypWaitGte) && (real64(val)>=arValue)) ||
        ((aeTypWait==eTypWaitLt) && (real64(val)<arValue)) ||
        ((aeTypWait==eTypWaitLte) && (real64(val)<=arValue)) ||
        ((aeTypWait==eTypWaitEq) && (real64(val)==arValue))){
        // ok -> set used time
        arUsed = REAL64(0.0);
        // thats it
        return CINOSTaskEx::eRplOk;
    } // end if
 
    // cancel pending ?
    if (GetRequest(eReqCancel)){
        // yes -> return 'canceled'
        return eRplCanceled;
    }
    // stop pending ?
    else if (GetRequest(eReqStop)){
        // yes -> return 'stopped'
        return eRplStopped;
    }
    // pause pending ?
    else if (GetRequest(eReqPause)){
        // yes -> return 'paused'
        return eRplPaused;
    }
    // reset sync object
    m_sWaitObj.Reset();
    m_eWaitObj = eRplError;
    // set critical flag 'waitobj'
    SetCritical(eCrtWaitObj);
    // create wait object
    CINOSMcModuleWaitVar<T>* obj = new CINOSMcModuleWaitVar<T>(apVal, aeTypWait, arValue);
    // add it to the list
    uint32 uMsr = INOSDisableInterrupts();
    obj->m_pNext = m_pWaitObj;
    m_pWaitObj = obj;
    INOSEnableInterrupts(uMsr);
    // ensure wait handler is running
    RegisterWaitObjHookLazy();
    // get start ticks
    int32 iStart = g_pINOS1ms->GetTickCount();
    // wait for signal
    if (arTimeout!=REAL64(0.0)){
        m_sWaitObj.Wait((uint32)(arTimeout*REAL64(1000.0)));
    } // end if
    else {
        m_sWaitObj.Wait(INOS_WAIT_FOREVER);
    } // end else
    // get delta
    arUsed = g_pINOS1ms->GetTickDelta(iStart); 
    // clear critical flag 'waitobj'
    ClrCritical(eCrtWaitObj);
    // remove obj from list
    uMsr = INOSDisableInterrupts();
    // walk through list
    CINOSMcModuleWaitObj* mbr = m_pWaitObj;
    CINOSMcModuleWaitObj* prv=0;
    while (mbr) {
        // found ?
        if (mbr==obj){
            // yes -> remove
            if (prv) prv->m_pNext = obj->m_pNext;
            else m_pWaitObj = obj->m_pNext;     
            // thats it
            break;
        } // end if
        // next object
        prv = mbr;
        mbr = mbr->m_pNext;
    } // end while
    INOSEnableInterrupts(uMsr);
    // and delete it
    delete obj;
    // return synccall result
    return m_eWaitObj;
    
    // end CINOSMcModule::WaitVar
}
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSMCMODULE_H