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<>
class hash<uniset::ModbusRTU::mbErrCode>
{
    public:
        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 );

        inline void setSleepPause( timeout_t msec )
        {
            sleepPause_msec = msec;
        }

        inline void setCRCNoCheckit( bool set )
        {
            crcNoCheckit = set;
        }
        inline bool isCRCNoCheckit() const
        {
            return crcNoCheckit;
        }

        inline void setBroadcastMode( bool set )
        {
            onBroadcast = set;
        }
        inline bool getBroadcastMode() const
        {
            return onBroadcast;
        }

        inline void setCleanBeforeSend( bool set )
        {
            cleanBeforeSend = set;
        }
        inline bool getCleanBeforeSend()
        {
            return cleanBeforeSend;
        }

        static ModbusRTU::mbErrCode replySetDateTime( ModbusRTU::SetDateTimeMessage& query,
                                                      ModbusRTU::SetDateTimeRetMessage& reply,
                                                      std::shared_ptr<DebugStream> dlog = nullptr );


        static ModbusRTU::mbErrCode replyFileTransfer( const std::string& fname,
                                                       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 );
        size_t resetErrCount( ModbusRTU::mbErrCode e, size_t set = 0 );

        inline size_t getAskCount() const
        {
            return askCount;
        }
        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( ModbusRTU::ReadCoilMessage& query,
                                                     ModbusRTU::ReadCoilRetMessage& reply ) = 0;
        virtual ModbusRTU::mbErrCode readInputStatus( ModbusRTU::ReadInputStatusMessage& query,
                                                      ModbusRTU::ReadInputStatusRetMessage& reply ) = 0;

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

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

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


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

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

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


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

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


        virtual ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query,
                                                     ModbusRTU::JournalCommandRetMessage& reply ) = 0;


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


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


        virtual ModbusRTU::mbErrCode fileTransfer( 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 onBroadcast = { false };        
        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_
// -------------------------------------------------------------------------