People who use Qt for many different projects on many different platforms have a lot of kits configured in their Qt Creator. For those people the “New Project Wizard” contains an annoyance. Picking the right kit from a list of twenty-something possible kits means quite a bit of searching. But no more! For the newly released Qt Creator 4.6 we added a filter widget to quickly select the right one. Enjoy!
OPC UA is a central element of the Industry 4.0 story providing seamless communication between IT and industrial production systems. basysKom has initiated Qt OPC UA in 2015 with the goal of providing an out of the box Qt API for OPC UA. In 2017 basysKom, together with The Qt Company, has finished up a Technology Preview of that API. It will be available with the upcoming Qt 5.11 release end of May.
The focus of Qt OPC UA is on HMI/application development and ease of use for client-side development. The Tech Preview implements a subset of the OPC UA standard. It allows to connect to servers, read and write attributes, call methods on the server, monitor values for data changes and browse nodes. All this functionality is provided by asynchronous APIs which integrate nicely into Qt applications.
Qt OPC UA is primarily an API and not a whole OPC UA stack. A plugin interface allows to integrate existing OPC UA stacks as API backends. Currently, plugins for the following stacks are available:
Qt OPC UA will be available directly from the Qt installer for those holding a Qt for Automation license. The source code itself is triple licensed (GPL, LGPL and commercial) with the exception of the Unified Automation backend which is only available under a commercial license. Users of one of the Open Source licenses will need to compile Qt OPC UA themselves. See here for a list of build recipes.
The backends for FreeOpcUa and open62541 are available under an Open Source license. When going for an Open Source solution, we recommend the open62541 plugin as it is the more complete implementation with an active community and a good momentum. It also has less dependencies, making usage on platforms such as Android or iOS much easier.
On the platform side, the technology preview will by available for
Please note that not every backend is available on every platform.
On top of what is part of the Tech Preview, there are already a number of additions planned. Among them support for transport security, the discovery service, event support and filters.
We are looking forward to feedback and questions on this new module.
basysKom Stand – Halle 4, Stand 400
Auf unserem Stand zeigen wir den Einsatz eines IoT & HMI Gateways, welcher als zentrale Schaltstelle Informationen u.a. aus Maschinen-steuerung, Wartungsarbeiten und Monitoring verwaltet und diese über eine Cloud nach außen zur Verfügung stellt. Darin sind sowohl OPC UA als das Framework für industrielle Interoperabilität wie auch MQTT als Protokoll für die Kommunikation über die Cloud im Einsatz.
Continue reading basysKom auf der Embedded World 2018 vom 27.02. bis 01.03. in Nürnberg
Update 02.03.2018: the steps outlined below have become outdated. Please see here for up to date build steps.
basysKom has initiated Qt OpcUa which is a module offering support for the industrial communication standard OPC UA. This module has been contributed by us to the Qt Project. The Qt OpcUa API wraps existing OPC UA implementations. Currently, implementations for freeopcua and open62541 are available.
Qt OpcUa will become part of the Qt 5.11 release as a Technology Preview. First alpha builds will be available by the end of February 2018. Qt 5.11 release is scheduled for end of May 2018.
We have been asked by a number of people how to get started already now. We will provide short howtos for Ubuntu, Windows-MinGW and Visual Studio 2017 in the following article.
Two things are needed: Qt OpcUa itself and an OPC UA library. In this article, we use open62541 as it has very little dependencies (and is the more complete implementation anyway).
The easiest approach to build Qt OpcUa is as a drop-in for Qt 5.10. This spares us from creating a full Qt build based on the current dev branch.
The following recipes assume that you have cmake, python/pip, perl, git and other essential build tools installed. Paths used with the examples need to be adjusted to reflect your local situation.
These steps have been tested on Ubuntu 16.04 but can be applied to a wide range of desktop distributions.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
$ sudo pip install six $ git clone https://github.com/open62541/open62541.git $ cd open62541 $ git checkout 302003d $ mkdir build && cd build $ cmake -DBUILD_SHARED_LIBS=ON -DUA_ENABLE_AMALGAMATION=ON .. $ make $ sudo make install $ git clone http://code.qt.io/qt/qtopcua.git $ cd qtopcua $ mkdir build && cd build $ /opt/Qt5.10/5.10.0/gcc_64/bin/qmake .. # has open62541 been detected? $ make $ sudo make install |
Start by running the Qt 5.10.0 64-bit for Desktop (MSVC 2017) shell shipped with Qt (have a look at the “Start Menu”). Use this shell to issue the following commands:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
"c:\Program Files (x86)\Microsoft Visual Studio\2017\WDExpress\VC\Auxiliary\Build\vcvarsx86_amd64.bat" pip install six git clone https://github.com/open62541/open62541.git cd open62541 git checkout 302003d mkdir build cd build cmake.exe -G "NMake Makefiles" -DUA_ENABLE_AMALGAMATION=ON .. nmake.exe git clone http://code.qt.io/qt/qtopcua.git cd qtopcua mkdir build cd build set INCLUDE=%INCLUDE%;c:\path\to\open62541\build set LIB=%LIB%;c:\path\to\open62541\build\bin qmake.exe .. # has open62541 been detected? nmake.exe nmame.exe install |
Above recipe will also work for Visual Studio 2015. 2013 is not supported (and will be dropped by Qt 5.11 anyways).
Start by running the Qt 5.10.0 for Desktop (MinGW 5.3.0 32 bit) shell shipped with Qt (have a look at the “Start Menu”). Use this shell to issue the following commands:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
pip install six git clone https://github.com/open62541/open62541.git cd open62541 git checkout 302003d mkdir build cd build cmake.exe -G "MinGW Makefiles" -DUA_ENABLE_AMALGAMATION=ON .. mingw32-make.exe git clone http://code.qt.io/qt/qtopcua.git cd qtopcua mkdir build cd build set CPLUS_INCLUDE_PATH=c:\path\to\open62541\build set LIBRARY_PATH=c:\path\to\open62541\build\bin qmake.exe .. mingw32-make.exe mingw32-make.exe install |
After successful completion of above steps Qt OpcUa will be available from your existing Qt5.10 installation. A documentation snapshot can be found here.
The following “Hello Qt OpcUa” example shows how to read an attribute from a server (add QT += opcua to your .pro).
|
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 |
#include <QCoreApplication> #include <QtOpcUa> class QOpcUaReader : public QObject { Q_OBJECT public: QOpcUaReader(QObject *parent); bool init(); void handleStateChanged(QOpcUaClient::ClientState state); void handleAttributeRead(QOpcUa::NodeAttributes attr); signals: void done(); private: QScopedPointer<QOpcUaClient> m_client; QScopedPointer<QOpcUaNode> m_node; }; QOpcUaReader::QOpcUaReader(QObject *parent) : QObject(parent) {} bool QOpcUaReader::init() { QOpcUaProvider p; qDebug() << "Available backends:" << p.availableBackends(); if (p.availableBackends().size() == 0) { qDebug() << "No backends found"; return false; } m_client.reset(p.createClient(p.availableBackends()[0])); if (!m_client) { qDebug() << "Failed to create client"; return false; } QObject::connect(m_client.data(), &QOpcUaClient::stateChanged, this, &QOpcUaReader::handleStateChanged); m_client->connectToEndpoint(QUrl("opc.tcp://opcua.demo-this.com:51210/UA/SampleServer")); return true; } void QOpcUaReader::handleStateChanged(QOpcUaClient::ClientState state) { qDebug() << "Client state changed:" << state; switch(state) { case QOpcUaClient::ClientState::Connected: { m_node.reset(m_client->node("ns=0;i=84")); if (!m_node) { qDebug() << "Failed to get node"; emit done(); break; } QObject::connect(m_node.data(), &QOpcUaNode::attributeRead, this, &QOpcUaReader::handleAttributeRead); m_node->readAttributes(QOpcUa::NodeAttribute::BrowseName); break; } case QOpcUaClient::Disconnected: { emit done(); break; } default: break; } } void QOpcUaReader::handleAttributeRead(QOpcUa::NodeAttributes attr) { qDebug() << "Signal for attributes:" << attr; if (m_node->attributeError(QOpcUa::NodeAttribute::BrowseName) == QOpcUa::UaStatusCode::Good) qDebug() << "Browse name:" << m_node->attribute(QOpcUa::NodeAttribute::BrowseName).value<QOpcUa::QQualifiedName>().name; else qDebug() << "Failed to read attribute:" << m_node->attributeError(QOpcUa::NodeAttribute::BrowseName); m_client->disconnectFromEndpoint(); } int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); QOpcUaReader reader(&a); QObject::connect(&reader, &QOpcUaReader::done, &a, &QCoreApplication::quit); if (!reader.init()) return 1; return a.exec(); } #include "main.moc" |
Most of the API envisioned for the Technology Preview is available. We are currently busy testing and polishing, as well as adding more comprehensive examples and improving the documentation. Please leave a comment or get in contact with us if you have any questions or comments – you still have the chance to influence the final shape of the API.
The Qt World Summit recordings 2017 are online. basysKom presented “Practical Qt Lite”.
Qt Lite is a project within Qt geared towards optimizing Qt for smaller devices. One important feature of the overall Qt Lite story is the ability to create size optimized, application specific builds of Qt. These require less flash, less RAM and also load faster.
In this presentation we show how to create such size optimized builds with and without Qt Lite and present some actual numbers on achievable savings. Have fun!
This year the Qt World Summit is back in Europe. It will be held October 11th and 12th in Berlin. basysKom is proud to sponsor and to participate in a number of ways.
At the exhibition we will showcase a distributed industrial automation scenario based on Qt Quick and QOpcUa. QOpcUa is an upcoming Qt module basysKom initiated, aiming for simple integration between industrial controllers and HMIs. The showcase also features integration of telemetry data into a Microsoft Azure-based Cloud-Application via MQTT. To highlight the cross platform capabilities of Qt, the HMI is deployed to a number of different devices.
At the conference we will present our Qt Lite experience. “Practical Qt Lite” will be held Wednesday at 15:00, Room A03. Come visit us if you are interested in having smaller Qt builds for your embedded project.
This year, the Qt Contributor Summit is co-located with the World Summit. Contributors to Qt discuss the development and directions of the Qt project. The Contributor summit happens Monday and Tuesday, right before the World Summit. basysKom will offer a session on QOpcUa on Tuesday at 15:00 in Room2. If your are interested in OPC-UA and its integration into Qt please join the session!
We are looking forward to meeting you in Berlin!
Qt Lite is an initiative driven by The Qt Company striving for smaller and leaner Qt builds. It utilizes the new configuration system introduced with Qt 5.8 to create custom builds stripped of features or classes that aren’t needed for a given application. Focus is mostly on Embedded Linux with the goal of making Qt a feasible option on smaller systems. In this post we will have a look at the current state of affairs and we will provide guidance on how to experiment with Qt Lite on your own. Continue reading Qt Lite
basysKom wird auch in diesem Jahr auf dem Entwicklerforum HMI am 18.05.2017 in München als Aussteller HMI-Entwicklung mit Qt und QML präsentieren.
Wir freuen uns auf Ihren Besuch!
Continue reading basysKom auf dem Entwicklerforum HMI in München
basysKom will sponsor the biggest Qt event in Europe, QtCon 2016 in Berlin.
Our Development Lead is looking forward to visiting this event in order to have exciting technical discussions with you. If you want to schedule a meeting upfront, please send an email to info@basyskom.com.
See you in Berlin!
The field of web technology is evolving at a rapid pace. Unlike Qt, which offers a complete, prepackaged solution, there is a multitude of tools and libraries which need to be combined into a functional stack. This article presents a stack proven in cross-platform projects and our experience gathered with it.
Modern web technology provides a powerful foundation for cross-platform application development. By using responsive design techniques a browser based application can already cover desktop and mobile platforms. Using the right set of tools, such an application can be developed further into a real mobile app and/or an embedded touch interface.
The building blocks of a modern “cross-platform web application” are the web runtime environment, the single-page application and the back-end system. Let’s have a look at the definition of these three terms and their relation to each other.
