extensions/ModbusSlave/MBSlave.h

// -----------------------------------------------------------------------------
#ifndef _MBSlave_H_
#define _MBSlave_H_
// -----------------------------------------------------------------------------
#include <ostream>
#include <string>
#include <memory>
#include <map>
#include <unordered_map>
#include <vector>
#include <condition_variable>
#include <atomic>
#include <mutex>
#include "UniSetObject.h"
#include "modbus/ModbusTypes.h"
#include "modbus/ModbusServerSlot.h"
#include "PassiveTimer.h"
#include "Trigger.h"
#include "Mutex.h"
#include "SMInterface.h"
#include "SharedMemory.h"
#include "IOBase.h"
#include "VTypes.h"
#include "ThreadCreator.h"
#include "LogServer.h"
#include "LogAgregator.h"
#include "VMonitor.h"
// -----------------------------------------------------------------------------
#ifndef vmonit
#define vmonit( var ) vmon.add( #var, var )
#endif
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
namespace std
{
    template<>
    class hash<ModbusRTU::mbErrCode>
    {
        public:
            size_t operator()(const ModbusRTU::mbErrCode& e) const
            {
                return std::hash<int>()((int)e);
            }
    };
}
// -----------------------------------------------------------------------------
class MBSlave:
    public UniSetObject
{
    public:
        MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr, const std::string& prefix = "mbs" );
        virtual ~MBSlave();

        static std::shared_ptr<MBSlave> init_mbslave(int argc, const char* const* argv,
                UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory>& ic = nullptr,
                const std::string& prefix = "mbs" );

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

        static const int NoSafetyState = -1;

        enum AccessMode
        {
            amRW,
            amRO,
            amWO
        };

        struct BitRegProperty;

        struct IOProperty:
            public IOBase
        {
            ModbusRTU::ModbusData mbreg;    
            AccessMode amode;
            VTypes::VType vtype;    
            int wnum;               
            int nbyte;              
            bool rawdata;           
            std::shared_ptr<BitRegProperty> bitreg; 
            ModbusRTU::RegID regID;

            IOProperty():
                mbreg(0),
                amode(amRW),
                vtype(VTypes::vtUnknown),
                wnum(0),
                nbyte(0),
                rawdata(false),
                regID(0)
            {}

            friend std::ostream& operator<<( std::ostream& os, IOProperty& p );
        };


        struct BitRegProperty
        {
            typedef std::vector<IOProperty> BitSensorMap;

            ModbusRTU::ModbusData mbreg; 
            BitSensorMap bvec;

            BitRegProperty(): mbreg(0), bvec(ModbusRTU::BitsPerData) {}

            bool check( const IOController_i::SensorInfo& si );

            friend std::ostream& operator<<( std::ostream& os, BitRegProperty& p );
            friend std::ostream& operator<<( std::ostream& os, BitRegProperty* p );
        };

        inline long getAskCount()
        {
            return askCount;
        }

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

        virtual UniSetTypes::SimpleInfo* getInfo( CORBA::Long userparam = 0 ) override;

    protected:

        ModbusRTU::mbErrCode readCoilStatus( ModbusRTU::ReadCoilMessage& query,
                                             ModbusRTU::ReadCoilRetMessage& reply );
        ModbusRTU::mbErrCode readInputStatus( ModbusRTU::ReadInputStatusMessage& query,
                                              ModbusRTU::ReadInputStatusRetMessage& reply );

        ModbusRTU::mbErrCode readOutputRegisters( ModbusRTU::ReadOutputMessage& query,
                ModbusRTU::ReadOutputRetMessage& reply );

        ModbusRTU::mbErrCode readInputRegisters( ModbusRTU::ReadInputMessage& query,
                ModbusRTU::ReadInputRetMessage& reply );

        ModbusRTU::mbErrCode forceSingleCoil( ModbusRTU::ForceSingleCoilMessage& query,
                                              ModbusRTU::ForceSingleCoilRetMessage& reply );

        ModbusRTU::mbErrCode forceMultipleCoils( ModbusRTU::ForceCoilsMessage& query,
                ModbusRTU::ForceCoilsRetMessage& reply );


        ModbusRTU::mbErrCode writeOutputRegisters( ModbusRTU::WriteOutputMessage& query,
                ModbusRTU::WriteOutputRetMessage& reply );

        ModbusRTU::mbErrCode writeOutputSingleRegister( ModbusRTU::WriteSingleOutputMessage& query,
                ModbusRTU::WriteSingleOutputRetMessage& reply );

        //        ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query,
        //                                                            ModbusRTU::JournalCommandRetMessage& reply );

        ModbusRTU::mbErrCode setDateTime( ModbusRTU::SetDateTimeMessage& query,
                                          ModbusRTU::SetDateTimeRetMessage& reply );

        ModbusRTU::mbErrCode remoteService( ModbusRTU::RemoteServiceMessage& query,
                                            ModbusRTU::RemoteServiceRetMessage& reply );

        ModbusRTU::mbErrCode fileTransfer( ModbusRTU::FileTransferMessage& query,
                                           ModbusRTU::FileTransferRetMessage& reply );

        ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query,
                                          ModbusRTU::DiagnosticRetMessage& reply );

        ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
                                       ModbusRTU::MEIMessageRetRDI& reply );

        virtual ModbusRTU::mbErrCode checkRegister( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData& val )
        {
            return ModbusRTU::erNoError;
        }

        // т.к. в функциях (much_real_read,nuch_real_write) рассчёт на отсортированность IOMap
        // то использовать unordered_map нельзя
        typedef std::map<ModbusRTU::RegID, IOProperty> RegMap;

        typedef std::unordered_map<ModbusRTU::ModbusAddr, RegMap> IOMap;

        IOMap iomap;  
        std::shared_ptr<ModbusServerSlot> mbslot;
        std::unordered_set<ModbusRTU::ModbusAddr> vaddr; 
        std::string default_mbaddr = { "" };

        xmlNode* cnode = { 0 };
        std::string s_field = { "" };
        std::string s_fvalue = { "" };
        int default_mbfunc = {0}; // функция по умолчанию, для вычисления RegID

        std::shared_ptr<SMInterface> shm;

        virtual void sysCommand( const UniSetTypes::SystemMessage* msg ) override;
        virtual void sensorInfo( const UniSetTypes::SensorMessage* sm ) override;
        void askSensors( UniversalIO::UIOCommand cmd );
        void waitSMReady();
        virtual void execute_rtu();
        virtual void execute_tcp();

        virtual bool activateObject() override;
        virtual bool deactivateObject() override;

        // действия при завершении работы
        virtual void sigterm( int signo ) override;
        virtual void finalThread();

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

        void readConfiguration();
        bool check_item( UniXML::iterator& it );

        ModbusRTU::mbErrCode real_write( RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData val, const int fn = 0 );
        ModbusRTU::mbErrCode real_write( RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData* dat, int& i, int count, const int fn = 0  );
        ModbusRTU::mbErrCode real_read( RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData& val, const int fn = 0  );
        ModbusRTU::mbErrCode much_real_read( RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData* dat, int count, const int fn = 0  );
        ModbusRTU::mbErrCode much_real_write( RegMap& rmap, const ModbusRTU::ModbusData regOKOK, ModbusRTU::ModbusData* dat, int count, const int fn = 0  );

        ModbusRTU::mbErrCode real_read_it( RegMap& rmap, RegMap::iterator& it, ModbusRTU::ModbusData& val );
        ModbusRTU::mbErrCode real_bitreg_read_it( std::shared_ptr<BitRegProperty>& bp, ModbusRTU::ModbusData& val );
        ModbusRTU::mbErrCode real_read_prop( IOProperty* p, ModbusRTU::ModbusData& val );

        ModbusRTU::mbErrCode real_write_it(RegMap& rmap, RegMap::iterator& it, ModbusRTU::ModbusData* dat, int& i, int count );
        ModbusRTU::mbErrCode real_bitreg_write_it( std::shared_ptr<BitRegProperty>& bp, const ModbusRTU::ModbusData val );
        ModbusRTU::mbErrCode real_write_prop( IOProperty* p, ModbusRTU::ModbusData* dat, int& i, int count );

        MBSlave();
        timeout_t initPause = { 3000 };
        UniSetTypes::uniset_rwmutex mutex_start;
        std::shared_ptr< ThreadCreator<MBSlave> > thr;

        std::mutex mutexStartNotify;
        std::condition_variable startNotifyEvent;

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

        IOController::IOStateList::iterator itAskCount;
        UniSetTypes::ObjectId askcount_id = { UniSetTypes::DefaultObjectId };

        IOController::IOStateList::iterator itRespond;
        UniSetTypes::ObjectId respond_id = { UniSetTypes::DefaultObjectId };
        bool respond_invert = { false };

        PassiveTimer ptTimeout;
        long askCount = { 0 };
        typedef std::unordered_map<ModbusRTU::mbErrCode, unsigned int> ExchangeErrorMap;
        ExchangeErrorMap errmap;     
        std::atomic_bool activated = { false };
        std::atomic_bool cancelled = { false };
        int activateTimeout = { 20000 }; // msec
        bool pingOK = { false };
        timeout_t wait_msec = { 3000 };
        bool force = { false };        
        bool mbregFromID = {0};
        bool checkMBFunc = {0};
        bool noMBFuncOptimize = {0}; // флаг отключающий принудительное преобразование функций (0x06->0x10, 0x05->0x0F) см. initItem()

        int getOptimizeWriteFunction( const int fn ); // функция возвращает оптимизированную функцию (если оптимизация включена)

        typedef std::unordered_map<int, std::string> FileList;
        FileList flist;
        std::string prefix = { "" };
        std::string prop_prefix = { "" };

        ModbusRTU::ModbusData buf[ModbusRTU::MAXLENPACKET / 2 + 1]; 
        // данные для ответа на запрос 0x2B(43)/0x0E(14)
        // 'MEI' - modbus encapsulated interface
        // 'RDI' - read device identification
        typedef std::unordered_map<int, std::string> MEIValMap;
        typedef std::unordered_map<int, MEIValMap> MEIObjIDMap;
        typedef std::unordered_map<int, MEIObjIDMap> MEIDevIDMap;

        MEIDevIDMap meidev;

        std::shared_ptr<LogAgregator> loga;
        std::shared_ptr<DebugStream> mblog;
        std::shared_ptr<LogServer> logserv;
        std::string logserv_host = {""};
        int logserv_port = {0};
        VMonitor vmon;
};
// -----------------------------------------------------------------------------
#endif // _MBSlave_H_
// -----------------------------------------------------------------------------