modbus-potato/ModbusUtil.h at master · lorcap/modbus-potato · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#ifndef __ModbusPotato_ModbusUtil_h__
#define __ModbusPotato_ModbusUtil_h__
#include <cstddef>
#include "ModbusTypes.h"
namespace ModbusPotato
{

constexpr int PDU_LEN_FUNCTION   = 1;
constexpr int PDU_LEN_ADDRESS    = 2;
constexpr int PDU_LEN_BYTE_COUNT = 1;
constexpr int PDU_LEN_QUANTITY   = 2;
constexpr int PDU_LEN_CRC        = 2;

/* --- general PDU length ------------------------------------------------ */

extern bool pdu_short (uint8_t station_address, const uint8_t* buffer, size_t buffer_len);
extern size_t pdu_len (uint8_t station_address, const uint8_t* buffer, size_t buffer_len);

/* --- request PDU length ------------------------------------------------ */

extern size_t pdu_len_req (const uint8_t* buffer, size_t buffer_len);
extern size_t pdu_len_req (function_code::function_code func, size_t byte_count = 0);

inline size_t pdu_len_req_read_coil_status ()
{
    return PDU_LEN_FUNCTION
         + PDU_LEN_ADDRESS
         + PDU_LEN_QUANTITY // quantity/value
         + PDU_LEN_CRC;
}

inline size_t pdu_len_req_read_discrete_input_status ()
{ return pdu_len_req_read_coil_status(); }

inline size_t pdu_len_req_read_holding_registers ()
{ return pdu_len_req_read_coil_status(); }

inline size_t pdu_len_req_read_input_registers ()
{ return pdu_len_req_read_coil_status(); }

inline size_t pdu_len_req_write_single_coil ()
{ return pdu_len_req_read_coil_status(); }

inline size_t pdu_len_req_write_single_register ()
{ return pdu_len_req_read_coil_status(); }

inline size_t pdu_len_req_write_multiple_coils (int byte_count)
{
    return PDU_LEN_FUNCTION
         + PDU_LEN_ADDRESS
         + PDU_LEN_QUANTITY
         + PDU_LEN_BYTE_COUNT
         + byte_count
         + PDU_LEN_CRC;
}

inline size_t pdu_len_req_write_multiple_registers (int byte_count)
{ return pdu_len_req_write_multiple_coils(byte_count); }

inline size_t pdu_len_req_read_write_multiple_registers (int byte_count)
{
    return PDU_LEN_FUNCTION
         + PDU_LEN_ADDRESS
         + PDU_LEN_QUANTITY
         + PDU_LEN_ADDRESS
         + PDU_LEN_QUANTITY
         + PDU_LEN_BYTE_COUNT
         + byte_count
         + PDU_LEN_CRC;
}

/* --- response PDU length ----------------------------------------------- */

extern size_t pdu_len_rsp (const uint8_t* buffer, size_t buffer_len);
extern size_t pdu_len_rsp (function_code::function_code func, size_t byte_count = 0);

inline size_t pdu_len_rsp_read_coil_status (int byte_count)
{
    return PDU_LEN_FUNCTION
         + PDU_LEN_BYTE_COUNT
         + byte_count
         + PDU_LEN_CRC;
}

inline size_t pdu_len_rsp_read_discrete_input_status (int byte_count)
{ return pdu_len_rsp_read_coil_status(byte_count); }

inline size_t pdu_len_rsp_read_holding_registers (int byte_count)
{ return pdu_len_rsp_read_coil_status(byte_count); }

inline size_t pdu_len_rsp_read_input_registers (int byte_count)
{ return pdu_len_rsp_read_coil_status(byte_count); }

inline size_t pdu_len_rsp_write_single_coil ()
{
    return PDU_LEN_FUNCTION
         + PDU_LEN_ADDRESS
         + PDU_LEN_QUANTITY
         + PDU_LEN_CRC;
}

inline size_t pdu_len_rsp_write_single_register ()
{ return pdu_len_rsp_write_single_coil(); }

inline size_t pdu_len_rsp_write_multiple_coils ()
{ return pdu_len_rsp_write_single_coil(); }

inline size_t pdu_len_rsp_write_multiple_registers ()
{ return pdu_len_rsp_write_single_coil(); }

inline size_t pdu_len_rsp_read_write_multiple_registers (int byte_count)
{ return pdu_len_rsp_read_coil_status(byte_count); }

}

#endif