ModbusTypes.h

// -------------------------------------------------------------------------
#ifndef ModbusTypes_H_
#define ModbusTypes_H_
// -------------------------------------------------------------------------
#include <ostream>
#include <bitset>
#include <string>
#include <list>
#include "ModbusRTUErrors.h"
// -------------------------------------------------------------------------
/* Основные предположения:    
 * - младший и старший байт переворачиваются только в CRC
 * - В случае неправильного формата пакета(запроса), логической ошибки и т.п
 *         ОТВЕТ просто не посылается, а пакет отбрасывается...
 * - CRC считается по всей посылке (с начальным адресом)
 * - CRC инициализируется значением 0xffff
 * - CRC не переворачивается
 * - Все двухбайтовые слова переворачиваются. Порядок байт: старший младший
*/
// -------------------------------------------------------------------------
namespace ModbusRTU
{
    // Базовые типы 
    typedef unsigned char ModbusByte;    
    const int BitsPerByte = 8;
    typedef unsigned char ModbusAddr;    
    typedef unsigned short ModbusData;    
    const int BitsPerData = 16;
    typedef unsigned short ModbusCRC;    
    // ---------------------------------------------------------------------
    enum SlaveFunctionCode
    {
        fnUnknown                = 0x00,
        fnReadCoilStatus        = 0x01, 
        fnReadInputStatus        = 0x02, 
        fnReadOutputRegisters    = 0x03, 
        fnReadInputRegisters    = 0x04, 
        fnForceSingleCoil        = 0x05, 
        fnWriteOutputSingleRegister = 0x06,    
        fnDiagnostics            = 0x08, 
        fnForceMultipleCoils    = 0x0F,    
        fnWriteOutputRegisters    = 0x10,    
        fnReadFileRecord        = 0x14,    
        fnWriteFileRecord        = 0x15,    
        fnMEI                    = 0x2B, 
        fnSetDateTime            = 0x50, 
        fnRemoteService            = 0x53,    
        fnJournalCommand        = 0x65,    
        fnFileTransfer            = 0x66    
    };

    enum DiagnosticsSubFunction
    {
        subEcho = 0x00,         
        dgRestartComm = 0x01,     
        dgDiagReg = 0x02,         
        dgChangeASCII = 0x03,    
        dgForceListen = 0x04,    
        // 05.. 09 RESERVED
        dgClearCounters = 0x0A,     
        dgBusMsgCount = 0x0B,        
        dgBusErrCount = 0x0C,        
        dgBusExceptCount = 0x0D,    
        dgMsgSlaveCount = 0x0E,        
        dgNoNoResponseCount = 0x0F,    
        dgSlaveNAKCount = 0x10,        
        dgSlaveBusyCount = 0x11,        
        dgBusCharOverrunCount = 0x12,    
         // = 0x13,    /*!<  RESERVED */
        dgClearOverrunCounter = 0x14    
         // 21 ...65535 RESERVED
    };

    // определение размера данных в зависимости от типа сообщения
    // возвращает -1 - если динамический размер сообщения или размер неизвестен
    int szRequestDiagnosticData( DiagnosticsSubFunction f );

    enum RDIObjectID 
    {
        rdiVendorName = 0x0,
        rdiProductCode = 0x1,
        rdiMajorMinorRevision = 0x2,
        rdiVendorURL = 0x3,
        rdiProductName = 0x4,
        rdiModelName = 0x5,
        rdiUserApplicationName = 0x6
        // 0x07 .. 0x7F - reserved
        // 0x80 .. 0xFF - optionaly defined (product dependant)
    };

    enum RDIRequestDeviceID 
    {
        rdevMinNum = 0,
        rdevBasicDevice = 0x1,   // request to get the basic device identification (stream access)
        rdevRegularDevice = 0x2, // request to get the regular device identification (stream access)
        rdevExtentedDevice = 0x3, // request to get the extended device identification (stream access)
        rdevSpecificDevice = 0x4, // request to get the extended device identification (stream access)
        rdevMaxNum = 0x5
    };

    std::string rdi2str( int id );
    // -----------------------------------------------------------------------

    enum
    {
        MAXLENPACKET     = 508,    
        BroadcastAddr    = 255,    
        MAXDATALEN        = 127    
    };

    const unsigned char MBErrMask = 0x80;
    // ---------------------------------------------------------------------
    unsigned short SWAPSHORT(unsigned short x);
    // ---------------------------------------------------------------------
    ModbusCRC checkCRC( ModbusByte* start, int len );
    const int szCRC = sizeof(ModbusCRC); 
    // ---------------------------------------------------------------------
    std::ostream& mbPrintMessage( std::ostream& os, ModbusByte* b, int len );
    // -------------------------------------------------------------------------
    ModbusAddr str2mbAddr( const std::string& val );
    ModbusData str2mbData( const std::string& val );
    std::string dat2str( const ModbusData dat );
    std::string addr2str( const ModbusAddr addr );
    std::string b2str( const ModbusByte b );
    // -------------------------------------------------------------------------
    float dat2f( const ModbusData dat1, const ModbusData dat2 );
    // -------------------------------------------------------------------------
    bool isWriteFunction( SlaveFunctionCode c );
    // -------------------------------------------------------------------------
    struct ModbusHeader
    {
        ModbusAddr addr;        
        ModbusByte func;        
        ModbusHeader():addr(0),func(0){}
    }__attribute__((packed));

    const int szModbusHeader = sizeof(ModbusHeader);
    std::ostream& operator<<(std::ostream& os, ModbusHeader& m );
    std::ostream& operator<<(std::ostream& os, ModbusHeader* m );
    // -----------------------------------------------------------------------

    struct ModbusMessage:
        public ModbusHeader
    {
        ModbusMessage();
        ModbusByte data[MAXLENPACKET+szCRC];     
        // Это поле вспомогательное и игнорируется при пересылке
        int len;    
    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, ModbusMessage& m );
    std::ostream& operator<<(std::ostream& os, ModbusMessage* m );
    // -----------------------------------------------------------------------
    struct ErrorRetMessage:
        public ModbusHeader
    {
        ModbusByte ecode;
        ModbusCRC crc;

        // ------- from slave -------
        ErrorRetMessage( ModbusMessage& m );
        ErrorRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        // ------- to master -------
        ErrorRetMessage( ModbusAddr _from, ModbusByte _func, ModbusByte ecode );

        ModbusMessage transport_msg();

        inline static int szData(){ return sizeof(ModbusByte)+szCRC; }
    };

    std::ostream& operator<<(std::ostream& os, ErrorRetMessage& m ); 
    std::ostream& operator<<(std::ostream& os, ErrorRetMessage* m ); 
    // -----------------------------------------------------------------------
    struct DataBits
    {
        DataBits( ModbusByte b );
        DataBits( std::string s ); // example "10001111"
        DataBits();

        const DataBits& operator=(const ModbusByte& r);

        operator ModbusByte();
        ModbusByte mbyte();

        bool operator[]( const size_t i ){ return b[i]; }
        void set( int n, bool s ){ b.set(n,s); }

        std::bitset<BitsPerByte> b;
    };

    std::ostream& operator<<(std::ostream& os, DataBits& m );
    std::ostream& operator<<(std::ostream& os, DataBits* m ); 
    // -----------------------------------------------------------------------
    struct DataBits16
    {
        DataBits16( ModbusData d );
        DataBits16( const std::string& s ); // example "1000111110001111"
        DataBits16();

        const DataBits16& operator=(const ModbusData& r);

        operator ModbusData();
        ModbusData mdata();

        bool operator[]( const size_t i ){ return b[i]; }
        void set( int n, bool s ){ b.set(n,s); }

        std::bitset<BitsPerData> b;
    };

    std::ostream& operator<<(std::ostream& os, DataBits16& m );
    std::ostream& operator<<(std::ostream& os, DataBits16* m ); 
    // -----------------------------------------------------------------------
    struct ReadCoilMessage:
        public ModbusHeader
    {
        ModbusData start;
        ModbusData count;
        ModbusCRC crc;

        // ------- to slave -------
        ReadCoilMessage( ModbusAddr addr, ModbusData start, ModbusData count );
        ModbusMessage transport_msg();

        // ------- from master -------
        ReadCoilMessage( ModbusMessage& m );
        ReadCoilMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        inline static int szData(){ return sizeof(ModbusData)*2 + szCRC; }

    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, ReadCoilMessage& m ); 
    std::ostream& operator<<(std::ostream& os, ReadCoilMessage* m ); 

    // -----------------------------------------------------------------------

    struct ReadCoilRetMessage:
        public ModbusHeader
    {
        ModbusByte bcnt;                
        ModbusByte data[MAXLENPACKET];    
        // ------- from slave -------
        ReadCoilRetMessage( ModbusMessage& m );
        ReadCoilRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );
        static inline int szHead()
        {
            return sizeof(ModbusByte); // bcnt
        }

        static int getDataLen( ModbusMessage& m );
        ModbusCRC crc;

        // ------- to master -------
        ReadCoilRetMessage( ModbusAddr _from );

        bool addData( DataBits d );

        bool setBit( unsigned char dnum, unsigned char bnum, bool state );

        bool getData( unsigned char bnum, DataBits& d );

        void clear();

        inline bool isFull()
        {
            return ( (int)bcnt >= MAXLENPACKET );
        }

        size_t szData();

        ModbusMessage transport_msg();
    };

    std::ostream& operator<<(std::ostream& os, ReadCoilRetMessage& m );
    std::ostream& operator<<(std::ostream& os, ReadCoilRetMessage* m );
    // -----------------------------------------------------------------------
    struct ReadInputStatusMessage:
        public ModbusHeader
    {
        ModbusData start;
        ModbusData count;
        ModbusCRC crc;

        // ------- to slave -------
        ReadInputStatusMessage( ModbusAddr addr, ModbusData start, ModbusData count );
        ModbusMessage transport_msg();

        // ------- from master -------
        ReadInputStatusMessage( ModbusMessage& m );
        ReadInputStatusMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        inline static int szData(){ return sizeof(ModbusData)*2 + szCRC; }

    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, ReadInputStatusMessage& m ); 
    std::ostream& operator<<(std::ostream& os, ReadInputStatusMessage* m ); 
    // -----------------------------------------------------------------------
    struct ReadInputStatusRetMessage:
        public ModbusHeader
    {
        ModbusByte bcnt;                
        ModbusByte data[MAXLENPACKET];    
        // ------- from slave -------
        ReadInputStatusRetMessage( ModbusMessage& m );
        ReadInputStatusRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );
        static inline int szHead()
        {
            return sizeof(ModbusByte); // bcnt
        }

        static int getDataLen( ModbusMessage& m );
        ModbusCRC crc;

        // ------- to master -------
        ReadInputStatusRetMessage( ModbusAddr _from );

        bool addData( DataBits d );

        bool setBit( unsigned char dnum, unsigned char bnum, bool state );

        bool getData( unsigned char dnum, DataBits& d );

        void clear();

        inline bool isFull()
        {
            return ( (int)bcnt >= MAXLENPACKET );
        }

        size_t szData();

        ModbusMessage transport_msg();
    };

    std::ostream& operator<<(std::ostream& os, ReadInputStatusRetMessage& m );
    std::ostream& operator<<(std::ostream& os, ReadInputStatusRetMessage* m );
    // -----------------------------------------------------------------------

    struct ReadOutputMessage:
        public ModbusHeader
    {
        ModbusData start;
        ModbusData count;
        ModbusCRC crc;

        // ------- to slave -------
        ReadOutputMessage( ModbusAddr addr, ModbusData start, ModbusData count );
        ModbusMessage transport_msg();

        // ------- from master -------
        ReadOutputMessage( ModbusMessage& m );
        ReadOutputMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        inline static int szData(){ return sizeof(ModbusData)*2 + szCRC; }

    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, ReadOutputMessage& m ); 
    std::ostream& operator<<(std::ostream& os, ReadOutputMessage* m ); 
    // -----------------------------------------------------------------------
    struct ReadOutputRetMessage:
        public ModbusHeader
    {
        ModbusByte bcnt;                                    
        ModbusData data[MAXLENPACKET/sizeof(ModbusData)];    
        // ------- from slave -------
        ReadOutputRetMessage( ModbusMessage& m );
        ReadOutputRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );
        static inline int szHead()
        {
            // bcnt
            return sizeof(ModbusByte);
        }

        static int getDataLen( ModbusMessage& m );
        ModbusCRC crc;

        // ------- to master -------
        ReadOutputRetMessage( ModbusAddr _from );

        bool addData( ModbusData d );

        void clear();

        inline bool isFull()
        {
            return ( count*sizeof(ModbusData) >= MAXLENPACKET );
        }

        size_t szData();

        ModbusMessage transport_msg();

        // Это поле не входит в стандарт modbus
        // оно вспомогательное и игнорируется при 
        // преобразовании в ModbusMessage.
        // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно. 
        // Используйте специальную функцию transport_msg()
        int    count;    
    };

    std::ostream& operator<<(std::ostream& os, ReadOutputRetMessage& m );
    std::ostream& operator<<(std::ostream& os, ReadOutputRetMessage* m );
    // -----------------------------------------------------------------------
    struct ReadInputMessage:
        public ModbusHeader
    {
        ModbusData start;
        ModbusData count;
        ModbusCRC crc;

        // ------- to slave -------
        ReadInputMessage( ModbusAddr addr, ModbusData start, ModbusData count );
        ModbusMessage transport_msg();

        // ------- from master -------
        ReadInputMessage( ModbusMessage& m );
        ReadInputMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        inline static int szData(){ return sizeof(ModbusData)*2 + szCRC; }

    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, ReadInputMessage& m ); 
    std::ostream& operator<<(std::ostream& os, ReadInputMessage* m ); 
    // -----------------------------------------------------------------------

    struct ReadInputRetMessage:
        public ModbusHeader
    {
        ModbusByte bcnt;                                    
        ModbusData data[MAXLENPACKET/sizeof(ModbusData)];    
        // ------- from slave -------
        ReadInputRetMessage( ModbusMessage& m );
        ReadInputRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );
        static inline int szHead()
        {
            // bcnt
            return sizeof(ModbusByte);
        }

        static int getDataLen( ModbusMessage& m );
        ModbusCRC crc;

        // ------- to master -------
        ReadInputRetMessage( ModbusAddr _from );

        bool addData( ModbusData d );

        void clear();

        inline bool isFull()
        {
            return ( count*sizeof(ModbusData) >= MAXLENPACKET );
        }

        void swapData();

        size_t szData();

        ModbusMessage transport_msg();

        // Это поле не входит в стандарт modbus
        // оно вспомогательное и игнорируется при 
        // преобразовании в ModbusMessage.
        // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно. 
        // Используйте специальную функцию transport_msg()
        int    count;    
    };

    std::ostream& operator<<(std::ostream& os, ReadInputRetMessage& m );
    std::ostream& operator<<(std::ostream& os, ReadInputRetMessage* m );
    // -----------------------------------------------------------------------
    struct ForceCoilsMessage:
        public ModbusHeader
    {
        ModbusData start;    
        ModbusData quant;    
        ModbusByte bcnt;    
        ModbusByte data[MAXLENPACKET-sizeof(ModbusData)*2-sizeof(ModbusByte)];
        ModbusCRC crc;        
        // ------- to slave -------
        ForceCoilsMessage( ModbusAddr addr, ModbusData start );
        ModbusMessage transport_msg();

        bool addData( DataBits d );

        // return number of bit
        // -1 - error
        int addBit( bool state );

        bool setBit( int nbit, bool state );

        inline int last(){ return quant; }

        bool getData( unsigned char dnum, DataBits& d );

        bool getBit( unsigned char bnum );

        void clear();
        inline bool isFull()
        {
            return ( (int)bcnt >= MAXLENPACKET );
        }

        // ------- from master -------    
        ForceCoilsMessage( ModbusMessage& m );
        ForceCoilsMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        size_t szData();

        static inline int szHead()
        {
            // start + quant + count
            return sizeof(ModbusData)*2+sizeof(ModbusByte);
        }
        
        static int getDataLen( ModbusMessage& m );

        bool checkFormat();
        
    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, ForceCoilsMessage& m );
    std::ostream& operator<<(std::ostream& os, ForceCoilsMessage* m );
    // -----------------------------------------------------------------------
    struct ForceCoilsRetMessage:
        public ModbusHeader
    {
        ModbusData start;     
        ModbusData quant;    
        ModbusCRC crc;

        // ------- from slave -------
        ForceCoilsRetMessage( ModbusMessage& m );
        ForceCoilsRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );
        
        // ------- to master -------
        ForceCoilsRetMessage( ModbusAddr _from, ModbusData start=0, ModbusData quant=0 );

        void set( ModbusData start, ModbusData quant );

        ModbusMessage transport_msg();
        
        inline static int szData(){ return sizeof(ModbusData)*2+sizeof(ModbusCRC); }
    };
    
    std::ostream& operator<<(std::ostream& os, ForceCoilsRetMessage& m );
    std::ostream& operator<<(std::ostream& os, ForceCoilsRetMessage* m );
    // -----------------------------------------------------------------------

    struct WriteOutputMessage:
        public ModbusHeader
    {
        ModbusData start;    
        ModbusData quant;    
        ModbusByte bcnt;    
        ModbusData data[MAXLENPACKET/sizeof(ModbusData)-sizeof(ModbusData)*2-sizeof(ModbusByte)];
        ModbusCRC crc;        
        // ------- to slave -------
        WriteOutputMessage( ModbusAddr addr, ModbusData start );
        ModbusMessage transport_msg();

        bool addData( ModbusData d );
        void clear();
        inline bool isFull()
        {
            return ( quant >= MAXDATALEN );
        }

        // ------- from master -------    
        WriteOutputMessage( ModbusMessage& m );
        WriteOutputMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        size_t szData();

        static inline int szHead()
        {
            // start + quant + count
            return sizeof(ModbusData)*2+sizeof(ModbusByte);
        }
        
        static int getDataLen( ModbusMessage& m );

        bool checkFormat();
        
    }__attribute__((packed));


    std::ostream& operator<<(std::ostream& os, WriteOutputMessage& m );
    std::ostream& operator<<(std::ostream& os, WriteOutputMessage* m );

    struct WriteOutputRetMessage:
        public ModbusHeader
    {
        ModbusData start;     
        ModbusData quant;    
        // ------- from slave -------
        WriteOutputRetMessage( ModbusMessage& m );
        WriteOutputRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );
        ModbusCRC crc;

        // ------- to master -------
        WriteOutputRetMessage( ModbusAddr _from, ModbusData start=0, ModbusData quant=0 );

        void set( ModbusData start, ModbusData quant );

        ModbusMessage transport_msg();
        
        inline static int szData(){ return sizeof(ModbusData)*2+sizeof(ModbusCRC); }
    };
    
    std::ostream& operator<<(std::ostream& os, WriteOutputRetMessage& m );
    std::ostream& operator<<(std::ostream& os, WriteOutputRetMessage* m );
    // -----------------------------------------------------------------------
    struct ForceSingleCoilMessage:
        public ModbusHeader
    {
        ModbusData start;    
        ModbusData data;    
        ModbusCRC crc;        
        inline bool cmd()
        {
            return (data & 0xFF00);
        }


        // ------- to slave -------
        ForceSingleCoilMessage( ModbusAddr addr, ModbusData reg, bool state );
        ModbusMessage transport_msg();
    
        // ------- from master -------
        ForceSingleCoilMessage( ModbusMessage& m );
        ForceSingleCoilMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        size_t szData();

        static inline int szHead()
        {
            return sizeof(ModbusData);
        }
        
        static int getDataLen( ModbusMessage& m );

        bool checkFormat();
    }__attribute__((packed));


    std::ostream& operator<<(std::ostream& os, ForceSingleCoilMessage& m );
    std::ostream& operator<<(std::ostream& os, ForceSingleCoilMessage* m );
    // -----------------------------------------------------------------------

    struct ForceSingleCoilRetMessage:
        public ModbusHeader
    {
        ModbusData start;     
        ModbusData data;     
        ModbusCRC crc;

        inline bool cmd()
        {
            return (data & 0xFF00);
        }

        // ------- from slave -------
        ForceSingleCoilRetMessage( ModbusMessage& m );
        ForceSingleCoilRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        // ------- to master -------
        ForceSingleCoilRetMessage( ModbusAddr _from );

        void set( ModbusData start, bool cmd );

        ModbusMessage transport_msg();
        
        inline static int szData(){ return 2*sizeof(ModbusData)+sizeof(ModbusCRC); }
    };
    
    std::ostream& operator<<(std::ostream& os, ForceSingleCoilRetMessage& m );
    std::ostream& operator<<(std::ostream& os, ForceSingleCoilRetMessage* m );
    // -----------------------------------------------------------------------

    struct WriteSingleOutputMessage:
        public ModbusHeader
    {
        ModbusData start;    
        ModbusData data;    
        ModbusCRC crc;        
        // ------- to slave -------
        WriteSingleOutputMessage( ModbusAddr addr, ModbusData reg=0, ModbusData data=0 );
        ModbusMessage transport_msg();
    
        // ------- from master -------
        WriteSingleOutputMessage( ModbusMessage& m );
        WriteSingleOutputMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        size_t szData();

        static inline int szHead()
        {
            return sizeof(ModbusData);
        }
        
        static int getDataLen( ModbusMessage& m );

        bool checkFormat();
    }__attribute__((packed));


    std::ostream& operator<<(std::ostream& os, WriteSingleOutputMessage& m );
    std::ostream& operator<<(std::ostream& os, WriteSingleOutputMessage* m );
    // -----------------------------------------------------------------------

    struct WriteSingleOutputRetMessage:
        public ModbusHeader
    {
        ModbusData start;     
        ModbusData data;     
        ModbusCRC crc;


        // ------- from slave -------
        WriteSingleOutputRetMessage( ModbusMessage& m );
        WriteSingleOutputRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        // ------- to master -------
        WriteSingleOutputRetMessage( ModbusAddr _from, ModbusData start=0 );

        void set( ModbusData start, ModbusData data );

        ModbusMessage transport_msg();
        
        inline static int szData(){ return 2*sizeof(ModbusData)+sizeof(ModbusCRC); }
    };
    
    std::ostream& operator<<(std::ostream& os, WriteSingleOutputRetMessage& m );
    std::ostream& operator<<(std::ostream& os, WriteSingleOutputRetMessage* m );
    // -----------------------------------------------------------------------
    struct DiagnosticMessage:
        public ModbusHeader
    {
        ModbusData subf;
        ModbusData data[MAXLENPACKET/sizeof(ModbusData)];    
        // ------- from slave -------
        DiagnosticMessage( ModbusMessage& m );
        DiagnosticMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );
        static inline int szHead()
        {
            return sizeof(ModbusData); // subf
        }

        static int getDataLen( ModbusMessage& m );
        ModbusCRC crc;
        
        // ------- to master -------
        DiagnosticMessage( ModbusAddr _from, DiagnosticsSubFunction subf, ModbusData d=0 );

        bool addData( ModbusData d );

        void clear();
        
        inline bool isFull()
        {
            // (1)subf + data count 
            return ( 1+count >= MAXDATALEN );
        }

        size_t szData();

        ModbusMessage transport_msg();

        // Это поле не входит в стандарт modbus
        // оно вспомогательное и игнорируется при 
        // преобразовании в ModbusMessage.
        // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно. 
        // Используйте специальную функцию transport_msg()
        int    count;    
    };
    std::ostream& operator<<(std::ostream& os, DiagnosticMessage& m );
    std::ostream& operator<<(std::ostream& os, DiagnosticMessage* m );
    // -----------------------------------------------------------------------
    struct DiagnosticRetMessage:
        public DiagnosticMessage
    {
        DiagnosticRetMessage( ModbusMessage& m );
        DiagnosticRetMessage( DiagnosticMessage& m );
        DiagnosticRetMessage( ModbusAddr a, DiagnosticsSubFunction subf, ModbusData d=0 );
    };

    std::ostream& operator<<(std::ostream& os, DiagnosticRetMessage& m );
    std::ostream& operator<<(std::ostream& os, DiagnosticRetMessage* m );
    // -----------------------------------------------------------------------
    struct MEIMessageRDI:
        public ModbusHeader
    {
        ModbusByte type;     
        ModbusByte devID;     
        ModbusByte objID;     
        ModbusCRC crc;        
        // ------- to slave -------
        MEIMessageRDI( ModbusAddr addr, ModbusByte devID, ModbusByte objID );
        ModbusMessage transport_msg();

        // ------- from master -------    
        MEIMessageRDI( ModbusMessage& m );
        MEIMessageRDI& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        static inline int szHead(){ return sizeof(ModbusByte)*3; }

        static inline int szData(){ return sizeof(ModbusByte)*3 + szCRC; }

        // вспомогательные функции
        bool checkFormat();

    }__attribute__((packed));
    // -----------------------------------------------------------------------
    std::ostream& operator<<(std::ostream& os, MEIMessageRDI& m );
    std::ostream& operator<<(std::ostream& os, MEIMessageRDI* m );
    // -----------------------------------------------------------------------

    struct RDIObjectInfo
    {
        RDIObjectInfo():id(0),val(""){}
        RDIObjectInfo( ModbusByte id, const std::string& v ):id(id),val(v){}
        RDIObjectInfo( ModbusByte id, ModbusByte* dat, ModbusByte len );

        ModbusByte id;
        std::string val;
    };

    typedef std::list<RDIObjectInfo> RDIObjectList;

    struct MEIMessageRetRDI:
        public ModbusHeader
    {
        ModbusByte type;     
        ModbusByte devID;     
        ModbusByte conformity; 
        ModbusByte mf;         
        ModbusByte objID;     
        ModbusByte objNum;     
        RDIObjectList dlist;
        ModbusCRC crc;

        // ------- from slave -------
        MEIMessageRetRDI();
        MEIMessageRetRDI( ModbusMessage& m );
        MEIMessageRetRDI& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        // предварительная инициализации, только заголовочной части, без данных
        void pre_init( ModbusMessage& m );

        static inline int szHead()
        {
            return sizeof(ModbusByte)*6;
        }

//        /*! узнать длину данных следующих за предварительным заголовком ( в байтах ) */
//        static int getDataLen( ModbusMessage& m );
        
        // ------- to master -------
        MEIMessageRetRDI( ModbusAddr _from, ModbusByte devID, ModbusByte conformity, ModbusByte mf, ModbusByte objID );

        bool addData( ModbusByte id, const std::string& value );
        bool addData( RDIObjectInfo& dat );

        void clear();
        
        inline bool isFull()
        {
            return ( bcnt >= MAXLENPACKET );
        }
        
        size_t szData();
        
        ModbusMessage transport_msg();

        int bcnt; 
    };

    std::ostream& operator<<(std::ostream& os, MEIMessageRetRDI& m );
    std::ostream& operator<<(std::ostream& os, MEIMessageRetRDI* m );
    std::ostream& operator<<(std::ostream& os, RDIObjectList& dl );
    std::ostream& operator<<(std::ostream& os, RDIObjectList* dl );
    // -----------------------------------------------------------------------
    // -----------------------------------------------------------------------

    struct JournalCommandMessage:
        public ModbusHeader
    {
        ModbusData cmd;            
        ModbusData num;            
        ModbusCRC crc;
        
        // -------------
        JournalCommandMessage( ModbusMessage& m );
        JournalCommandMessage& operator=( ModbusMessage& m );

        inline static int szData(){ return sizeof(ModbusByte)*4 + szCRC; }

    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, JournalCommandMessage& m ); 
    std::ostream& operator<<(std::ostream& os, JournalCommandMessage* m ); 
    // -----------------------------------------------------------------------
    struct JournalCommandRetMessage:
        public ModbusHeader
    {
        ModbusByte bcnt;                    
//        ModbusByte data[MAXLENPACKET-1];    /*!< данные */

        // В связи со спецификой реализации ответной части (т.е. modbus master)
        // данные приходится делать не байтовым потоком, а "словами"
        // которые в свою очередь будут перевёрнуты при посылке...
        ModbusData data[MAXLENPACKET/sizeof(ModbusData)];    
        // -------------
        JournalCommandRetMessage( ModbusAddr _from );

        bool setData( ModbusByte* b, int len );

        void clear();

        inline bool isFull()
        {
            return ( count >= MAXDATALEN );
        }

        size_t szData();
        
        ModbusMessage transport_msg();
        
        // Это поле не входит в стандарт modbus
        // оно вспомогательное и игнорируется при 
        // преобразовании в ModbusMessage.
        // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно. 
        // Используйте специальную функцию transport_msg()
        int    count;    
    };

    std::ostream& operator<<(std::ostream& os, JournalCommandRetMessage& m );
    std::ostream& operator<<(std::ostream& os, JournalCommandRetMessage* m );
    // -----------------------------------------------------------------------
    struct JournalCommandRetOK:
        public JournalCommandRetMessage
    {
        // -------------
        JournalCommandRetOK( ModbusAddr _from );
        void set( ModbusData cmd, ModbusData ecode );
        static void set( JournalCommandRetMessage& m, ModbusData cmd, ModbusData ecode );
    };

    std::ostream& operator<<(std::ostream& os, JournalCommandRetOK& m ); 
    std::ostream& operator<<(std::ostream& os, JournalCommandRetOK* m ); 
    // -----------------------------------------------------------------------

    struct SetDateTimeMessage:
        public ModbusHeader
    {
        ModbusByte hour;    
        ModbusByte min;        
        ModbusByte sec;        
        ModbusByte day;        
        ModbusByte mon;        
        ModbusByte year;    
        ModbusByte century;    
        ModbusCRC crc;
        
        // ------- to slave -------
        SetDateTimeMessage( ModbusAddr addr );
        ModbusMessage transport_msg();
        
        // ------- from master -------
        SetDateTimeMessage( ModbusMessage& m );
        SetDateTimeMessage& operator=( ModbusMessage& m );
        SetDateTimeMessage();

        bool checkFormat();

        inline static int szData(){ return sizeof(ModbusByte)*7 + szCRC; }

    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, SetDateTimeMessage& m ); 
    std::ostream& operator<<(std::ostream& os, SetDateTimeMessage* m ); 
    // -----------------------------------------------------------------------

    struct SetDateTimeRetMessage:
        public SetDateTimeMessage
    {

        // ------- from slave -------
        SetDateTimeRetMessage( ModbusMessage& m );
        SetDateTimeRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        // ------- to master -------
        SetDateTimeRetMessage( ModbusAddr _from );
        SetDateTimeRetMessage( const SetDateTimeMessage& query );
        static void cpy( SetDateTimeRetMessage& reply, SetDateTimeMessage& query );

        ModbusMessage transport_msg();
    };
    // -----------------------------------------------------------------------

    struct RemoteServiceMessage:
        public ModbusHeader
    {
        ModbusByte bcnt;    
        ModbusByte data[MAXLENPACKET-sizeof(ModbusByte)];
        ModbusCRC crc;        
        // -----------
        RemoteServiceMessage( ModbusMessage& m );
        RemoteServiceMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        size_t szData();

        static inline int szHead()
        { return sizeof(ModbusByte); } // bcnt
        
        static int getDataLen( ModbusMessage& m );

    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, RemoteServiceMessage& m ); 
    std::ostream& operator<<(std::ostream& os, RemoteServiceMessage* m ); 
    // -----------------------------------------------------------------------
    struct RemoteServiceRetMessage:
        public ModbusHeader
    {
        ModbusByte bcnt;    
        ModbusByte data[MAXLENPACKET-sizeof(ModbusByte)];

        RemoteServiceRetMessage( ModbusAddr _from );

        bool setData( ModbusByte* b, int len );

        void clear();
        
        inline bool isFull()
            { return ( count >= sizeof(data) ); }

        size_t szData();
        
        ModbusMessage transport_msg();
        
        // Это поле не входит в стандарт modbus
        // оно вспомогательное и игнорируется при 
        // преобразовании в ModbusMessage.
        unsigned int    count;    
    };
    // -----------------------------------------------------------------------

    struct ReadFileRecordMessage:
        public ModbusHeader
    {
        struct SubRequest
        {
            ModbusByte reftype; 
            ModbusData numfile; 
            ModbusData numrec;  
            ModbusData reglen;  
        }__attribute__((packed));    

        ModbusByte bcnt;    
        SubRequest data[MAXLENPACKET/sizeof(SubRequest)-sizeof(ModbusByte)];
        ModbusCRC crc;        
        // -----------
        ReadFileRecordMessage( ModbusMessage& m );
        ReadFileRecordMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        size_t szData();

        static inline int szHead()
        { return sizeof(ModbusByte); } // bcnt
        
        static int getDataLen( ModbusMessage& m );

        bool checkFormat();
        
        // это поле служебное и не используется в релальном обмене
        int count; 
    };

    std::ostream& operator<<(std::ostream& os, ReadFileRecordMessage& m ); 
    std::ostream& operator<<(std::ostream& os, ReadFileRecordMessage* m ); 
    // -----------------------------------------------------------------------

    struct FileTransferMessage:
        public ModbusHeader
    {
        ModbusData numfile;     
        ModbusData numpacket;      
        ModbusCRC crc;            
        // ------- to slave -------
        FileTransferMessage( ModbusAddr addr, ModbusData numfile, ModbusData numpacket );
        ModbusMessage transport_msg();     
        // ------- from master -------
        FileTransferMessage( ModbusMessage& m );
        FileTransferMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );

        static inline int szData()
        {    return sizeof(ModbusData)*2 + szCRC; }

    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, FileTransferMessage& m ); 
    std::ostream& operator<<(std::ostream& os, FileTransferMessage* m ); 
    // -----------------------------------------------------------------------

    struct FileTransferRetMessage:
        public ModbusHeader
    {
        // 255 - max of bcnt...(1 byte)        
//        static const int MaxDataLen = 255 - szCRC - szModbusHeader - sizeof(ModbusData)*3 - sizeof(ModbusByte)*2;
        static const int MaxDataLen = MAXLENPACKET - sizeof(ModbusData)*3 - sizeof(ModbusByte)*2;

        ModbusByte bcnt;        
        ModbusData numfile;     
        ModbusData numpacks;     
        ModbusData packet;      
        ModbusByte dlen;        
        ModbusByte data[MaxDataLen];

    
        // ------- from slave -------
        FileTransferRetMessage( ModbusMessage& m );
        FileTransferRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );
        ModbusCRC crc;
        static int szHead(){ return sizeof(ModbusByte); }
        static int getDataLen( ModbusMessage& m );
        
        // ------- to master -------
        FileTransferRetMessage( ModbusAddr _from );

        bool set( ModbusData numfile, ModbusData file_num_packets, ModbusData packet, ModbusByte* b, ModbusByte len );

        void clear();
        
        size_t szData();
        
        ModbusMessage transport_msg();
    };

    std::ostream& operator<<(std::ostream& os, FileTransferRetMessage& m ); 
    std::ostream& operator<<(std::ostream& os, FileTransferRetMessage* m );
    // -----------------------------------------------------------------------
} // end of ModbusRTU namespace
// ---------------------------------------------------------------------------
namespace ModbusTCP
{
    struct MBAPHeader
    {
        ModbusRTU::ModbusData    tID; 
        ModbusRTU::ModbusData    pID; 
        ModbusRTU::ModbusData    len; 
/*        ModbusRTU::ModbusByte    uID; */  /* <------- see ModbusHeader */

        MBAPHeader():tID(0),pID(0) /*,uID(0) */{}
        
        void swapdata();

    }__attribute__((packed));

    std::ostream& operator<<(std::ostream& os, MBAPHeader& m ); 

  // -----------------------------------------------------------------------
} // end of namespace ModbusTCP
// ---------------------------------------------------------------------------
#endif // ModbusTypes_H_
// ---------------------------------------------------------------------------