basysKom beim Merck-Firmenlauf 2019

Am 29. Mai nahmen unsere laufbegeisterten Mitarbeiter beim diesjährigen 8. Darmstädter Merck-Firmenlauf teil. Für sie hieß es: fünf Kilometer rund um den Messplatz.

Bei besten Lauftemperaturen und Sonnenschein trat das hoch motivierte basysKom-Team gemeinsam mit über 5700 anderen Sportlern zum Lauf an – so vielen Teilnehmer wie noch nie zuvor. Tatkräftige Unterstützung gab es natürlich von den Kolleginnen und Kollegen, die eifrig angefeuert haben.

Nach dem erfolgreichen Lauf ging es dann gemeinsam bei bester Stimmung in den Biergarten, um bei einem guten Essen und einem kühlen Getränk das Erlebnis noch einmal Revue passieren und den Abend gemütlich ausklingen zu lassen.

Wir gratulieren unseren Kollegen zu ihren erfolgreichen Läufen und ihren Platzierungen!

Wir freuen uns schon auf das nächste Jahr!

Secure Connections with Qt OPC UA

Starting with the Qt 5.13 release, due end of May, the Qt OPC UA API in combination with the Unified Automation backend officially supports secure connections to servers (Sign or SignAndEncrypt message security mode). The following article outlines the changes to the Qt OPC UA API and shows how to get secure connections also with the open62541 backend.

Security related QOpcUaClient API changes

To enable secure connections a number of changes to the API of the QOpcUaClient were necessary – some of them preventing existing code from compiling. In summary:

The connectToEndpoint() method which takes a QUrl parameter has been removed. The only supported way to specify which server to connect to is now via an endpoint description retrieved using requestEndpoints().
supportedSecurityPolicies() returns a list with the OPC UA security policies supported by the current backend.
setPkiConfiguration() is used to configure QOpcUaClient with a client certificate, a corresponding private key and the necessary data to verify server certificates.
setIdentity() configures the identity information QOpcUaClient provides to the server during the connect. This information can also be initialized from the client certificate.
Up to Qt 5.12, login credentials were supplied to QOpcUaClient by encoding username and password in the URL. setAuthenticationInformation() replaces this by a clean API which can be used to select anonymous, username and password or X509 certificate based authentication.
The connectError() signal is emitted when a connection to a server fails. Depending on the error, the connected slot is able to override it (for example an untrusted or no longer valid server certificate).
If the private key is protected with a password, the passwordForPrivateKeyRequired() signal is emitted. The user can then supply the password in the connected slot.

Review: basysKom auf der Embedded World 2019

Auch in diesem Jahr war basysKom auf der Embedded World und der begleitenden Fachkonferenz vertreten, welche vom 26. bis 28. Februar in den Hallen der Nürnberg Messe stattfanden.

In ihrem 17. Veranstaltungsjahr deckte die internationale Leitmesse mit einer Vielzahl an Ausstellern wieder die gesamte Bandbreite der Embedded Systeme ab und verzeichnete zahlreiche Fachbesucher. Die Anzahl der Aussteller und auch der Besucher erreichten Rekordniveau.

Trendthemen in diesem Jahr: KI, Safety and Security, ebenso wie HMI, M2M, Open Source, Edge und Cloud Computing.

An unserem Stand konnten sich Interessierte anhand unseres neuen Showcases aktuelle Entwicklungen im Bereich der digitalen Industrieproduktion zeigen lassen, sowie anregende Diskussionen mit unseren Fachleuten führen.
Ein besonderes Highlight bestand hier in einer im Showcase integrierten Sprachsteuerung, welche die Automatisierung der Produktionsstraße durch einen hands-free Workflow optimiert.

Im Bereich des Cloud Computing boten wir unseren Besuchern eine Remote-Monitoring Anwendung. Diese war aufgebaut auf der Cloudtechnologie Azure von Microsoft und dem WebApplication-Framework Angular.

Auch an der begleitenden Konferenz beteiligte sich basysKom mit zwei Vorträgen. Bei diesen referierten wir über die Erstellung von Embedded Computer Vision Applications mit Qt und über die Applikationsentwicklung mit der Open Source-Implementierung open62541 nach OPC-UA-Standard.

Initial support for servers with historical data access in open62541

An OPC UA server supporting historical access allows clients to access historical data or historical events. Such a server can act as a process or event historian. open62541-based servers were till recently completely missing the ability to support these use cases. basysKom has extended the server API to support access to historical data using the “read raw” functionality specified in OPC UA part 11. This allows to create a simple process historian. This article provides an overview about this API and a short tutorial how to use it.

Overview

Most of the new functionality is contained within a plugin called UA_HistoryDatabase. This plugin contains three main API elements.

UA_HistoryDatabase (same name as the plugin) which contains the main interface between the server itself and the plugin.
UA_HistoryDataBackend which implements the integration with a specific database. A sample implementation based on a simple in-memory database is provided.
UA_HistoryDataGathering which encapsulates the gathering and storage of data.

The following diagram gives an overview how these API elements interact.

Tutorial

The following tutorial will first demonstrate how to create a simple server, hosting a single variable node. We will extend this server to store this value in an in-memory database each time it changes.

Let’s start with a server:

#include "open62541.h"
#include <signal.h>
 
static UA_Boolean running = true;
static void stopHandler(int sign) {
    (void)sign;
    UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "received ctrl-c");
    running = false;
}
 
 
int main(void) {
    signal(SIGINT, stopHandler);
    signal(SIGTERM, stopHandler);
 
    UA_ServerConfig *config = UA_ServerConfig_new_default();
    UA_Server *server = UA_Server_new(config);
    /* Define the attribute of the uint32 variable node */
    UA_VariableAttributes attr = UA_VariableAttributes_default;
    UA_UInt32 myUint32 = 40;
    UA_Variant_setScalar(&attr.value, &myUint32, &UA_TYPES[UA_TYPES_UINT32]);
    attr.description = UA_LOCALIZEDTEXT("en-US","myUintValue");
    attr.displayName = UA_LOCALIZEDTEXT("en-US","myUintValue");
    attr.dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
    attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;
 
    /* Add the variable node to the information model */
    UA_NodeId uint32NodeId = UA_NODEID_STRING(1, "myUintValue");
    UA_QualifiedName uint32Name = UA_QUALIFIEDNAME(1, "myUintValue");
    UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);
    UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
    UA_NodeId outNodeId;
    UA_NodeId_init(&outNodeId);
    UA_StatusCode retval = UA_Server_addVariableNode(server,
                                                     uint32NodeId,
                                                     parentNodeId,
                                                     parentReferenceNodeId,
                                                     uint32Name,
                                                     UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),
                                                     attr,
                                                     NULL,
                                                     &outNodeId);
    fprintf(stderr, "UA_Server_addVariableNode %s\n", UA_StatusCode_name(retval));
    retval = UA_Server_run(server, &running);
    fprintf(stderr, "UA_Server_run %s\n", UA_StatusCode_name(retval));
    UA_Server_run_shutdown(server);
    UA_Server_delete(server);
    UA_ServerConfig_delete(config);
    return (int)retval;
}

#include "open62541.h"

#include <signal.h>

static UA_Boolean running = true;

static void stopHandler(int sign) {

(void)sign;

UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "received ctrl-c");

running = false;

}

int main(void) {

signal(SIGINT, stopHandler);

signal(SIGTERM, stopHandler);

UA_ServerConfig *config = UA_ServerConfig_new_default();

UA_Server *server = UA_Server_new(config);

/* Define the attribute of the uint32 variable node */

UA_VariableAttributes attr = UA_VariableAttributes_default;

UA_UInt32 myUint32 = 40;

UA_Variant_setScalar(&attr.value, &myUint32, &UA_TYPES[UA_TYPES_UINT32]);

attr.description = UA_LOCALIZEDTEXT("en-US","myUintValue");

attr.displayName = UA_LOCALIZEDTEXT("en-US","myUintValue");

attr.dataType = UA_TYPES[UA_TYPES_UINT32].typeId;

attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE;

/* Add the variable node to the information model */

UA_NodeId uint32NodeId = UA_NODEID_STRING(1, "myUintValue");

UA_QualifiedName uint32Name = UA_QUALIFIEDNAME(1, "myUintValue");

UA_NodeId parentNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER);

UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);

UA_NodeId outNodeId;

UA_NodeId_init(&outNodeId);

UA_StatusCode retval = UA_Server_addVariableNode(server,

uint32NodeId,

parentNodeId,

parentReferenceNodeId,

uint32Name,

UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE),

attr,

NULL,

&outNodeId);

fprintf(stderr, "UA_Server_addVariableNode %s\n", UA_StatusCode_name(retval));

retval = UA_Server_run(server, &running);

fprintf(stderr, "UA_Server_run %s\n", UA_StatusCode_name(retval));

UA_Server_run_shutdown(server);

UA_Server_delete(server);

UA_ServerConfig_delete(config);

return (int)retval;

}

The resulting server can be browsed and the variable can be read. We use UAExpert for this tasks.

We now extend this example so that the server will be able to handle request for historical values for this node. Each of the following snippets contains enough context so it is clear where to add the code into the initial server code.

[...]
UA_ServerConfig *config = UA_ServerConfig_new_default();
 
 
// Instanciate a UA_HistoryDataGathering with an initial node id store size of 1.
 
// The store will grow if additional nodes are registered, but this is expensive.
UA_HistoryDataGathering gathering = UA_HistoryDataGathering_Default(1);
// configure the server with an instance of the UA_HistoryDatabase plugin
config->historyDatabase = UA_HistoryDatabase_default(gathering);
UA_Server *server = UA_Server_new(config);
UA_VariableAttributes attr = UA_VariableAttributes_default;
UA_UInt32 myUint32 = 40;
UA_Variant_setScalar(&amp;attr.value, &amp;myUint32, &amp;UA_TYPES[UA_TYPES_UINT32]);
attr.description = UA_LOCALIZEDTEXT("en-US","myUintValue");
attr.displayName = UA_LOCALIZEDTEXT("en-US","myUintValue");
attr.dataType = UA_TYPES[UA_TYPES_UINT32].typeId;
 
// announce support for history read to clients
attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE | UA_ACCESSLEVELMASK_HISTORYREAD;
// tell the server to enable historizing for this node
attr.historizing = true;
 
UA_NodeId uint32NodeId = UA_NODEID_STRING(1, "myUintValue");
UA_QualifiedName uint32Name = UA_QUALIFIEDNAME(1, "myUintValue");
[...]

[...]

UA_ServerConfig *config = UA_ServerConfig_new_default();

// Instanciate a UA_HistoryDataGathering with an initial node id store size of 1.

// The store will grow if additional nodes are registered, but this is expensive.

UA_HistoryDataGathering gathering = UA_HistoryDataGathering_Default(1);

// configure the server with an instance of the UA_HistoryDatabase plugin

config->historyDatabase = UA_HistoryDatabase_default(gathering);

UA_Server *server = UA_Server_new(config);

UA_VariableAttributes attr = UA_VariableAttributes_default;

UA_UInt32 myUint32 = 40;

UA_Variant_setScalar(&attr.value, &myUint32, &UA_TYPES[UA_TYPES_UINT32]);

attr.description = UA_LOCALIZEDTEXT("en-US","myUintValue");

attr.displayName = UA_LOCALIZEDTEXT("en-US","myUintValue");

attr.dataType = UA_TYPES[UA_TYPES_UINT32].typeId;

// announce support for history read to clients

attr.accessLevel = UA_ACCESSLEVELMASK_READ | UA_ACCESSLEVELMASK_WRITE | UA_ACCESSLEVELMASK_HISTORYREAD;

// tell the server to enable historizing for this node

attr.historizing = true;

UA_NodeId uint32NodeId = UA_NODEID_STRING(1, "myUintValue");

UA_QualifiedName uint32Name = UA_QUALIFIEDNAME(1, "myUintValue");

[...]

Next we configure the node to update the database each time the nodes value is set.

[...]
                                                 NULL,
                                                 &amp;outNodeId);
fprintf(stderr, "UA_Server_addVariableNode %s\n", UA_StatusCode_name(retval));
 
UA_HistorizingNodeIdSettings setting;
/* Use the default sample in-memory database. Reserve space for 3 nodes with an initial room of 100 values each.
 * This will also automaticaly grow if needed. */
setting.historizingBackend = UA_HistoryDataBackend_Memory(3, 100);
 
/* We want the server to serve a maximum of 100 values per request.
 * This value depends on the platform you are running the server on - a big
 * server can serve more values in a single request. */
setting.maxHistoryDataResponseSize = 100;
// update the database each time the node value is set
setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_VALUESET;
// register the node for gathering data in the database
retval = gathering.registerNodeId(server, gathering.context, &amp;outNodeId, setting);
fprintf(stderr, "registerNodeId %s\n", UA_StatusCode_name(retval));
retval = UA_Server_run(server, &amp;running);
fprintf(stderr, "UA_Server_run %s\n", UA_StatusCode_name(retval));
[...]

[...]

NULL,

&outNodeId);

fprintf(stderr, "UA_Server_addVariableNode %s\n", UA_StatusCode_name(retval));

UA_HistorizingNodeIdSettings setting;

/* Use the default sample in-memory database. Reserve space for 3 nodes with an initial room of 100 values each.

* This will also automaticaly grow if needed. */

setting.historizingBackend = UA_HistoryDataBackend_Memory(3, 100);

/* We want the server to serve a maximum of 100 values per request.

* This value depends on the platform you are running the server on - a big

* server can serve more values in a single request. */

setting.maxHistoryDataResponseSize = 100;

// update the database each time the node value is set

setting.historizingUpdateStrategy = UA_HISTORIZINGUPDATESTRATEGY_VALUESET;

// register the node for gathering data in the database

retval = gathering.registerNodeId(server, gathering.context, &outNodeId, setting);

fprintf(stderr, "registerNodeId %s\n", UA_StatusCode_name(retval));

retval = UA_Server_run(server, &running);

fprintf(stderr, "UA_Server_run %s\n", UA_StatusCode_name(retval));

[...]

Again we rely on the UAExpert to validate the server. First update the variable a few times (so we actually have some historical values). Next we want to read them. For that we use the “History Trend View” which is available via Document → Add → Document Type. The resulting view shows either a graph or (in a second tab) a list of your historical values. If no values are plotted or the list is empty make sure that the right time interval is used in the request.

Conclusion & future work

It is now possible to create open62541-based servers which support the gathering and reading of historical data values. A number of plugin interfaces has been defined which can be used to implement functionality such as support for additional databases (e.g. sqlite). There is additional work to be done to support other history read details such as “read event”, “read modified”, “read processed” or “read at a time”. Also the history update service still needs to be implemented.

In addition to being a contributor to the project, basysKom also provides commercial support for the open62541 OPC UA stack. Talk to us if you are interested in project/application support, the implementation of missing features or bugfixing.

Mit OpenCV und Qt Quick trifft Computer Vision auf moderne HMI-Entwicklung

Ob beim automatischen Sortieren von Briefen, beim Erkennen von Materialfehlern in der Produktion oder bei der Vermessung: überall dort, wo Maschinen ihre Umwelt erkennen müssen, kommt Computer Vision zum Einsatz.

OpenCV ist ein populäres Open Source Framework, das eine große Anzahl an Algorithmen für die Bilderkennung zur Verfügung stellt. Eine Bibliothek zur Umsetzung prototypischer HMIs mit Fokus auf Parametereinstellung ist vorhanden, für anspruchsvollere Aufgaben sollte OpenCV jedoch mit einem HMI-Framework integriert werden.

In einem aktuellen Artikel in der Design&Elektronik geben unsere Software Entwickler Berthold Krevert und Torsten Rahn einen Überblick, welche Themen bei der Integration von Open CV und Qt Quick zu beachten sind.

embedded world 2019 vom 26.02. – 28.02.2019 in Nürnberg

Die Embedded-Community trifft sich wieder im Rahmen der jährlich stattfindenden Embedded World sowie der begleitenden Konferenz in Nürnberg. basysKom wird an verschiedenen Stellen präsent sein:

Diskutieren Sie mit uns an unserem Stand in der Halle 4, Stand 400 oder als Partner bei The Qt Company, Halle 4, Stand 258, über aktuelle Themen in der Entwicklung von HMIs und Anwendungen für technische Aufgaben und freuen Sie sich auf unseren neuen Showcase. Wir zeigen – von der Steuerung bis in die Cloud – Digitalisierung im Kontext einer industriellen Produktionsstraße. Als besonderes Highlight haben wir dieses Jahr eine Sprachsteuerung in unsere Industrial HMI integriert. Damit werden hands-free Workflows auch an der Maschine möglich. Auf der Cloud-Seite zeigen wir eine Remote-Monitoring Anwendung basierend auf Microsoft Azure und Angular.

basysKom ist auch mit zwei Vorträgen auf der embedded world Conference 2019 vertreten:

Dienstag, 26.02.2019 um 16:00 Uhr
Berthold Krevert:
Embedded Computer Vision Applications with Qt

In dieser Präsentation wird dargestellt, wie komplexe HMIs für Computer Vision-Anwendungen mit Qt erstellt werden.

Donnerstag, 28.02.2019 um 14:00 Uhr
Frank Meerkötter:
OPC UA Application Development with open62541

open62541 ist eine freie und Open Source-Implementierung des OPC-UA-Standards. Nach einem Start im größtenteils akademischen Kontext sieht es in kommerziellen Projekten immer mehr Akzeptanz.

Sichern Sie sich mit uns eine kostenlose Eintrittskarte indem Sie sich einfach bei uns melden. Wir freuen uns auf Ihren Besuch!

Using Shiboken2 to create Python bindings for a Qt library

With the release of Qt 5.12, Qt for Python is officially supported and can be used to write full-fledged Qt applications using Python as the main programming language (https://blog.qt.io/blog/2018/12/18/qt-python-5-12-released/).

This prompted us to also take a closer look at the bindings (the Python module is called PySide2) and also the underlying technology, namely the binding generator called Shiboken2.

This post will show you how to create a set of Python bindings for a small Qt library from scratch.

PySide2

The Qt bindings themselves are easy to install and use.

If you have a python interpreter and the pip package manager set up on your system, whether it is Windows or Linux, you can install the module via pip install PySide2 and are ready to go.

Shiboken2

While it is nice to use the Qt framework from Python it is even better to be able to quickly create Python bindings for your own Qt libraries and use their API from Python with relatively little work.

Setup

All examples on this article have been run on Ubuntu 18.04, the setup steps for other platforms might vary.

Since the most recent documentation advises to build Shiboken2 from source for building your own bindings, we will do that now.

Multimodale User-Interfaces für Industrie und Automationslösungen

Der Software-Spezialist für Industrie und Maschinenbau, basysKom, und voice INTER connect, Experte für industrielle Sprachsteuerungen, stellen zur SPS IPC Drives in Nürnberg vom 27.-29.11.2018 gemeinsam ihr Konzept für eine multimodale Bedienung einer Automatisierungslösung vor.

Mit der Einbeziehung menschlicher Sprache als zusätzliche Modalität in industrielle Bedienkonzepte ergeben sich ganz neue Möglichkeiten für die effiziente Überwachung und Statusabfrage großer Anlagen, Wissensmanagement und maschinelle Assistenz in komplexen Fertigungsprozessen sowie bei der Effizienzsteigerung durch kontextbezogene Bereitstellung von Informationen in Konfigurations- und Wartungsprozessen.

Zur SPS IPC Drives wurde durch beide Unternehmen prototypisch eine Fertigungsanlage mit Sprachbedienfunktionen auf Basis von vicCONTROL industrial ausgestattet. Der Besucher kann auf dem Stand der Spectra GmbH & Co. KG in Halle 7 Stand 420 erleben, welche Effizienzvorteile eine ortsunabhängige und parallele Konfiguration und Bedienung der Maschinenfunktionen per Sprache bieten. Unabhängig vom Zustand der klassischen GUI können Prozessdaten abgefragt und Konfigurationen per Sprache umgeschaltet werden. Die stationäre Bedienung über ein GUI-Terminal kann unter Nutzung von OPC-UA z.B. für Wartungszwecke auf ein mobiles Bedienterminal dupliziert werden. Hier spielen sprachbasierte, kontextbezogene Informationsabfragen und akustische Hilfefunktionen ihre Stärken aus.

Neugierig geworden? Erleben Sie die Vorteile einer Sprachbedienung live und diskutieren Sie mit uns den Einsatz von Sprachbedienung in Ihrer Automationslösung.

basysKom & The Qt Company in Halle 5, Stand 254

Anwendungen und Maschinen sind heute nicht mehr ausschließlich lokal. Die Integration in und mit übergeordneten Systemen ist ein wichtiger Aspekt, um Mehrwert zu generieren. Über die HMI an der Maschine wird diese gesteuert. Gleichzeitig müssen Daten und Zustände dieser Maschine an übergeordnete Systeme übertragen und dort zur Nutzung weiter aufbereitet und gespeichert werden. Einsatzbeispiele sind dabei: Monitoring, Predictive Maintenance, Verbrauchsdatenüberwachung, Einsatzplanung und vieles mehr.

basysKom präsentiert dies auf Basis des bekannten Industrial HMI Showcases, der um ein Maschinenmonitoring unter Verwendung von Microsoft Azure™ Diensten erweitert wurde. Die lokale Bedienung per HMI wird am Beispiel einer Verpackungsanlage dargestellt. Telemetriedaten werden auf der Embedded Hardware an der Anlage akquiriert, über eine sichere Datenkommunikation an die skalierbare Microsoft Azure™ Infrastruktur übertragen und dort verarbeitet. Über eine web-basierte Monitoring-Anwendung werden die Ergebnisse bereitgestellt.

Als etablierter Dienstleister für die Entwicklung industrieller Anwendungen bietet basysKom Unterstützung über die gesamte Verarbeitungskette:

Sichere Einbindung von Maschinen in eine Cloud-Infrastruktur
Datenerfassung und Aufbereitung auf der Maschine (Device to Cloud)
Verarbeitung von Befehlen und Konfigurationsänderungen aus der Cloud (Cloud to Device)
Sichere Datenübertragung mit MQTT, AMQP und OPC UA
Entwurf und Umsetzung von skalierbaren Anwendungsarchitekturen mit den Mitteln von Microsoft Azure™
Entwicklung von Anwendungen und HMIs mit Webtechnologien für die Darstellung und Nutzung der Daten

Eingesetzte Technologien:

Embedded Linux
C, C++ und Qt
Qt Quick (lokales HMI)
MQTT, REST, WebSockets
OPC UA (Qt OPC UA, open62541)
Microsoft Azure™ als Cloud-Plattform
Umsetzung der Dienste über node.js
Webtechnologie: Single-Page Application basierend auf Angular, umgesetzt mit Javascript und Typescript
Google-Firebase (Smartwatch)

Sollten Sie noch eine Eintrittskarte für die Messe benötigen, melden Sie sich gerne bei uns.

Wir freuen uns auf Ihren Besuch!

Konferenz Internet of Things – vom Sensor bis zur Cloud

basysKom wird auch in diesem Jahr auf der “Konferenz Internet of Things – vom Sensor bis zur Cloud” am 25.10.2018 in München als Aussteller diesmal mit einem Industrial Azure-IoT Showcase vertreten sein.

Continue reading Konferenz Internet of Things – vom Sensor bis zur Cloud