1/****************************************************************************
2**
3** Copyright (C) 2017 The Qt Company Ltd.
4** Contact: http://www.qt.io/licensing/
5**
6** This file is part of the QtSerialBus module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL3$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see http://www.qt.io/terms-conditions. For further
15** information use the contact form at http://www.qt.io/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 3 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPLv3 included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 3 requirements
23** will be met: https://www.gnu.org/licenses/lgpl.html.
24**
25** GNU General Public License Usage
26** Alternatively, this file may be used under the terms of the GNU
27** General Public License version 2.0 or later as published by the Free
28** Software Foundation and appearing in the file LICENSE.GPL included in
29** the packaging of this file. Please review the following information to
30** ensure the GNU General Public License version 2.0 requirements will be
31** met: http://www.gnu.org/licenses/gpl-2.0.html.
32**
33** $QT_END_LICENSE$
34**
35****************************************************************************/
36
37#include "qmodbusdataunit.h"
38
39QT_BEGIN_NAMESPACE
40
41/*!
42 \class QModbusDataUnit
43 \inmodule QtSerialBus
44 \since 5.8
45
46 \brief QModbusDataUnit is a container class representing single bit and
47 \c 16 bit word entries in the Modbus register.
48
49 \l QModbusDataUnit can be used for read and write operations. The entries
50 are addressed via \l startAddress() and the \l valueCount() number of
51 contiguous entries. \l registerType() determines which register is used for
52 the operations. Note that some registers are read-only registers.
53
54 The actual \l values() are either single bit or \c 16 bit based.
55 \l QModbusDataUnit::DiscreteInputs and \l QModbusDataUnit::Coils
56 only accept single bits. Therefore \c 0 is interpreted as \c 0 and anything
57 else \c 1.
58*/
59
60/*!
61 \enum QModbusDataUnit::RegisterType
62
63 This enum describes all supported register types.
64
65 \value Invalid Set by the default constructor, do not use.
66 \value DiscreteInputs This type of data can be provided by an I/O
67 system.
68 \value Coils This type of data can be alterable by an
69 application program.
70 \value InputRegisters This type of data can be provided by an I/O
71 system.
72 \value HoldingRegisters This type of data can be alterable by an
73 application program.
74*/
75
76/*!
77 \fn QModbusDataUnit::QModbusDataUnit()
78
79 Constructs an empty, invalid QModbusDataUnit. Start address is set to \c -1
80 and the \l registerType is set to \l QModbusDataUnit::Invalid.
81*/
82
83/*!
84 \fn QModbusDataUnit::QModbusDataUnit(RegisterType type)
85
86 Constructs a unit of data for register \a type. Start address is set to
87 \c 0, data range and data values are empty.
88*/
89
90/*!
91 \fn QModbusDataUnit::QModbusDataUnit(RegisterType type, int address,
92 quint16 size)
93
94 Constructs a unit of data for register\a type. Start address of the data is
95 set to \a address and the size of the unit to \a size.
96 The entries of \l values() are initialized with \c 0.
97*/
98
99/*!
100 \fn QModbusDataUnit::QModbusDataUnit(RegisterType type, int address,
101 const QVector<quint16> &data)
102
103 Constructs a unit of data for register\a type. Start address of the data is
104 set to \a address and the unit's values to \a data.
105 The value count is implied by the \a data size.
106*/
107
108/*!
109 \fn void QModbusDataUnit::setRegisterType(QModbusDataUnit::RegisterType type)
110
111 Sets the register \a type.
112
113 \sa registerType(), QModbusDataUnit::RegisterType
114*/
115
116/*!
117 \fn QModbusDataUnit::RegisterType QModbusDataUnit::registerType() const
118
119 Returns the type of the register.
120
121 \sa setRegisterType(), QModbusDataUnit::RegisterType
122*/
123
124/*!
125 \fn void QModbusDataUnit::setStartAddress(int address)
126
127 Sets the start \a address of the data unit.
128
129 \sa startAddress()
130*/
131
132/*!
133 \fn int QModbusDataUnit::startAddress() const
134
135 Returns the start address of data unit in the register.
136
137 \sa setStartAddress()
138*/
139
140/*!
141 \fn void QModbusDataUnit::setValues(const QVector<quint16> &values)
142
143 Sets the \a values of the data unit. \l QModbusDataUnit::DiscreteInputs
144 and \l QModbusDataUnit::Coils tables only accept single bit value, so \c 0
145 is interpreted as \c 0 and anything else as \c 1.
146
147 \sa values()
148*/
149
150/*!
151 \fn QVector<quint16> QModbusDataUnit::values() const
152
153 Returns the data in the data unit. \l QModbusDataUnit::DiscreteInputs
154 and \l QModbusDataUnit::Coils tables only accept single bit value, so \c 0
155 is interpreted as \c 0 and anything else as \c 1.
156
157 \sa setValues()
158*/
159
160/*!
161 \fn uint QModbusDataUnit::valueCount() const
162
163 Returns the size of the requested register's data block or the size of data
164 read from the device.
165
166 This function may not always return a count that equals \l values() size.
167 Since this class is used to request data from the remote data register, the
168 \l valueCount() can be used to indicate the size of the requested register's
169 data block. Once the request has been processed, the \l valueCount() is
170 equal to the size of \l values().
171
172 \sa setValueCount()
173*/
174
175/*!
176 \fn void QModbusDataUnit::setValueCount(uint newCount)
177
178 Sets the size of the requested register's data block to \a newCount.
179
180 This may be different from \l values() size as this function is used
181 to indicated the size of a data request. Only once the data request
182 has been processed \l valueCount() is equal to the size of \l values().
183*/
184
185/*!
186 \fn void QModbusDataUnit::setValue(int index, quint16 value)
187
188 Sets the register at position \a index to \a value.
189*/
190
191/*!
192 \fn quint16 QModbusDataUnit::value(int index) const
193
194 Return the value at position \a index.
195*/
196
197/*!
198 \fn bool QModbusDataUnit::isValid() const
199
200 Returns \c true if the \c QModbusDataUnit is valid; otherwise \c false.
201 A \c QModbusDataUnit is considered valid if the \l registerType() is not
202 \l QModbusDataUnit::Invalid and the \l startAddress() is greater than or
203 equal to \c 0.
204*/
205
206/*!
207 \typedef QModbusDataUnitMap
208 \relates QModbusDataUnit
209 \since 5.8
210
211 Synonym for QMap<QModbusDataUnit::RegisterType, QModbusDataUnit>.
212*/
213
214QT_END_NAMESPACE
215

source code of qtserialbus/src/serialbus/qmodbusdataunit.cpp