ModbusServer.h

// -------------------------------------------------------------------------
#ifndef ModbusServer_H_
#define ModbusServer_H_
// -------------------------------------------------------------------------
#include <string>
#include <unordered_set>
#include <unordered_map>
#include <sigc++/sigc++.h>
 
#include "Debug.h"
#include "Mutex.h"
#include "Configuration.h"
#include "PassiveTimer.h"
#include "ModbusTypes.h"
// -------------------------------------------------------------------------
namespace std
{
    template<>
    struct hash<uniset::ModbusRTU::mbErrCode>
    {
        size_t operator()(const uniset::ModbusRTU::mbErrCode& e) const
        {
            return std::hash<size_t>()(e);
        }
    };
}
// -------------------------------------------------------------------------
namespace uniset
{
    // -------------------------------------------------------------------------
    class ModbusServer
    {
        public:
            ModbusServer();
            virtual ~ModbusServer();
 
            void initLog( uniset::Configuration* conf, const std::string& name, const std::string& logfile = "" );
            void setLog( std::shared_ptr<DebugStream> dlog );
            inline std::shared_ptr<DebugStream> log()
            {
                return dlog;
            }
 
            static std::unordered_set<ModbusRTU::ModbusAddr> addr2vaddr( ModbusRTU::ModbusAddr& mbaddr );
 
            ModbusRTU::mbErrCode receive( const std::unordered_set<ModbusRTU::ModbusAddr>& vaddr, timeout_t msecTimeout );
 
            // версия с "одним" адресом
            virtual ModbusRTU::mbErrCode receive_one( const ModbusRTU::ModbusAddr addr, timeout_t msec );
 
 
            // ---------------------------------------------------------------------------------------
            // сигналы по обработке событий приёма сообщения.
            // ---------------------------------------------------------------------------------------
            // сигнал вызова receive, ДО обработки realReceive()
            // \return ModbusRTU::errNoError, тогда обработка продолжиться.
            typedef sigc::signal<ModbusRTU::mbErrCode, const std::unordered_set<ModbusRTU::ModbusAddr>, timeout_t> PreReceiveSignal;
            PreReceiveSignal signal_pre_receive();
 
            // сигнал после обработки realReceive()
            typedef sigc::signal<void, ModbusRTU::mbErrCode> PostReceiveSignal;
            PostReceiveSignal signal_post_receive();
            // ---------------------------------------------------------------------------------------
 
            static bool checkAddr( const std::unordered_set<ModbusRTU::ModbusAddr>& vaddr, const ModbusRTU::ModbusAddr addr );
            static std::string vaddr2str( const std::unordered_set<ModbusRTU::ModbusAddr>& vaddr );
 
            timeout_t setAfterSendPause( timeout_t msec );
 
            timeout_t setReplyTimeout( timeout_t msec );
 
            void setRecvTimeout( timeout_t msec );
 
            void setSleepPause( timeout_t msec );
 
            void setCRCNoCheckit( bool set );
            bool isCRCNoCheckit() const;
 
            void setCleanBeforeSend( bool set );
            bool getCleanBeforeSend() const;
 
            static ModbusRTU::mbErrCode replySetDateTime( const ModbusRTU::SetDateTimeMessage& query,
                    ModbusRTU::SetDateTimeRetMessage& reply,
                    std::shared_ptr<DebugStream> dlog = nullptr );
 
            static ModbusRTU::mbErrCode replyFileTransfer( const std::string& fname,
                    const ModbusRTU::FileTransferMessage& query,
                    ModbusRTU::FileTransferRetMessage& reply,
                    std::shared_ptr<DebugStream> dlog = nullptr );
 
            virtual void cleanupChannel() {}
            virtual void terminate() {}
 
            virtual bool isActive() const = 0;
 
            // ------------ Статистика ---------------
            typedef std::unordered_map<ModbusRTU::mbErrCode, size_t> ExchangeErrorMap;
 
            ExchangeErrorMap getErrorMap();
            size_t getErrCount( ModbusRTU::mbErrCode e ) const;
            size_t resetErrCount( ModbusRTU::mbErrCode e, size_t set = 0 );
 
            size_t getAskCount() const noexcept;
            void resetAskCounter();
 
        protected:
 
            virtual void iowait( timeout_t usec );
 
            virtual ModbusRTU::mbErrCode realReceive( const std::unordered_set<ModbusRTU::ModbusAddr>& vaddr, timeout_t msecTimeout ) = 0;
 
            virtual ModbusRTU::mbErrCode readCoilStatus( const ModbusRTU::ReadCoilMessage& query,
                    ModbusRTU::ReadCoilRetMessage& reply ) = 0;
            virtual ModbusRTU::mbErrCode readInputStatus( const ModbusRTU::ReadInputStatusMessage& query,
                    ModbusRTU::ReadInputStatusRetMessage& reply ) = 0;
 
            virtual ModbusRTU::mbErrCode readOutputRegisters( const ModbusRTU::ReadOutputMessage& query,
                    ModbusRTU::ReadOutputRetMessage& reply ) = 0;
 
            virtual ModbusRTU::mbErrCode readInputRegisters( const ModbusRTU::ReadInputMessage& query,
                    ModbusRTU::ReadInputRetMessage& reply ) = 0;
 
            virtual ModbusRTU::mbErrCode forceSingleCoil( const ModbusRTU::ForceSingleCoilMessage& query,
                    ModbusRTU::ForceSingleCoilRetMessage& reply ) = 0;
 
 
            virtual ModbusRTU::mbErrCode writeOutputSingleRegister( const ModbusRTU::WriteSingleOutputMessage& query,
                    ModbusRTU::WriteSingleOutputRetMessage& reply ) = 0;
 
            virtual ModbusRTU::mbErrCode forceMultipleCoils( const ModbusRTU::ForceCoilsMessage& query,
                    ModbusRTU::ForceCoilsRetMessage& reply ) = 0;
 
            virtual ModbusRTU::mbErrCode writeOutputRegisters( const ModbusRTU::WriteOutputMessage& query,
                    ModbusRTU::WriteOutputRetMessage& reply ) = 0;
 
 
            virtual ModbusRTU::mbErrCode diagnostics( const ModbusRTU::DiagnosticMessage& query,
                    ModbusRTU::DiagnosticRetMessage& reply ) = 0;
 
            virtual ModbusRTU::mbErrCode read4314( const ModbusRTU::MEIMessageRDI& query,
                                                   ModbusRTU::MEIMessageRetRDI& reply ) = 0;
 
 
            virtual ModbusRTU::mbErrCode journalCommand( const ModbusRTU::JournalCommandMessage& query,
                    ModbusRTU::JournalCommandRetMessage& reply ) = 0;
 
 
            virtual ModbusRTU::mbErrCode setDateTime( const ModbusRTU::SetDateTimeMessage& query,
                    ModbusRTU::SetDateTimeRetMessage& reply ) = 0;
 
 
            virtual ModbusRTU::mbErrCode remoteService( const ModbusRTU::RemoteServiceMessage& query,
                    ModbusRTU::RemoteServiceRetMessage& reply ) = 0;
 
 
            virtual ModbusRTU::mbErrCode fileTransfer( const ModbusRTU::FileTransferMessage& query,
                    ModbusRTU::FileTransferRetMessage& reply ) = 0;
 
            virtual size_t getNextData( unsigned char* buf, int len ) = 0;
 
            virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len ) = 0;
 
            virtual void setChannelTimeout( timeout_t msec ) = 0;
 
            virtual ModbusRTU::mbErrCode send( ModbusRTU::ModbusMessage& buf );
 
            // Если заголовок не должен использоваться оставляйте request.header.len = 0
            virtual ModbusRTU::mbErrCode make_adu_header( ModbusRTU::ModbusMessage& request )
            {
                return ModbusRTU::erNoError;
            }
            virtual ModbusRTU::mbErrCode post_send_request( ModbusRTU::ModbusMessage& request )
            {
                return ModbusRTU::erNoError;
            }
 
            // default processing
            virtual ModbusRTU::mbErrCode processing( ModbusRTU::ModbusMessage& buf );
 
            ModbusRTU::mbErrCode recv(const std::unordered_set<ModbusRTU::ModbusAddr>& vaddr, ModbusRTU::ModbusMessage& buf, timeout_t timeout );
            ModbusRTU::mbErrCode recv_pdu( ModbusRTU::ModbusMessage& rbuf, timeout_t timeout );
 
            std::timed_mutex recvMutex;
            timeout_t recvTimeOut_ms = { 50 };        
            timeout_t replyTimeout_ms = { 2000 };    
            timeout_t aftersend_msec = { 0 };        
            timeout_t sleepPause_msec = { 10 };     
            bool crcNoCheckit = { false };
            bool cleanBeforeSend = { false };
 
            void printProcessingTime();
            PassiveTimer tmProcessing;
 
            std::shared_ptr<DebugStream> dlog;
 
            // статистика сервера
            size_t askCount = { 0 };
            ExchangeErrorMap errmap;     
            PreReceiveSignal m_pre_signal;
            PostReceiveSignal m_post_signal;
 
        private:
 
    };
    // -------------------------------------------------------------------------
} // end of namespace uniset
// -------------------------------------------------------------------------
#endif // ModbusServer_H_
// -------------------------------------------------------------------------