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 "ThreadCreator.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 "IOController.h"
#include "IOBase.h"
#include "SharedMemory.h"
#include "LogServer.h"
#include "DebugStream.h"
#include "LogAgregator.h"
#include "USingleProcess.h"
// -------------------------------------------------------------------------
#ifndef vmonit
#define vmonit( var ) vmon.add( #var, var )
#endif
// -------------------------------------------------------------------------
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 < size() )
                    return (*this)[ncard];
 
                return nullptr;
            }
 
            inline ComediInterface* getCard( size_t ncard ) const
            {
                if( ncard < size() )
                    return (*this)[ncard];
 
                return nullptr;
            }
 
    };

    class IOControl:
        private USingleProcess,
        public UniSetObject
    {
        public:
            IOControl( uniset::ObjectId id, xmlNode* cnode,
                       uniset::ObjectId icID, const std::shared_ptr<SharedMemory>& shm = nullptr, size_t 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 );
 
            virtual uniset::SimpleInfo* getInfo( const char* userparam = 0 ) override;

            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() {}
 
                int subdev = { DefaultSubdev };   
                int channel = { DefaultChannel }; 
                int ncard = { DefaultCard };      

                int aref = { 0 };
 
                int adelay = { 0 }; 

                int range = { 0 };
 
                bool lamp = { false };             
                bool no_testlamp = { false };      
                bool enable_testmode = { false };  
                bool disable_testmode = { false }; 
 
                friend std::ostream& operator<<(std::ostream& os, const IOInfo& inf );
                friend std::ostream& operator<<(std::ostream& os, const std::shared_ptr<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   
            };
 
        protected:
 
            void iopoll(); 
            void ioread( std::shared_ptr<IOInfo>& it );
            void check_testlamp();
            void check_testmode();
            void blink();
            void iothread();
 
            // действия при завершении работы
            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 bool activateObject() override;
            virtual bool deactivateObject() 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();
 
            bool waitSM();
 
            xmlNode* confnode = { 0 }; 
 
            int polltime = { 150 };   
            CardList cards; 
            bool noCards = { false };
 
            typedef std::vector< std::shared_ptr<IOInfo> > IOMap;
            IOMap iomap;    
 
            typedef std::deque<IOPriority> PIOMap;
            PIOMap pmap;    
 
            size_t maxItem = { 0 };    
            size_t 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<std::shared_ptr<IOInfo>> BlinkList;
 
            void addBlink( std::shared_ptr<IOInfo>& it, BlinkList& lst );
            void delBlink( std::shared_ptr<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 };    
            ssize_t defCardNum = { -1 };        
            size_t maxCardNum = { 10 };        
 
            std::mutex iopollMutex;
            std::atomic_bool activated = { false };
            std::atomic_bool cancelled = { false };
            bool readconf_ok = { false };
            int activateTimeout;
            uniset::ObjectId sidTestSMReady = { uniset::DefaultObjectId };
 
            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};
 
            std::shared_ptr< ThreadCreator<IOControl> > ioThread;
 
            VMonitor vmon;
 
        private:
    };
    // --------------------------------------------------------------------------
} // end of namespace uniset
// -----------------------------------------------------------------------------
#endif // IOControl_H_
// -----------------------------------------------------------------------------