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 uniset
{
// -------------------------------------------------------------------------
namespace ModbusRTU
{
// Базовые типы
typedef uint8_t ModbusByte;    
const size_t BitsPerByte = 8;
typedef uint8_t ModbusAddr;    
typedef uint16_t ModbusData;    
const size_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
};


typedef unsigned long RegID;

RegID genRegID( const ModbusRTU::ModbusData r, const int 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    = 255, 
    MAXPDULEN       = 253, // 255 - 2(CRC)
    MAXDATALEN       = 125  
};

const unsigned char 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 );
// -------------------------------------------------------------------------
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 ADUHeader
{
    ModbusRTU::ModbusData tID; 
    ModbusRTU::ModbusData pID; 
    ModbusRTU::ModbusData len; 
    ADUHeader(): tID(0), pID(0), len(0) {}

    void swapdata();

} __attribute__((packed));

std::ostream& operator<<(std::ostream& os, const ADUHeader& 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 aduhead.tID;
    }
    inline ModbusRTU::ModbusData pID() const
    {
        return aduhead.pID;
    }
    inline ModbusRTU::ModbusData aduLen() const
    {
        return aduhead.len;
    }

    unsigned char* buf();
    ModbusRTU::ModbusData len() const;
    void swapHead();
    void makeHead( 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();

    ADUHeader aduhead;
    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( unsigned char dnum, unsigned char bnum, bool state );

    bool getData( unsigned char 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( unsigned char dnum, unsigned char bnum, bool state );

    bool getData( unsigned char 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( int nbit, bool state );

    inline size_t last() const
    {
        return quant;
    }

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

    bool getBit( unsigned char bnum );

    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;
};

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( 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_
// ---------------------------------------------------------------------------