APSControl.h

#ifndef APSControl_H_
#define APSControl_H_
// ------------------------------------------------------------------------------------------
#include <map>
#include <list>
#include <UniSetObject_LT.h>
#include <MessageType.h>
#include <PassiveTimer.h>
#include <Trigger.h>
#include <extensions/SMInterface.h>
// ------------------------------------------------------------------------------------------
class APSControl:
    public  UniSetObject_LT 
{
    public:
    
        APSControl( UniSetTypes::ObjectId id, const std::string& name="APSControl" );
        ~APSControl();

        static DebugStream dlog;
        static void init_dlog( DebugStream& dlog );

    protected:
    
        void processingMessage(UniSetTypes::VoidMessage *msg);
        
        void askSensors(UniversalIO::UIOCommand cmd);
        
        void sysCommand(UniSetTypes::SystemMessage *sm);
        
        void sensorInfo(UniSetTypes::SensorMessage *sm);
        
        void timerInfo(UniSetTypes::TimerMessage *tm);
        
        void makeAPS(UniSetTypes::ObjectId id, bool state); 
        
        void makeAPSLamp( bool newAPS, bool isAnyAPS );

        void makeNewAPSSensor( bool newAPS );

    //  string getShortName(const string& fullName, char brk = ':');
    
        struct APSSensorInfo
        {
            UniSetTypes::ObjectId id;       
            UniSetTypes::ObjectId apsId;    
            UniSetTypes::ObjectId blockerId;
            bool state;                     
            bool no_apslamp;        
            APSSensorInfo():
                id(UniSetTypes::DefaultObjectId),
                apsId(UniSetTypes::DefaultObjectId),
                blockerId(UniSetTypes::DefaultObjectId),
                state(false),
                no_apslamp(false)
            {};
        };
        
        std::map<UniSetTypes::ObjectId,APSSensorInfo> sensorToAPS;              // <sensorId,APSSsensorInfo>
        std::map<UniSetTypes::ObjectId,UniSetTypes::ObjectId>blockedSensors;    // <sensorId,blockSensorId>

        struct APSGroupInfo
        {
            UniSetTypes::ObjectId apsId; 
            bool apsState;
            std::list<UniSetTypes::ObjectId> sensIdList; 
            APSGroupInfo():apsId(UniSetTypes::DefaultObjectId),
            apsState( false )
            {};
        };
        
        typedef std::map<UniSetTypes::ObjectId,APSGroupInfo> APSGroupList;
        APSGroupList apsGroupsInfo;

        bool initAPS(xmlNode*cnode);

        SMInterface* smi;
        UniSetTypes::ObjectId testSensor;
        UniSetTypes::ObjectId nodeTestSensor;
        bool in_testSensor;
        bool in_nodeTestSensor;
        
        UniSetTypes::ObjectId sidHeartBeat;
        int maxHeartBeat;
        timeout_t heartbeatTime;

        UniSetTypes::ObjectId newaps_s; 
        UniSetTypes::ObjectId confirm_s; 
        bool confirmMode;               /*< режим нажатия кнопки квитирования ("1" - нажата "0" - отжата)*/
        UniSetTypes::ObjectId apsLamp_c; 
        enum Timers
        {
            ptHeartBeat
        };
        
        timeout_t smReadyTimeout;
        
        virtual void sigterm( int signo );
        void offOutputs( bool all );
        bool TermOffAps;
        bool checkTestMode();
        
        std::string f_field;
        std::string f_value;
        std::string f_group;
        
        timeout_t apsMakePause; 
    private:
        timeout_t askTimeout;   
        timeout_t askPause;     
        Trigger trTestMode;
};

#endif // APSControl_H_

---