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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
/****************************************************************************
**
** Copyright (C) 2021 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtSerialBus module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:COMM$
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** $QT_END_LICENSE$
**
**
**
**
**
**
**
**
**
**
**
**
**
**
**
**
****************************************************************************/
#ifndef QMODBUSCLIENT_P_H
#define QMODBUSCLIENT_P_H
#include <QtCore/qtimer.h>
#include <QtSerialBus/qmodbusclient.h>
#include <QtSerialBus/qmodbuspdu.h>
#include <private/qmodbusdevice_p.h>
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
QT_BEGIN_NAMESPACE
class Q_AUTOTEST_EXPORT QModbusClientPrivate : public QModbusDevicePrivate
{
Q_DECLARE_PUBLIC(QModbusClient)
public:
QModbusReply *sendRequest(const QModbusRequest &request, int serverAddress,
const QModbusDataUnit *const unit);
QModbusRequest createReadRequest(const QModbusDataUnit &data) const;
QModbusRequest createWriteRequest(const QModbusDataUnit &data) const;
QModbusRequest createRWRequest(const QModbusDataUnit &read, const QModbusDataUnit &write) const;
bool processResponse(const QModbusResponse &response, QModbusDataUnit *data);
bool processReadCoilsResponse(const QModbusResponse &response, QModbusDataUnit *data);
bool processReadDiscreteInputsResponse(const QModbusResponse &response, QModbusDataUnit *data);
bool collateBits(const QModbusPdu &pdu, QModbusDataUnit::RegisterType type, QModbusDataUnit *data);
bool processReadHoldingRegistersResponse(const QModbusResponse &response, QModbusDataUnit *data);
bool processReadInputRegistersResponse(const QModbusResponse &response, QModbusDataUnit *data);
bool collateBytes(const QModbusPdu &pdu, QModbusDataUnit::RegisterType type, QModbusDataUnit *data);
bool processWriteSingleCoilResponse(const QModbusResponse &response, QModbusDataUnit *data);
bool processWriteSingleRegisterResponse(const QModbusResponse &response,
QModbusDataUnit *data);
bool collateSingleValue(const QModbusPdu &pdu, QModbusDataUnit::RegisterType type,
QModbusDataUnit *data);
bool processWriteMultipleCoilsResponse(const QModbusResponse &response, QModbusDataUnit *data);
bool processWriteMultipleRegistersResponse(const QModbusResponse &response,
QModbusDataUnit *data);
bool collateMultipleValues(const QModbusPdu &pdu, QModbusDataUnit::RegisterType type,
QModbusDataUnit *data);
bool processReadWriteMultipleRegistersResponse(const QModbusResponse &response,
QModbusDataUnit *data);
virtual QModbusReply *enqueueRequest(const QModbusRequest &, int, const QModbusDataUnit &,
QModbusReply::ReplyType) {
return nullptr;
}
// TODO: Review once we have a transport layer in place.
virtual bool isOpen() const { return false; }
int m_numberOfRetries = 3;
int m_responseTimeoutDuration = 1000;
struct QueueElement {
QueueElement() = default;
QueueElement(QModbusReply *r, const QModbusRequest &req, const QModbusDataUnit &u, int num,
int timeout = -1)
: reply(r), requestPdu(req), unit(u), numberOfRetries(num)
{
if (timeout >= 0) {
// always the case for TCP
timer = QSharedPointer<QTimer>::create();
timer->setSingleShot(true);
timer->setInterval(timeout);
}
}
bool operator==(const QueueElement &other) const {
return reply == other.reply;
}
QPointer<QModbusReply> reply;
QModbusRequest requestPdu;
QModbusDataUnit unit;
int numberOfRetries;
QSharedPointer<QTimer> timer;
QByteArray adu;
qint64 bytesWritten = 0;
qint32 m_timerId = INT_MIN;
};
void processQueueElement(const QModbusResponse &pdu, const QueueElement &element);
};
QT_END_NAMESPACE
#endif // QMODBUSCLIENT_P_H
|
