SEES.h

// ------------------------------------------------------------------------------------------
#ifndef SEES_H_
#define SEES_H_
// ------------------------------------------------------------------------------------------
#include <TriggerOutput.h>
#include <TriggerOR.h>
#include <TriggerAND.h>
#include <ObjectsManager.h>
#include <DebugStream.h>
#include "ObjectMode.h"
#include "SEESMessages.h"
#include "SEESTypes.h" 
#include "SEES_SK.h"
// ------------------------------------------------------------------------------------------
class SEESMode;
class SEESControl;
class QG;
class Diesel;
class Generator;
class SEESGroup;
// ------------------------------------------------------------------------------------------
class SEES:
    public SEES_SK
{
    public:
        SEES( int gnum, const std::string& name, SEESControl* master, xmlNode* confnode );
        ~SEES();

        virtual char* getName();
        inline std::string getSESName(){ return myname; }

        inline int getNumber(){ return num; }
        
        inline int getGroupNumber(){ return gnum; }
        inline void setGroupNumber( int num ){ gnum = num; }

        int getReservPower();
        inline int getNominalPower(){ return npower; }
        long getP();
        long getU();
        long getF();

        SEESTypes::ControlMode getControlMode();
        inline ObjectMode getOMode(){ return (ObjectMode)in_state_as; }

        void requiredReserv( bool set );
        bool waitRunning();     
        bool waitStopping();    
        bool isOnMode();        
        bool isAutoMode();      
        bool isReservMode();    
        bool isProtection();    
        bool isAutoControl();   
        long getPriority();
        void setLeader( bool set );

//      bool isOnReserv();
        bool canReservRunning();
        bool canReservStopping();
        bool isReservOnNeeded();
        bool isReservOffNeeded();
        
        void onReservCommand();
        void offReservCommand();
        void resetReservCommand();
        void updateReservCommand();
        void setAloneWorking( bool state );

//      SEESMessage::SEESMode getMode();

        enum Timers
        {
            OnTimer,
            RunTimer,
            OffTimer,
            DGProtectionStopTimer,
            DGProtectionCheckTimer,
            QGTimer,
            AcceptWaitingTimer,
            AcceptControlTimer,
            Load20Timer,
            NoPowerTimer,
            BlockedRunTimer,
            UpdateStateTimer
        };

        const int OnTime;       
        const int QGOnTime;     
        const int QGOffTime;    
        const int RunTime;      
        const int OffTime;      
        const int AcceptWaitingTime;    
        const int AcceptControlTime;    
        const int Load20Time;           
        const int CmdPause;             
        const int ReservCount;          
        const int askTimeout;           
        const int askPause;             
        const int filterPause;          
        const int protectionPause;      
        const int initPause;            
        const int NoPowerTime;          
        int BlockedRunTime;             
        const int DGProtectionStopTime; 
        const int DGProtectionCheckTime; 
        const int modeTime;
        const int updateStateTime;      
        int resetPause;
        int initAttempts;       
        SEESControl* master;
        QG* qg;
        Diesel* dis;
        Generator* gen;

        bool setLamp(const UniSetTypes::ObjectId id, UniSetTypes::LampCommand cmd);

        TriggerOutput<SEES, SEES::Timers, int>* tm;

        enum InputId
        {
            // для команды включения резерва
            Load105,    
            Load95,     
            Protection, 
            Fault,      
            NoPower,    
            RequiredReserve, 
            // для команды отключения резерва
            ReservOn_Condition,     
            Load20                  
        };

        TriggerOutput<SEES, UniSetTypes::ObjectId, bool>* out;
//      TriggerAND<SEES,UniSetTypes::ObjectId>* reservMode;

        enum SigState
        {
            Sig_None,
            Sig_Filtrating,
            Sig_OK
        };

        SigState load20_sig; 
        TriggerOutput<SEES, UniSetTypes::ObjectId, bool>* msg;

        const UniSetTypes::ObjectId myPostID;
        
        static DebugStream dlog;
        static void init_dlog( DebugStream& dlog );
        
    protected:
        SEES();

        TriggerOR<SEES,SEES::InputId>* needReservOn;
        TriggerAND<SEES,SEES::InputId>* needReservOff;
        
        virtual void step();
//      virtual void processingMessage( UniSetTypes::VoidMessage *msg );
        virtual void sigterm( int signo );

        virtual void processingMessage( UniSetTypes::VoidMessage* msg );
        virtual void sysCommand( UniSetTypes::SystemMessage* sm );
        virtual void sensorInfo( UniSetTypes::SensorMessage* sm );
        virtual void timerInfo( UniSetTypes::TimerMessage* tm );
        void seesInfo( SEESMessage *sm );

        void changeMode( SEESMode* m );
        void setTimer(SEES::Timers tid, int val);
        void setOut(UniSetTypes::ObjectId sid, bool state);
        void setProtection( bool state );

        void onReservCondition( bool set );
        void offReservCondition( bool set );
        void updateReservNeeded();
        void resetModeTimer();
        void checkControlMode();
        
        void setMyControlMode( SEESTypes::ControlMode m );

        long getAnalogInput( UniSetTypes::ObjectId id );

        inline bool isHaveQGLock(){ return haveQGLock; }
        inline void setQGLock( bool set ){ haveQGLock = set; }

    private:
        friend class SEESMode;
        friend class SEESWaitingMode;
        friend class SEESAutoWaitingMode;
        friend class SEESProtectionMode;
        friend class SEESGroup;

        friend std::ostream& operator<<(std::ostream& os, SEES& am );
        friend std::ostream& operator<<(std::ostream& os, SEES* am );
        
        void init();

        SEESMode* mode;
        SEESTypes::ControlMode myMode;
        int gnum;
        int num;
        int maxPower;           
        int curReservPower;     
        PassiveTimer ptMode;
        
        PassiveTimer ptPing;
        PassiveTimer ptAnalog;      
        UniSetTypes::ObjectId power_as;
        UniSetTypes::ObjectId voltage_as;
        UniSetTypes::ObjectId frequency_as;
        long in_power_as;
        long in_voltage_as;
        long in_frequency_as;
        int npower;

        bool checkMode;
        Trigger trModeUnbalance;
        Trigger trModeUnbalanceCheck;
        PassiveTimer ptModeUnbalance;

        UniSetTypes::uniset_mutex myModeMutex;
        UniSetTypes::uniset_mutex modeMutex;
        UniSetTypes::uniset_mutex reservMutex;

        // Для переходных режимов
        SEESMessage::SEESMode toMode;   
        SEESMessage::SEESMode prevMode; 
        SEESMode* backMode;                         
        int attemptCounter;                         
        int attempt;                                
        bool protection;
        UniSetTypes::uniset_mutex protectionMutex; 
        bool in_RequiredReserve;        
        // ВНИМАНИЕ! Сделан только (!) для использованияв SEESGroup
        bool haveQGLock; 
};
// ------------------------------------------------------------------------------------------
#endif // SEES_H_
// ------------------------------------------------------------------------------------------

---