ModbusMaster/MBExchange.h

#ifndef _MBExchange_H_
#define _MBExchange_H_
// -----------------------------------------------------------------------------
#include <ostream>
#include <string>
#include <map>
#include <vector>
#include "IONotifyController.h"
#include "UniSetObject_LT.h"
#include "PassiveTimer.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"
// -----------------------------------------------------------------------------
class MBExchange:
    public UniSetObject_LT
{
    public:
        MBExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
                        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,         
            emWriteOnly,    
            emReadOnly,     
            emSkipSaveToSM  
        };

        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;    
            short rnum;             
            short nbyte;            
            RSProperty():
                nbit(-1),vType(VTypes::vtUnknown),
                rnum(VTypes::wsize(VTypes::vtUnknown)),
                nbyte(0),reg(0)
            {}

            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, PList& p );

        typedef unsigned long RegID;

        typedef std::map<RegID,RegInfo*> RegMap;
        struct RegInfo
        {
            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(true),sm_initOK(true)
            {}

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

            RTUDevice* dev;

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

            // only for MTR
            MTR::MTRType mtrType;   
            // optimization
            int q_num;      
            int 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():
            respnond(false),
            mbaddr(0),
            dtype(dtUnknown),
            resp_id(UniSetTypes::DefaultObjectId),
            resp_state(false),
            resp_invert(false),
            resp_real(false),
            resp_init(false),
            ask_every_reg(false),
            speed(ComPort::ComSpeed38400),
            rtu(0)
            {
                resp_trTimeout.change(false);
            }
            
            bool respnond;
            ModbusRTU::ModbusAddr mbaddr;   
            RegMap regmap;

            DeviceType dtype;   
            UniSetTypes::ObjectId resp_id;
            IOController::DIOStateList::iterator resp_dit;
            PassiveTimer resp_ptTimeout;
            Trigger resp_trTimeout;
            bool resp_state;
            bool resp_invert;
            bool resp_real;
            bool resp_init;
            bool ask_every_reg;

            // return TRUE if state changed
            bool checkRespond();

            // специфические поля для RS
            ComPort::Speed speed;
            RTUStorage* rtu;
        };

        friend std::ostream& operator<<( std::ostream& os, RTUDevice& d );
        
        typedef std::map<ModbusRTU::ModbusAddr,RTUDevice*> RTUDeviceMap;

        friend std::ostream& operator<<( std::ostream& os, RTUDeviceMap& d );
        void printMap(RTUDeviceMap& d);
        
        // ----------------------------------
        static RegID genRegID( const ModbusRTU::ModbusData r, const int fn );   

        enum Timer
        {
            tmExchange
        };

        void execute();
    
    protected:
        virtual void step();
        virtual void processingMessage( UniSetTypes::VoidMessage *msg );
        virtual void sysCommand( UniSetTypes::SystemMessage *msg );
        virtual void sensorInfo( UniSetTypes::SensorMessage*sm );
        virtual void timerInfo( UniSetTypes::TimerMessage *tm );
        virtual void askSensors( UniversalIO::UIOCommand cmd ); 
        virtual void initOutput();
        virtual void sigterm( int signo );
        virtual bool activateObject();
        virtual void initIterators();

        struct InitRegInfo
        {
            InitRegInfo():
            dev(0),mbreg(0),
            mbfunc(ModbusRTU::fnUnknown),
            initOK(false),ri(0)
            {}
            RSProperty p;
            RTUDevice* dev;
            ModbusRTU::ModbusData mbreg;
            ModbusRTU::SlaveFunctionCode mbfunc;
            bool initOK;
            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 rmap;
        InitList initRegList;   
        UniSetTypes::uniset_mutex pollMutex;

        virtual ModbusClient* initMB( bool reopen=false )= 0;
        
        virtual void poll();
        bool pollRTU( 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 );
        bool checkPoll( bool wrFunc );
        
        bool checkProcActive();
        void setProcActive( bool st );
        void waitSMReady();

        void readConfiguration();
        bool readItem( UniXML& xml, UniXML_iterator& it, xmlNode* sec );
        bool initItem( UniXML_iterator& it );
        void initDeviceList();
        void initOffsetList();

        RTUDevice* addDev( RTUDeviceMap& dmap, ModbusRTU::ModbusAddr a, UniXML_iterator& it );
        RegInfo* addReg( RegMap& rmap, RegID id, ModbusRTU::ModbusData r, UniXML_iterator& it,
                            RTUDevice* dev, RegInfo* rcopy=0 );
        RSProperty* addProp( PList& plist, RSProperty& p );

        bool initMTRitem( UniXML_iterator& it, RegInfo* p );
        bool initRTU188item( UniXML_iterator& it, RegInfo* p );
        bool initRSProperty( RSProperty& p, UniXML_iterator& it );
        bool initRegInfo( RegInfo* r, UniXML_iterator& it, RTUDevice* dev  );
        bool initRTUDevice( RTUDevice* d, UniXML_iterator& it );
        virtual bool initDeviceInfo( RTUDeviceMap& m, ModbusRTU::ModbusAddr a, UniXML_iterator& it );

        void rtuQueryOptimization( RTUDeviceMap& m );

        xmlNode* cnode;
        std::string s_field;
        std::string s_fvalue;

        SMInterface* shm;
        
        bool initPause;
        UniSetTypes::uniset_mutex mutex_start;

        bool force;     
        bool force_out; 
        bool mbregFromID;
        int polltime;   
        timeout_t sleepPause_usec;

        PassiveTimer ptHeartBeat;
        UniSetTypes::ObjectId sidHeartBeat;
        int maxHeartBeat;
        IOController::AIOStateList::iterator aitHeartBeat;
        UniSetTypes::ObjectId test_id;

        UniSetTypes::ObjectId sidExchangeMode; 
        IOController::AIOStateList::iterator aitExchangeMode;
        long exchangeMode; 
        UniSetTypes::uniset_mutex actMutex;
        bool activated;
        int activateTimeout;
        bool noQueryOptimization;
        bool no_extimer;
        
        std::string prefix;
        
        timeout_t stat_time;        
        int poll_count;
        PassiveTimer ptStatistic;   
        std::string prop_prefix;  
        ModbusClient* mb;

        // определение timeout для соединения
        PassiveTimer ptTimeout;
        bool pollActivated;
        int recv_timeout;

     private:
        MBExchange();

};
// -----------------------------------------------------------------------------
#endif // _MBExchange_H_
// -----------------------------------------------------------------------------