IOControl/IOControl.h

// -----------------------------------------------------------------------------
#ifndef IOControl_H_
#define IOControl_H_
// -----------------------------------------------------------------------------
#include <vector>
#include <deque>
#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 );

        struct IOInfo:
            public IOBase
        {
            // т.к. IOBase содержит rwmutex с запрещённым конструктором копирования
            // приходится здесь тоже объявлять разрешенными только операции "перемещения"
            IOInfo( const IOInfo& r ) = delete;
            IOInfo& operator=(const IOInfo& r) = delete;
            IOInfo( IOInfo&& r ) = default;
            IOInfo& operator=(IOInfo&& r) = default;

            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 sysCommand( const UniSetTypes::SystemMessage* sm ) override;
        virtual void askSensors( UniversalIO::UIOCommand cmd );
        virtual void sensorInfo( const UniSetTypes::SensorMessage* sm ) override;
        virtual void timerInfo( const UniSetTypes::TimerMessage* tm ) override;
        virtual void sigterm( int signo ) override;
        virtual bool activateObject() override;

        // начальная инициализация выходов
        void initOutputs();

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

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

        void waitSM();

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

        xmlNode* cnode; 
        int polltime;   
        CardList cards; 
        bool noCards;

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

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

        SMInterface* shm;
        UInterface 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::IOStateList::iterator itTestLamp;

        PassiveTimer ptHeartBeat;
        UniSetTypes::ObjectId sidHeartBeat;
        int maxHeartBeat;
        IOController::IOStateList::iterator itHeartBeat;

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


        UniSetTypes::ObjectId testMode_as;
        IOController::IOStateList::iterator itTestMode;
        long testmode;
        long prev_testmode;

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