MBExchange.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 _MBExchange_H_
#define _MBExchange_H_
// -----------------------------------------------------------------------------
#include <ostream>
#include <string>
#include <map>
#include <unordered_map>
#include <memory>
#include "IONotifyController.h"
#include "UniSetObject.h"
#include "PassiveTimer.h"
#include "DelayTimer.h"
#include "Trigger.h"
#include "Mutex.h"
#include "Calibration.h"
#include "SMInterface.h"
#include "SharedMemory.h"
#include "ThreadCreator.h"
#include "IOBase.h"
#include "VTypes.h"
#include "MTR.h"
#include "RTUStorage.h"
#include "modbus/ModbusClient.h"
#include "LogAgregator.h"
#include "LogServer.h"
#include "LogAgregator.h"
#include "VMonitor.h"
// -----------------------------------------------------------------------------
#ifndef vmonit
#define vmonit( var ) vmon.add( #var, var )
#endif
// -------------------------------------------------------------------------
namespace uniset
{
// -----------------------------------------------------------------------------
class MBExchange:
    public UniSetObject
{
    public:
        MBExchange( uniset::ObjectId objId, uniset::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr,
                    const std::string& prefix = "mb" );
        virtual ~MBExchange();

        static void help_print( int argc, const char* const* argv );

        static const int NoSafetyState = -1;

        enum ExchangeMode
        {
            emNone = 0,       
            emWriteOnly = 1,  
            emReadOnly = 2,   
            emSkipSaveToSM = 3, 
            emSkipExchange = 4 
        };

        friend std::ostream& operator<<( std::ostream& os, const ExchangeMode& em );

        enum DeviceType
        {
            dtUnknown,      
            dtRTU,          
            dtMTR,          
            dtRTU188        
        };

        static DeviceType getDeviceType( const std::string& dtype );
        friend std::ostream& operator<<( std::ostream& os, const DeviceType& dt );

        struct RTUDevice;
        struct RegInfo;

        struct RSProperty:
            public IOBase
        {
            // only for RTU
            short nbit;             
            VTypes::VType vType;    
            unsigned short rnum;    
            unsigned short nbyte;   
            RSProperty():
                nbit(-1), vType(VTypes::vtUnknown),
                rnum(VTypes::wsize(VTypes::vtUnknown)),
                nbyte(0)
            {}

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

            std::shared_ptr<RegInfo> reg;
        };

        friend std::ostream& operator<<( std::ostream& os, const RSProperty& p );

        typedef std::list<RSProperty> PList;
        static std::ostream& print_plist( std::ostream& os, const PList& p );

        typedef std::map<ModbusRTU::RegID, std::shared_ptr<RegInfo>> RegMap;
        struct RegInfo
        {
            // т.к. RSProperty содержит rwmutex с запрещённым конструктором копирования
            // приходится здесь тоже объявлять разрешенными только операции "перемещения"
            RegInfo( const RegInfo& r ) = default;
            RegInfo& operator=(const RegInfo& r) = delete;
            RegInfo( RegInfo&& r ) = delete;
            RegInfo& operator=(RegInfo&& r) = default;

            RegInfo():
                mbval(0), mbreg(0), mbfunc(ModbusRTU::fnUnknown),
                id(0), dev(0),
                rtuJack(RTUStorage::nUnknown), rtuChan(0),
                mtrType(MTR::mtUnknown),
                q_num(0), q_count(1), mb_initOK(false), sm_initOK(false)
            {}

            ModbusRTU::ModbusData mbval;
            ModbusRTU::ModbusData mbreg;            
            ModbusRTU::SlaveFunctionCode mbfunc;    
            PList slst;
            ModbusRTU::RegID id;

            std::shared_ptr<RTUDevice> dev;

            // only for RTU188
            RTUStorage::RTUJack rtuJack;
            int rtuChan;

            // only for MTR
            MTR::MTRType mtrType;    
            // optimization
            size_t q_num;      
            size_t q_count;    
            RegMap::iterator rit;

            // начальная инициалиазция для "записываемых" регистров
            // Механизм:
            // Если tcp_preinit="1", то сперва будет сделано чтение значения из устройства.
            // при этом флаг mb_init=false пока не пройдёт успешной инициализации
            // Если tcp_preinit="0", то флаг mb_init сразу выставляется в true.
            bool mb_initOK;    
            // Флаг sm_init означает, что писать в устройство нельзя, т.к. значение в "карте регистров"
            // ещё не инициализировано из SM
            bool sm_initOK;    
        };

        friend std::ostream& operator<<( std::ostream& os, RegInfo& r );
        friend std::ostream& operator<<( std::ostream& os, RegInfo* r );

        struct RTUDevice
        {
            RTUDevice():
                mbaddr(0),
                dtype(dtUnknown),
                resp_id(uniset::DefaultObjectId),
                resp_state(false),
                resp_invert(false),
                numreply(0),
                prev_numreply(0),
                ask_every_reg(false),
                mode_id(uniset::DefaultObjectId),
                mode(emNone),
                speed(ComPort::ComSpeed38400),
                rtu188(0)
            {
            }

            ModbusRTU::ModbusAddr mbaddr;    
            std::unordered_map<unsigned int, std::shared_ptr<RegMap>> pollmap;

            DeviceType dtype;    
            // resp - respond..(контроль наличия связи)
            uniset::ObjectId resp_id;
            IOController::IOStateList::iterator resp_it;
            DelayTimer resp_Delay; // таймер для формирования задержки на отпускание (пропадание связи)
            PassiveTimer resp_ptInit; // таймер для формирования задержки на инициализацию связи (задержка на выставление датчика связи после запуска)
            bool resp_state;
            bool resp_invert;
            bool resp_force = { false };
            Trigger trInitOK; // триггер для "инициализации"
            std::atomic<size_t> numreply; // количество успешных запросов..
            std::atomic<size_t> prev_numreply;

            //
            bool ask_every_reg; 
            // режим работы
            uniset::ObjectId mode_id;
            IOController::IOStateList::iterator mode_it;
            long mode; // режим работы с устройством (см. ExchangeMode)

            // return TRUE if state changed
            bool checkRespond( std::shared_ptr<DebugStream>& log );

            // специфические поля для RS
            ComPort::Speed speed;
            std::shared_ptr<RTUStorage> rtu188;

            std::string getShortInfo() const;
        };

        friend std::ostream& operator<<( std::ostream& os, RTUDevice& d );

        typedef std::unordered_map<ModbusRTU::ModbusAddr, std::shared_ptr<RTUDevice>> RTUDeviceMap;

        friend std::ostream& operator<<( std::ostream& os, RTUDeviceMap& d );
        void printMap(RTUDeviceMap& d);

        // ----------------------------------
        enum Timer
        {
            tmExchange
        };

        void execute();

        inline std::shared_ptr<LogAgregator> getLogAggregator()
        {
            return loga;
        }
        inline std::shared_ptr<DebugStream> log()
        {
            return mblog;
        }

        virtual uniset::SimpleInfo* getInfo( const char* userparam = 0 ) override;

    protected:
        virtual void step();
        virtual void sysCommand( const uniset::SystemMessage* msg ) override;
        virtual void sensorInfo( const uniset::SensorMessage* sm ) override;
        virtual void timerInfo( const uniset::TimerMessage* tm ) override;
        virtual void askSensors( UniversalIO::UIOCommand cmd );
        virtual void initOutput();
        virtual void sigterm( int signo ) override;
        virtual bool activateObject() override;
        virtual void initIterators();
        virtual void initValues();

        struct InitRegInfo
        {
            InitRegInfo():
                dev(0), mbreg(0),
                mbfunc(ModbusRTU::fnUnknown),
                initOK(false)
            {}
            RSProperty p;
            std::shared_ptr<RTUDevice> dev;
            ModbusRTU::ModbusData mbreg;
            ModbusRTU::SlaveFunctionCode mbfunc;
            bool initOK;
            std::shared_ptr<RegInfo> ri;
        };
        typedef std::list<InitRegInfo> InitList;

        void firstInitRegisters();
        bool preInitRead( InitList::iterator& p );
        bool initSMValue( ModbusRTU::ModbusData* data, int count, RSProperty* p );
        bool allInitOK;

        RTUDeviceMap devices;
        InitList initRegList;    
        //      uniset::uniset_rwmutex pollMutex;

        virtual std::shared_ptr<ModbusClient> initMB( bool reopen = false ) = 0;

        virtual bool poll();
        bool pollRTU( std::shared_ptr<RTUDevice>& dev, RegMap::iterator& it );

        void updateSM();
        void updateRTU(RegMap::iterator& it);
        void updateMTR(RegMap::iterator& it);
        void updateRTU188(RegMap::iterator& it);
        void updateRSProperty( RSProperty* p, bool write_only = false );
        virtual void updateRespondSensors();

        bool checkUpdateSM( bool wrFunc, long devMode );
        bool checkPoll( bool wrFunc ) const;

        bool checkProcActive() const;
        void setProcActive( bool st );
        void waitSMReady();

        void readConfiguration();
        bool readItem( const std::shared_ptr<UniXML>& xml, UniXML::iterator& it, xmlNode* sec );
        bool initItem( UniXML::iterator& it );
        void initDeviceList();
        void initOffsetList();

        std::shared_ptr<RTUDevice> addDev( RTUDeviceMap& dmap, ModbusRTU::ModbusAddr a, UniXML::iterator& it );
        std::shared_ptr<RegInfo> addReg(std::shared_ptr<RegMap>& devices, ModbusRTU::RegID id, ModbusRTU::ModbusData r, UniXML::iterator& it, std::shared_ptr<RTUDevice> dev );
        RSProperty* addProp( PList& plist, RSProperty&& p );

        bool initMTRitem(UniXML::iterator& it, std::shared_ptr<RegInfo>& p );
        bool initRTU188item(UniXML::iterator& it, std::shared_ptr<RegInfo>& p );
        bool initRSProperty( RSProperty& p, UniXML::iterator& it );
        bool initRegInfo(std::shared_ptr<RegInfo>& r, UniXML::iterator& it, std::shared_ptr<RTUDevice>& dev  );
        bool initRTUDevice( std::shared_ptr<RTUDevice>& d, UniXML::iterator& it );
        virtual bool initDeviceInfo( RTUDeviceMap& m, ModbusRTU::ModbusAddr a, UniXML::iterator& it );

        std::string initPropPrefix( const std::string& def_prop_prefix = "" );

        void rtuQueryOptimization( RTUDeviceMap& m );

        xmlNode* cnode = { 0 };
        std::string s_field;
        std::string s_fvalue;

        std::shared_ptr<SMInterface> shm;

        timeout_t initPause = { 3000 };
        uniset::uniset_rwmutex mutex_start;

        bool force =  { false };        
        bool force_out = { false };    
        bool mbregFromID = { false };
        timeout_t polltime = { 100 };    
        timeout_t sleepPause_msec;
        size_t maxQueryCount = { ModbusRTU::MAXDATALEN }; 
        PassiveTimer ptHeartBeat;
        uniset::ObjectId sidHeartBeat = { uniset::DefaultObjectId };
        long maxHeartBeat = { 10 };
        IOController::IOStateList::iterator itHeartBeat;
        uniset::ObjectId test_id = { uniset::DefaultObjectId };

        uniset::ObjectId sidExchangeMode = { uniset::DefaultObjectId }; 
        IOController::IOStateList::iterator itExchangeMode;
        long exchangeMode = {emNone}; 
        std::atomic_bool activated = { false };
        timeout_t activateTimeout = { 20000 }; // msec
        bool noQueryOptimization = { false };
        bool no_extimer = { false };

        std::string prefix;

        timeout_t stat_time = { 0 };      
        size_t poll_count = { 0 };
        PassiveTimer ptStatistic; 
        std::string statInfo = { "" };

        std::string prop_prefix;  
        std::shared_ptr<ModbusClient> mb;

        // определение timeout для соединения
        timeout_t recv_timeout = { 500 }; // msec
        timeout_t default_timeout = { 5000 }; // msec

        timeout_t aftersend_pause = { 0 };

        PassiveTimer ptReopen; 
        Trigger trReopen;

        PassiveTimer ptInitChannel; 
        // т.к. пороговые датчики не связаны напрямую с обменом, создаём для них отдельный список
        // и отдельно его проверяем потом
        typedef std::list<IOBase> ThresholdList;
        ThresholdList thrlist;

        std::string defaultMBtype;
        std::string defaultMBaddr;
        bool defaultMBinitOK = { false }; // флаг определяющий нужно ли ждать "первого обмена" или при запуске сохранять в SM значение default.

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

        VMonitor vmon;

        size_t ncycle = { 0 }; 
    private:
        MBExchange();

};
// --------------------------------------------------------------------------
} // end of namespace uniset
// -----------------------------------------------------------------------------
#endif // _MBExchange_H_
// -----------------------------------------------------------------------------