ModbusTypes.h

// -------------------------------------------------------------------------
#ifndef ModbusTypes_H_
#define ModbusTypes_H_
// -------------------------------------------------------------------------
#include <ostream>
#include <cstdint>
#include <bitset>
#include <string>
#include <list>
#include "ModbusRTUErrors.h"
// -------------------------------------------------------------------------
/* Основные предположения:
 * - младший и старший байт переворачиваются только в CRC
 * - В случае неправильного формата пакета(запроса), логической ошибки и т.п
 *         ОТВЕТ просто не посылается, а пакет отбрасывается...
 * - CRC считается по всей посылке (с начальным адресом)
 * - CRC инициализируется значением 0xffff
 * - CRC не переворачивается
 * - Все двухбайтовые слова переворачиваются. Порядок байт: старший младший
*/
// -------------------------------------------------------------------------
namespace uniset
{
    // -------------------------------------------------------------------------
    namespace ModbusRTU
    {
        // Базовые типы
        typedef uint8_t ModbusByte;    
        const size_t BitsPerByte = 8;
        typedef uint8_t ModbusAddr;    
        typedef uint16_t ModbusData;    
        const uint8_t BitsPerData = 16;
        typedef uint16_t 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
        };
 
 
        using RegID = size_t;
 
        RegID genRegID( const ModbusRTU::ModbusData r, const uint8_t fn );
 
        // определение размера данных в зависимости от типа сообщения
        // возвращает -1 - если динамический размер сообщения или размер неизвестен
        ssize_t 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    = 0, 
            MAXPDULEN       = 253, // 255 - 2(CRC)
            MAXDATALEN       = 125  
        };
 
        const uint8_t MBErrMask = 0x80;
        // ---------------------------------------------------------------------
        uint16_t SWAPSHORT( uint16_t x );
        // ---------------------------------------------------------------------
        ModbusCRC checkCRC( ModbusByte* start, size_t len );
        const size_t szCRC = sizeof(ModbusCRC); 
        // ---------------------------------------------------------------------
        std::ostream& mbPrintMessage(std::ostream& os, ModbusByte* b, size_t 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 );
        size_t numBytes( const size_t nbits ); // сколько байт нужно для указанного количества бит
        // -------------------------------------------------------------------------
        // вспомогательная структура для предотвращения утечки памяти (RAII)
        struct DataGuard
        {
            DataGuard( size_t sz ):
                len(sz)
            {
                data = new ModbusRTU::ModbusData[sz];
            }
 
            ~DataGuard()
            {
                delete[] data;
            }
 
            ModbusRTU::ModbusData* data;
            size_t len;
        };
        // -----------------------------------------------------------------------------
        bool isWriteFunction( SlaveFunctionCode c );
        bool isReadFunction( SlaveFunctionCode c );
        // -------------------------------------------------------------------------
        struct ModbusHeader
        {
            ModbusAddr addr;        
            ModbusByte func;        
            ModbusHeader(): addr(0), func(0) {}
        } __attribute__((packed));
 
        const size_t szModbusHeader = sizeof(ModbusHeader);
 
        std::ostream& operator<<(std::ostream& os, const ModbusHeader& m );
        std::ostream& operator<<(std::ostream& os, const ModbusHeader* m );
        // -----------------------------------------------------------------------
        struct MBAPHeader
        {
            ModbusRTU::ModbusData tID; 
            ModbusRTU::ModbusData pID; 
            ModbusRTU::ModbusData len; 
            MBAPHeader(): tID(0), pID(0), len(0) {}
 
            void swapdata();
 
        } __attribute__((packed));
 
        std::ostream& operator<<(std::ostream& os, const MBAPHeader& m );
        // -----------------------------------------------------------------------
 
        struct ModbusMessage
        {
            ModbusMessage();
 
            ModbusMessage( ModbusMessage&& ) = default;
            ModbusMessage& operator=(ModbusMessage&& ) = default;
            ModbusMessage( const ModbusMessage& ) = default;
            ModbusMessage& operator=(const ModbusMessage& ) = default;
 
            inline ModbusByte func() const
            {
                return pduhead.func;
            }
            inline ModbusAddr addr() const
            {
                return pduhead.addr;
            }
            inline ModbusRTU::ModbusData tID() const
            {
                return mbaphead.tID;
            }
            inline ModbusRTU::ModbusData pID() const
            {
                return mbaphead.pID;
            }
            inline ModbusRTU::ModbusData aduLen() const
            {
                return mbaphead.len;
            }
 
            u_int8_t* buf();
            ModbusRTU::ModbusData len() const;
            void swapHead();
            void makeMBAPHeader( ModbusRTU::ModbusData tID, bool noCRC = true, ModbusRTU::ModbusData pID = 0 );
 
            ModbusRTU::ModbusData pduLen() const;
            ModbusCRC pduCRC( size_t len ) const;
            static size_t maxSizeOfMessage();
 
            void clear();
 
            MBAPHeader mbaphead;
            ModbusHeader pduhead;
            ModbusByte data[MAXLENPACKET + szCRC];   
            // Это поле вспомогательное и игнорируется при пересылке
            size_t dlen = { 0 };  
        } __attribute__((packed));
 
        std::ostream& operator<<(std::ostream& os, const ModbusMessage& m );
        std::ostream& operator<<(std::ostream& os, const ModbusMessage* m );
        // -----------------------------------------------------------------------
        struct ErrorRetMessage:
            public ModbusHeader
        {
            ModbusByte ecode = { erNoError };
            ModbusCRC crc = { 0 };
 
            // ------- from slave -------
            ErrorRetMessage( const ModbusMessage& m );
            ErrorRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            // ------- to master -------
            ErrorRetMessage( ModbusAddr _from, ModbusByte _func, ModbusByte ecode );
 
            ModbusMessage transport_msg();
 
            inline static size_t 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() const;
 
            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( const ModbusMessage& m );
            ReadCoilMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            inline static size_t 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( const ModbusMessage& m );
            ReadCoilRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            static inline int szHead()
            {
                return sizeof(ModbusByte); // bcnt
            }
 
            static size_t getDataLen( const ModbusMessage& m );
            ModbusCRC crc = { 0 };
 
            // ------- to master -------
            ReadCoilRetMessage( ModbusAddr _from );
 
            bool addData( DataBits d );
 
            bool setBit( uint8_t dnum, uint8_t bnum, bool state );
 
            bool getData( uint8_t bnum, DataBits& d ) const;
 
            void clear();
 
            inline bool isFull() const
            {
                return ( (int)bcnt >= MAXPDULEN );
            }
 
            size_t szData() const;
 
            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( const ModbusMessage& m );
            ReadInputStatusMessage& operator=( const ModbusMessage& m );
 
            void init( const ModbusMessage& m );
 
            inline static size_t 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( const ModbusMessage& m );
            ReadInputStatusRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            static inline size_t szHead()
            {
                return sizeof(ModbusByte); // bcnt
            }
 
            static size_t getDataLen( const ModbusMessage& m );
            ModbusCRC crc = { 0 };
 
            // ------- to master -------
            ReadInputStatusRetMessage( ModbusAddr _from );
 
            bool addData( DataBits d );
 
            bool setBit( uint8_t dnum, uint8_t bnum, bool state );
 
            bool getData( uint8_t dnum, DataBits& d ) const;
 
            void clear();
 
            inline bool isFull() const
            {
                return ( (int)bcnt >= MAXPDULEN );
            }
 
            size_t szData() const;
 
            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( const ModbusMessage& m );
            ReadOutputMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            inline static size_t 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( const ModbusMessage& m );
            ReadOutputRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
            static inline size_t szHead()
            {
                // bcnt
                return sizeof(ModbusByte);
            }
 
            static size_t getDataLen( const ModbusMessage& m );
            ModbusCRC crc = { 0 };
 
            // ------- to master -------
            ReadOutputRetMessage( ModbusAddr _from );
 
            bool addData( ModbusData d );
 
            void clear();
 
            inline bool isFull() const
            {
                return ( count * sizeof(ModbusData) >= MAXLENPACKET );
            }
 
            size_t szData() const;
 
            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( const ModbusMessage& m );
            ReadInputMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            inline static size_t 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( const ModbusMessage& m );
            ReadInputRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
            static inline size_t szHead()
            {
                // bcnt
                return sizeof(ModbusByte);
            }
 
            static size_t getDataLen( const ModbusMessage& m );
            ModbusCRC crc = { 0 };
 
            // ------- to master -------
            ReadInputRetMessage( ModbusAddr _from );
 
            bool addData( ModbusData d );
 
            void clear();
 
            inline bool isFull() const
            {
                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( uint8_t nbit, bool state );
 
            inline size_t last() const
            {
                return quant;
            }
 
            bool getData( uint8_t dnum, DataBits& d );
 
            void clear();
            inline bool isFull() const
            {
                return ( (int)bcnt >= MAXPDULEN );
            }
 
            // ------- from master -------
            ForceCoilsMessage( const ModbusMessage& m );
            ForceCoilsMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            size_t szData() const;
 
            static inline size_t szHead()
            {
                // start + quant + count
                return sizeof(ModbusData) * 2 + sizeof(ModbusByte);
            }
 
            static size_t getDataLen( const ModbusMessage& m );
 
            bool checkFormat() const;
 
        } __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( const ModbusMessage& m );
            ForceCoilsRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            // ------- to master -------
            ForceCoilsRetMessage( ModbusAddr _from, ModbusData start = 0, ModbusData quant = 0 );
 
            void set( ModbusData start, ModbusData quant );
 
            ModbusMessage transport_msg();
 
            inline static size_t 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() const
            {
                return ( quant >= MAXDATALEN );
            }
 
            // ------- from master -------
            WriteOutputMessage( const ModbusMessage& m );
            WriteOutputMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            size_t szData() const;
 
            static inline size_t szHead()
            {
                // start + quant + count
                return sizeof(ModbusData) * 2 + sizeof(ModbusByte);
            }
 
            static size_t getDataLen( const ModbusMessage& m );
 
            bool checkFormat() const;
 
        } __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( const ModbusMessage& m );
            WriteOutputRetMessage& operator=( const ModbusMessage& m );
            void init( const 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 size_t 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( const ModbusMessage& m );
            ForceSingleCoilMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            size_t szData() const;
 
            static inline size_t szHead()
            {
                return sizeof(ModbusData);
            }
 
            static size_t getDataLen( const ModbusMessage& m );
 
            bool checkFormat() const;
        } __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() const
            {
                return (data & 0xFF00);
            }
 
            // ------- from slave -------
            ForceSingleCoilRetMessage( const ModbusMessage& m );
            ForceSingleCoilRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            // ------- to master -------
            ForceSingleCoilRetMessage( ModbusAddr _from );
 
            void set( ModbusData start, bool cmd );
 
            ModbusMessage transport_msg();
 
            inline static size_t 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( const ModbusMessage& m );
            WriteSingleOutputMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            size_t szData() const;
 
            static inline size_t szHead()
            {
                return sizeof(ModbusData);
            }
 
            static size_t getDataLen( const 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( const ModbusMessage& m );
            WriteSingleOutputRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            // ------- to master -------
            WriteSingleOutputRetMessage( ModbusAddr _from, ModbusData start = 0 );
 
            void set( ModbusData start, ModbusData data );
 
            ModbusMessage transport_msg();
 
            inline static size_t 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( const ModbusMessage& m );
            DiagnosticMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
            static inline size_t szHead()
            {
                return sizeof(ModbusData); // subf
            }
 
            static size_t getDataLen( const ModbusMessage& m );
            ModbusCRC crc = { 0 };
 
            // ------- to master -------
            DiagnosticMessage( ModbusAddr _from, DiagnosticsSubFunction subf, ModbusData d = 0 );
 
            bool addData( ModbusData d );
 
            void clear();
 
            inline bool isFull() const
            {
                // (1)subf + data count
                return ( 1 + count >= MAXDATALEN );
            }
 
            size_t szData() const;
 
            ModbusMessage transport_msg();
 
            // Это поле не входит в стандарт modbus
            // оно вспомогательное и игнорируется при
            // преобразовании в ModbusMessage.
            // Делать что-типа memcpy(buf,this,sizeof(*this)); будет не верно.
            // Используйте специальную функцию transport_msg()
            size_t count = { 0 };    
        };
        std::ostream& operator<<(std::ostream& os, DiagnosticMessage& m );
        std::ostream& operator<<(std::ostream& os, DiagnosticMessage* m );
        // -----------------------------------------------------------------------
        struct DiagnosticRetMessage:
            public DiagnosticMessage
        {
            DiagnosticRetMessage( const ModbusMessage& m );
            DiagnosticRetMessage( const 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( const ModbusMessage& m );
            MEIMessageRDI& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            static inline size_t szHead()
            {
                return sizeof(ModbusByte) * 3;
            }
 
            static inline size_t szData()
            {
                return sizeof(ModbusByte) * 3 + szCRC;
            }
 
            // вспомогательные функции
            bool checkFormat() const;
 
        } __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, const ModbusByte* dat, ModbusByte len );
 
            ModbusByte id;
            std::string val;
        };
 
        using RDIObjectList = std::list<RDIObjectInfo>;
 
        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( const ModbusMessage& m );
            MEIMessageRetRDI& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            // предварительная инициализации, только заголовочной части, без данных
            void pre_init( const ModbusMessage& m );
 
            static inline size_t 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() const
            {
                return ( bcnt >= MAXPDULEN );
            }
 
            size_t szData() const;
 
            ModbusMessage transport_msg();
 
            size_t 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( const ModbusMessage& m );
            JournalCommandMessage& operator=( const ModbusMessage& m );
 
            inline static size_t 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() const
            {
                return ( count >= MAXDATALEN );
            }
 
            size_t szData() const;
 
            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( const ModbusMessage& m );
            SetDateTimeMessage& operator=( const ModbusMessage& m );
            SetDateTimeMessage();
 
            bool checkFormat() const;
 
            inline static size_t 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( const ModbusMessage& m );
            SetDateTimeRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            // ------- to master -------
            SetDateTimeRetMessage( ModbusAddr _from );
            SetDateTimeRetMessage( const SetDateTimeMessage& query );
            static void cpy( SetDateTimeRetMessage& reply, const SetDateTimeMessage& query );
 
            ModbusMessage transport_msg();
        };
        // -----------------------------------------------------------------------
 
        struct RemoteServiceMessage:
            public ModbusHeader
        {
            ModbusByte bcnt = { 0 };    
            ModbusByte data[MAXLENPACKET - sizeof(ModbusByte)];
            ModbusCRC crc = { 0 };        
            // -----------
            RemoteServiceMessage( const ModbusMessage& m );
            RemoteServiceMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            size_t szData() const;
 
            static inline size_t szHead()
            {
                return sizeof(ModbusByte);    // bcnt
            }
 
            static size_t getDataLen( const 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() const
            {
                return ( count >= sizeof(data) );
            }
 
            size_t szData() const;
 
            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( const ModbusMessage& m );
            ReadFileRecordMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            size_t szData() const;
 
            static inline size_t szHead()
            {
                return sizeof(ModbusByte);    // bcnt
            }
 
            static size_t getDataLen( const ModbusMessage& m );
 
            bool checkFormat() const;
 
            // это поле служебное и не используется в реальном обмене
            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( const ModbusMessage& m );
            FileTransferMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
 
            static inline size_t 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 size_t MaxDataLen = MAXLENPACKET - sizeof(ModbusData) * 3 - sizeof(ModbusByte) * 2;
 
            ModbusByte bcnt;        
            ModbusData numfile;     
            ModbusData numpacks;     
            ModbusData packet;      
            ModbusByte dlen;        
            ModbusByte data[MaxDataLen];
 
 
            // ------- from slave -------
            FileTransferRetMessage( const ModbusMessage& m );
            FileTransferRetMessage& operator=( const ModbusMessage& m );
            void init( const ModbusMessage& m );
            ModbusCRC crc = { 0 };
            static size_t szHead()
            {
                return sizeof(ModbusByte);
            }
            static size_t getDataLen( const 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() const;
 
            ModbusMessage transport_msg();
        };
 
        std::ostream& operator<<(std::ostream& os, FileTransferRetMessage& m );
        std::ostream& operator<<(std::ostream& os, FileTransferRetMessage* m );
        // -----------------------------------------------------------------------
    } // end of ModbusRTU namespace
    // -------------------------------------------------------------------------
} // end of namespace uniset
// ---------------------------------------------------------------------------
#endif // ModbusTypes_H_
// ---------------------------------------------------------------------------