include/IOControl.h

// -----------------------------------------------------------------------------
#ifndef IOControl_H_
#define IOControl_H_
// -----------------------------------------------------------------------------
#include <vector>
#include <list>
#include <string>
#include "UniXML.h"
#include "PassiveTimer.h"
#include "Trigger.h"
#include "IONotifyController.h"
#include "UniSetObject_LT.h"
#include "Mutex.h"
#include "MessageType.h"
#include "ComediInterface.h" 
#include "DigitalFilter.h" 
#include "Calibration.h" 
#include "SMInterface.h" 
#include "SingleProcess.h"
#include "IOController.h" 
#include "IOBase.h" 
#include "SharedMemory.h" 
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
class CardList:
    public std::vector<ComediInterface*>
{
    public:

        CardList(int size) : std::vector<ComediInterface*>(size) { }

        ~CardList() {
            for( unsigned int i=0; i<size(); i++ )
                delete (*this)[i];
        }

        inline ComediInterface* getCard(int ncard) {
            if( ncard >= 0 && ncard < (int)size() )
                return (*this)[ncard];
            return NULL;
    }

};

class IOControl:
    public UniSetObject
{
    public:
        IOControl( UniSetTypes::ObjectId id, UniSetTypes::ObjectId icID, SharedMemory* ic=0, int numcards=2, const std::string prefix="io" );
        virtual ~IOControl();

        static IOControl* init_iocontrol( int argc, const char* const* argv,
                                            UniSetTypes::ObjectId icID, SharedMemory* ic=0,
                                            const std::string prefix="io" );
        static void help_print( int argc, const char* const* argv );

//      inline std::string getName(){ return myname; }

        struct IOInfo:
            public IOBase
        {
            IOInfo():
                subdev(DefaultSubdev),channel(DefaultChannel),
                ncard(-1),
                aref(0),
                range(0),
                lamp(false),
                no_testlamp(false),
                enable_testmode(false),
                disable_testmode(false)
            {}


            int subdev;     
            int channel;    
            int ncard;      
            int aref;

            int range;

            bool lamp;      
            bool no_testlamp; 
            bool enable_testmode; 
            bool disable_testmode; 
            friend std::ostream& operator<<(std::ostream& os, IOInfo& inf );
        };

        struct IOPriority
        {
            IOPriority(int p, int i):
                priority(p),index(i){}
                
            int priority;
            int index;
        };
        
        enum TestModeID
        {
            tmNone      = 0,        
            tmOffPoll   = 1,        
            tmConfigEnable  = 2,    
            tmConfigDisable = 3,    
            tmOnlyInputs    = 4,    
            tmOnlyOutputs   = 5     
        };

        void execute();

    protected:

        void iopoll(); 
        void ioread( IOInfo* it );
        void check_testlamp();
        void check_testmode();
        void blink();
    
        // действия при завершении работы
        virtual void processingMessage( UniSetTypes::VoidMessage* msg );
        virtual void sysCommand( UniSetTypes::SystemMessage* sm );
        virtual void askSensors( UniversalIO::UIOCommand cmd );
        virtual void sensorInfo( UniSetTypes::SensorMessage* sm );
        virtual void timerInfo( UniSetTypes::TimerMessage* tm );
        virtual void sigterm( int signo );
        virtual bool activateObject();
        
        // начальная инициализация выходов
        void initOutputs();

        // инициализация карты (каналов в/в)
        void initIOCard();

        // чтение файла конфигурации
        void readConfiguration();
        bool initIOItem( UniXML_iterator& it );
        bool readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec );
        void buildCardsList();

        void waitSM();

        bool checkCards( const std::string func="" );

//      std::string myname;
        xmlNode* cnode;         
        int polltime;           
        CardList cards;         
        bool noCards;


        typedef std::vector<IOInfo> IOMap;
        IOMap iomap;            
        typedef std::list<IOPriority> PIOMap;
        PIOMap pmap;    
        unsigned int maxItem;   
        unsigned int maxHalf;
        int filtersize;
        float filterT;

        std::string s_field;
        std::string s_fvalue;

        SMInterface* shm;         
        UniversalInterface ui;
        UniSetTypes::ObjectId myid;
        std::string prefix;

        typedef std::list<IOInfo*> BlinkList;

        void addBlink( IOInfo* it, BlinkList& lst );
        void delBlink( IOInfo* it, BlinkList& lst );
        void blink( BlinkList& lst, bool& bstate );

        // обычное мигание
        BlinkList lstBlink;
        PassiveTimer ptBlink;
        bool blink_state;
        
        // мигание с двойной частотой
        BlinkList lstBlink2;
        PassiveTimer ptBlink2;
        bool blink2_state;

        // мигание с тройной частотой
        BlinkList lstBlink3;
        PassiveTimer ptBlink3;
        bool blink3_state;
        
        UniSetTypes::ObjectId testLamp_S;
        Trigger trTestLamp;
        bool isTestLamp;
        IOController::DIOStateList::iterator ditTestLamp;

        PassiveTimer ptHeartBeat;
        UniSetTypes::ObjectId sidHeartBeat;
        int maxHeartBeat;
        IOController::AIOStateList::iterator aitHeartBeat;

        bool force;         
        bool force_out;     
        int smReadyTimeout;     
        int defCardNum;     
        int maxCardNum;     
        UniSetTypes::uniset_mutex iopollMutex;
        bool activated;
        bool readconf_ok;
        int activateTimeout;
        UniSetTypes::ObjectId sidTestSMReady;
        bool term;


        UniSetTypes::ObjectId testMode_as;
        IOController::AIOStateList::iterator aitTestMode;
        long testmode;
        long prev_testmode;

    private:
};
// -----------------------------------------------------------------------------
#endif // IOControl_H_
// -----------------------------------------------------------------------------