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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
|
/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the documentation of Qt for Automation.
**
** $QT_BEGIN_LICENSE:GPL$
** 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.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 or (at your option) any later version
** approved by the KDE Free Qt Foundation. The licenses are as published by
** the Free Software Foundation and appearing in the file LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
/*!
\page qtautomation-index.html
\title Qt for Automation
\nextpage qtautomation-overview.html
\e {\QTA} is a collection of software components, tools, and services
targeted for the development of automation systems: connected
\e {Internet of Things} edge devices, backend services, and their
supporting applications.
\QTA builds on top of Qt for Application Development and
\l {Qt for Device Creation}, providing the same great integrated
development environment, libraries and tools for creating embedded devices
and applications on all platforms supported by Qt. Additional modules are
provided for machine-to-machine communication, building automation, and
remote access of desktop applications.
To help with potential issues faced during development, industry-specific
consultancy services are part of the \QTA offering.
\section1 Contents
\list
\li \l {Qt for Automation Overview}
\li \l {Installing Qt for Automation}
\li \l {Deploying Qt for Automation Modules to Boot2Qt}
\endlist
\section1 Related Information
\list
\li \l {Qt CoAP}
\li \l {Qt KNX}
\li \l {Qt MQTT}
\li \l {Qt OPC UA}
\li \l {Qt for Device Creation}
\endlist
*/
/*!
\page qtautomation-overview.html
\title Qt for Automation Overview
\previouspage qtautomation-index.html
\nextpage qtautomation-install.html
\section1 Components
\QTA includes several components built on Qt and the \l {Qt Creator}
integrated development environment.
\section2 Qt
Cross-platform \l {http://www.qt.io/}{Qt} development libraries
and core tools are developed through an open-source collaboration model.
Qt is a full development framework designed to streamline the creation of
applications and user interfaces for desktop, embedded, and mobile
platforms.
The Qt libraries provide high-level APIs for a large variety of both
non-GUI and GUI related functionality. For UI creation, Qt provides a
number of approaches: traditional C++, declarative UI design with
\l {Qt Quick} or HTML5/hybrid user interfaces with the \l {Qt WebEngine}
module.
For an overview of Qt libraries see the \l {Qt reference documentation}.
Qt modules that are especially useful for automation:
\list
\li \l {Qt Virtual Keyboard} - complete virtual keyboard solution with
word-prediction and multiple languages supported.
\li \l {Qt Quick Controls 2} - provides a set of controls for building
complete user interfaces in Qt Quick.
\li \l {Qt Quick Compiler} - enables compiling .qml source files into
application binaries, improving load times and security for code
assets.
\li \l {Qt WebEngine} - provides a web browser engine based on the
\l {https://www.chromium.org}{Chromium} project.
\li \l {Qt Serial Bus} - access various industrial serial buses and
protocols such as ModBus.
\li \l {Qt Quick WebGL Streaming} Plugin - allows running Qt Quick
applications remotely in a WebGL-enabled browser.
\endlist
\section2 Development Environment
The development environment in \QTA is built around \l {Qt Creator}.
\list
\li \l {Qt Creator: Developing Qt Quick Applications}
\li \l {Qt Creator: Analyzing Code}
\li \l {Qt Creator: Debugging}
\endlist
\section2 Qt Configuration Tool
The \l {Qt Configuration Tool} allows browsing and selecting features that
are included in the Qt build configuration, making it easy to optimize Qt
libraries for minimal footprint, performance and start-up time.
\section2 Automation APIs
\QTA comes with additional modules for machine-to-machine communication
and building automation:
\b {Qt CoAP}
\l {CoAP}(Constrained Application Protocol) is a machine-to-machine (M2M)
web transfer protocol for use with constrained nodes and networks in the
Internet of Things (IoT). It is designed to easily interface with HTTP
for integration with the Web, while meeting specialized requirements such
as multicast support, very low overhead, and simplicity for constrained
environments.
\l {Qt CoAP} implements the client side of CoAP defined by \l{RFC 7252}.
Generally, CoAP is designed to use datagram-oriented transport such as UDP,
and therefore the current implementation of the transport is based on UDP.
However, it is also possible to implement custom transports based on TCP,
WebSocket, and so on.
\b {Qt MQTT}
\l {MQTT} (Message Queue Telemetry Transport) is an extremely
lightweight machine-to-machine (M2M) connectivity protocol utilizing the
publish-and-subscribe paradigm, and is suitable for carrying telemetry data
with minimal overhead.
\l {Qt MQTT} provides a standard-compliant implementation of the MQTT
protocol specification. It enables applications to act as telemetry displays
and devices to publish telemetry data.
\b {Qt KNX}
\l {KNX} is a standard for controlling home and building management
equipment, such as lighting, blinds and shutters, security systems,
heating and energy management, and more.
\l {Qt KNX} implements the client side of a connection between a client and
a KNXnet/IP server. This connection enables sending messages to the KNX bus
and controlling the functionalities of the KNX devices. Only local device
management procedures and KNX application services working with group
addressing are fully supported.
\b {Qt OPC UA}
\l {OPC UA} is a protocol for data modelling and exchange of data in
industrial applications.
\l {Qt OPC UA} provides a means to interact with OPC UA servers on top of
third-party OPC UA stacks.
\section1 Deployment
Device deployment can be done directly from the Qt Creator IDE to a
device connected via USB or local area network, or to an emulator
running the same full software stack as the devices.
As with any Qt application, the same project can be deployed to
desktop or mobile targets as well.
*/
/*!
\page qtautomation-install.html
\title Installing Qt for Automation
\previouspage qtautomation-overview.html
\nextpage qtautomation-boot2qt.html
Pre-built \QTA installation packages are available under a commercial
license. Open source developers can build their own binaries from the
sources that are available under the \e {GNU General Public License
version 3 (GPLv3)}. Further, Qt OPC UA can be built with the \e {GNU
Lesser General Public License (LGPLv3)} license, as long as the open62541
backend is used.
\l{Download Qt} page helps you to find the license that suits your needs.
The commercial license is associated with a Qt Account, which is required
to install the product.
\section1 Prerequisites
\QTA is based on the \l {Qt for Device Creation} offering so the
prerequisites are the same for both. For more information about how to install and
configure these prerequisites on your development host, see
\l {Requirements for Linux/X11} and \l {Requirements for Windows}.
\section1 Installing
\list 1
\li Download the \l{Qt Online Installer Download}{Qt online installer}.
\note On Linux, the installer needs executable permissions before you
can run it.
\li Run the installer and select \uicontrol Next to get to the Qt account
section.
\li Enter your Qt account credentials and select \uicontrol Next to run
a license check against the Qt account.
\li Select \uicontrol Next again to choose an install path.
\li Select \uicontrol Next to see available packages to install from.
\li Select \b{Qt for Automation} and at least one \b Qt version
from the list, and follow the instructions to complete the installation.
\endlist
*/
/*!
\page qtautomation-boot2qt.html
\title Deploying Qt for Automation Modules to Boot2Qt
\previouspage qtautomation-install.html
\QTA modules are created on top of Qt for Application development and
\l{Qt for Device Creation}. However, the modules are not part of the
Boot2Qt deployment images.
To add \QTA modules to an image using Qt Creator:
\list 1
\li Install \l {Qt for Device Creation} for your target, as instructed
in \l {Qt for Device Creation: Installation Guides}.
\li Install the sources of the module using the Qt online installer, as
instructed in \l {Installing Qt for Automation}.
\li Open the top-level project of the module (for example, qtmqtt.pro)
with Qt Creator and select the build and run kit, as instructed in
\l{Qt Creator: Opening Projects}.
\li Select \uicontrol Build > \uicontrol {Build Project}
to build the module, as instructed in
\l{Qt Creator: Building for Multiple Platforms}.
\li In the \uicontrol Projects mode, add \c install to the
\uicontrol {Make arguments} field in the build settings
to pass it to Make.
\image qtmqtt-build-settings.png
\li Build the project again to install the required files into the
\c sysroot directory of the target device.
\li Copy the generated .so files from the installation step to
\c /usr/lib on the target device to enable running applications
on it.
\endlist
You can now compile and link projects that use \QTA modules.
*/
|
