IOControl.h

// -----------------------------------------------------------------------------
#ifndef IOControl_H_
#define IOControl_H_
// -----------------------------------------------------------------------------
#include <vector>
#include <memory>
#include <deque>
#include <string>
#include "UniXML.h"
#include "PassiveTimer.h"
#include "Trigger.h"
#include "IONotifyController.h"
#include "UniSetObject.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"
#include "LogServer.h"
#include "DebugStream.h"
#include "LogAgregator.h"
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
class CardList:
    public std::vector<ComediInterface*>
{
    public:

        explicit 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, const std::shared_ptr<SharedMemory>& shm = nullptr, int numcards = 2, const std::string& prefix = "io" );
        virtual ~IOControl();

        static std::shared_ptr<IOControl> init_iocontrol( int argc, const char* const* argv,
                UniSetTypes::ObjectId icID, const std::shared_ptr<SharedMemory>& ic = nullptr,
                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 = { 0 }; 
        int polltime = { 150 };   
        CardList cards; 
        bool noCards = { false };

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

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

        std::shared_ptr<SMInterface> shm;
        UniSetTypes::ObjectId myid = { UniSetTypes::DefaultObjectId };
        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 = { false };

        // мигание с двойной частотой
        BlinkList lstBlink2;
        PassiveTimer ptBlink2;
        bool blink2_state = { false };

        // мигание с тройной частотой
        BlinkList lstBlink3;
        PassiveTimer ptBlink3;
        bool blink3_state = { false };

        UniSetTypes::ObjectId testLamp_s = { UniSetTypes::DefaultObjectId };
        Trigger trTestLamp;
        bool isTestLamp = { false };
        IOController::IOStateList::iterator itTestLamp;

        PassiveTimer ptHeartBeat;
        UniSetTypes::ObjectId sidHeartBeat;
        int maxHeartBeat = { 10 };
        IOController::IOStateList::iterator itHeartBeat;

        bool force = { false };            
        bool force_out = { false };        
        timeout_t smReadyTimeout = { 15000 };    
        int defCardNum = { -1 };        
        int maxCardNum = { 10 };        
        UniSetTypes::uniset_mutex iopollMutex;
        std::atomic_bool activated = { false };
        bool readconf_ok = { false };
        int activateTimeout;
        UniSetTypes::ObjectId sidTestSMReady = { UniSetTypes::DefaultObjectId };
        bool term = { false };


        UniSetTypes::ObjectId testMode_as = { UniSetTypes::DefaultObjectId };
        IOController::IOStateList::iterator itTestMode;
        long testmode = { false };
        long prev_testmode = { false };

        std::shared_ptr<LogAgregator> loga;
        std::shared_ptr<DebugStream> iolog;
        std::shared_ptr<LogServer> logserv;
        std::string logserv_host = {""};
        int logserv_port = {0};

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