IOControl.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, version 2.1.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// -----------------------------------------------------------------------------
#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"
// -------------------------------------------------------------------------
namespace uniset
{
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
class CardList:
    public std::vector<ComediInterface*>
{
    public:

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

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

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

            return NULL;
        }

};

class IOControl:
    public UniSetObject
{
    public:
        IOControl( uniset::ObjectId id, uniset::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,
                                                          uniset::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(size_t  p, size_t i):
                priority(p), index(i) {}

            size_t  priority;
            size_t 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 uniset::SystemMessage* sm ) override;
        virtual void askSensors( UniversalIO::UIOCommand cmd );
        virtual void sensorInfo( const uniset::SensorMessage* sm ) override;
        virtual void timerInfo( const uniset::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();

        xmlNode* confnode = { 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;
        uniset::ObjectId myid = { uniset::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 };

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

        PassiveTimer ptHeartBeat;
        uniset::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 };        
        std::mutex iopollMutex;
        std::atomic_bool activated = { false };
        bool readconf_ok = { false };
        int activateTimeout;
        uniset::ObjectId sidTestSMReady = { uniset::DefaultObjectId };
        std::atomic_bool term = { false };

        uniset::ObjectId testMode_as = { uniset::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:
};
// --------------------------------------------------------------------------
} // end of namespace uniset
// -----------------------------------------------------------------------------
#endif // IOControl_H_
// -----------------------------------------------------------------------------