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 unsigned short BitsPerByte = 8;
    typedef unsigned char ModbusAddr;    
    typedef unsigned short ModbusData;    
    const unsigned short 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
    };


    typedef unsigned long RegID;

    RegID genRegID( const ModbusRTU::ModbusData r, const int fn );

    // определение размера данных в зависимости от типа сообщения
    // возвращает -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, 
        MAXPDULEN       = 253, // 255 - 2(CRC)
        MAXDATALEN       = 125  
    };

    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];   
        // Это поле вспомогательное и игнорируется при пересылке
        size_t 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 = { erNoError };
        ModbusCRC crc = { 0 };

        // ------- 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 = { 0 };
        ModbusData count = { 0 };
        ModbusCRC crc = { 0 };

        // ------- 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 = { 0 };          
        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 = { 0 };

        // ------- 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 >= MAXPDULEN );
        }

        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 = { 0 };
        ModbusData count = { 0 };
        ModbusCRC crc = { 0 };

        // ------- 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 = { 0 };          
        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 = { 0 };

        // ------- 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 >= MAXPDULEN );
        }

        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 = { 0 };
        ModbusData count = { 0 };
        ModbusCRC crc = { 0 };

        // ------- 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 = { 0 };                             
        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 = { 0 };

        // ------- 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()
        size_t count = { 0 };    
    };

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

        // ------- 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 = { 0 };                                    
        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 = { 0 };

        // ------- 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()
        size_t count = { 0 };    
    };

    std::ostream& operator<<(std::ostream& os, ReadInputRetMessage& m );
    std::ostream& operator<<(std::ostream& os, ReadInputRetMessage* m );
    // -----------------------------------------------------------------------
    struct ForceCoilsMessage:
        public ModbusHeader
    {
        ModbusData start = { 0 };    
        ModbusData quant = { 0 };    
        ModbusByte bcnt = { 0 };    
        ModbusByte data[MAXLENPACKET - sizeof(ModbusData) * 2 - sizeof(ModbusByte)];
        ModbusCRC crc = { 0 };        
        // ------- 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 >= MAXPDULEN );
        }

        // ------- 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 = { 0 };    
        ModbusData quant = { 0 };    
        ModbusCRC crc = { 0 };

        // ------- 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 = { 0 };    
        ModbusData quant = { 0 };    
        ModbusByte bcnt = { 0 };    
        ModbusData data[MAXLENPACKET / sizeof(ModbusData) - sizeof(ModbusData) * 2 - sizeof(ModbusByte)];
        ModbusCRC crc = { 0 };        
        // ------- 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 = { 0 };     
        ModbusData quant = { 0 };    
        // ------- from slave -------
        WriteOutputRetMessage( ModbusMessage& m );
        WriteOutputRetMessage& operator=( ModbusMessage& m );
        void init( ModbusMessage& m );
        ModbusCRC crc = { 0 };

        // ------- 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 = { 0 };   
        ModbusData data = { 0 };    
        ModbusCRC crc = { 0 };      
        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 = { 0 };     
        ModbusData data = { 0 };     
        ModbusCRC crc = { 0 };

        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 = { 0 };    
        ModbusData data = { 0 };    
        ModbusCRC crc = { 0 };        
        // ------- 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 = { 0 };     
        ModbusData data = { 0 };     
        ModbusCRC crc = { 0 };


        // ------- 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 = { 0 };
        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 = { 0 };

        // ------- 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 = { 0 };    
    };
    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 = { 0 };        
        // ------- 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 = { 0 };

        // ------- 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 >= MAXPDULEN );
        }

        size_t szData();

        ModbusMessage transport_msg();

        int bcnt = { 0 }; 
    };

    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 = { 0 };            
        ModbusData num = { 0 };            
        ModbusCRC crc = { 0 };

        // -------------
        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 = { 0 };                    
        //        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()
        size_t count = { 0 };    
    };

    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 = { 0 };    
        ModbusByte min = { 0 };        
        ModbusByte sec = { 0 };        
        ModbusByte day = { 1 };        
        ModbusByte mon = { 1 };        
        ModbusByte year = { 0 };    
        ModbusByte century = { 20 };    
        ModbusCRC crc = { 0 };

        // ------- 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 = { 0 };    
        ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)];
        ModbusCRC crc = { 0 };        
        // -----------
        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 = { 0 };    
        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.
        size_t count = { 0 };    
    };
    // -----------------------------------------------------------------------

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

        ModbusByte bcnt = { 0 };    
        SubRequest data[MAXLENPACKET / sizeof(SubRequest) - sizeof(ModbusByte)];
        ModbusCRC crc = { 0 };        
        // -----------
        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();

        // это поле служебное и не используется в релальном обмене
        size_t count = { 0 }; 
    };

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

    struct FileTransferMessage:
        public ModbusHeader
    {
        ModbusData numfile = { 0 };     
        ModbusData numpacket = { 0 };   
        ModbusCRC crc = { 0 };          
        // ------- 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 = { 0 };
        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), len(0) /*,uID(0) */ {}

        void swapdata();

    } __attribute__((packed));

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

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