QOpcUaClient Class

Dokumentation der Member-Funktionen

[virtual noexcept] QOpcUaClient::~QOpcUaClient()

Löscht die Instanz „ QOpcUaClient “.

bool QOpcUaClient::addNode(const QOpcUaAddNodeItem &nodeToAdd)

Fügt den unter nodeToAdd beschriebenen Knoten auf dem Server hinzu.

Gibt „ true “ zurück, wenn der asynchrone Aufruf erfolgreich versendet wurde.

Der Erfolg des Vorgangs wird im Signal ` addNodeFinished()` zurückgegeben.

Der folgende Beispielcode fügt einen neuen „Variable“-Knoten auf dem Server hinzu:

QOpcUaNodeCreationAttributes attributes;
attributes.setDisplayName(QOpcUaLocalizedText("en", "My new Variable node"));
attributes.setDescription(QOpcUaLocalizedText("en", "A node which has been added at runtime"));
attributes.setValue(23.0, QOpcUa::Types::Double);
attributes.setDataTypeId(QOpcUa::ns0ID(QOpcUa::NodeIds::Namespace0::Double));
attributes.setValueRank(-2); // Scalar or array
attributes.setAccessLevel(QOpcUa::AccessLevelBit::CurrentRead);
attributes.setUserAccessLevel(QOpcUa::AccessLevelBit::CurrentRead);

QOpcUaAddNodeItem item;
item.setParentNodeId(QOpcUaExpandedNodeId("ns=3;s=TestFolder"));
item.setReferenceTypeId(QOpcUa::nodeIdFromReferenceType(QOpcUa::ReferenceTypeId::Organizes));
item.setRequestedNewNodeId(QOpcUaExpandedNodeId("ns=3;s=MyNewVariableNode"));
item.setBrowseName(QOpcUaQualifiedName(3, "MyNewVariableNode"));
item.setNodeClass(QOpcUa::NodeClass::Variable);
item.setNodeAttributes(attributes);

m_client->addNode(item);

Siehe auch „ deleteNode()“, „ addNodeFinished()“ und „ QOpcUaAddNodeItem “.

[signal] void QOpcUaClient::addNodeFinished(QOpcUaExpandedNodeId requestedNodeId, QString assignedNodeId, QOpcUa::UaStatusCode statusCode)

Dieses Signal wird ausgelöst, nachdem ein Vorgang mit ` addNode()` abgeschlossen wurde. ` requestedNodeId ` ist die angeforderte Knoten-ID aus dem Aufruf von ` addNode()`, ` assignedNodeId ` ist die Knoten-ID, die der Server dem neuen Knoten zugewiesen hat. ` statusCode ` enthält das Ergebnis des Vorgangs. Ist das Ergebnis ` Bad`, ist ` assignedNodeId ` leer und es wurde kein Knoten zum Adressraum des Servers hinzugefügt.

bool QOpcUaClient::addReference(const QOpcUaAddReferenceItem &referenceToAdd)

Fügt die unter referenceToAdd beschriebene Referenz zum Server hinzu.

Gibt „ true “ zurück, wenn der asynchrone Aufruf erfolgreich versendet wurde.

Der Erfolg des Vorgangs wird im Signal „ addReferenceFinished()“ zurückgegeben.

Der folgende Beispielcode fügt eine Referenz auf einen Knoten zum Ordner „Objects“ hinzu:

QOpcUaAddReferenceItem item;
item.setSourceNodeId(QOpcUa::namespace0Id(QOpcUa::NodeIds::Namespace0::ObjectsFolder));
item.setReferenceTypeId(QOpcUa::nodeIdFromInteger(0, static_cast<quint32>(QOpcUa::ReferenceTypeId::Organizes)));
item.setIsForwardReference(true);
item.setTargetNodeId(QOpcUaExpandedNodeId("ns=3;s=MyNewVariableNode"));
item.setTargetNodeClass(QOpcUa::NodeClass::Variable);

m_client->addReference(item);

Siehe auch deleteReference(), addReferenceFinished() und QOpcUaAddReferenceItem.

[signal] void QOpcUaClient::addReferenceFinished(QString sourceNodeId, QString referenceTypeId, QOpcUaExpandedNodeId targetNodeId, bool isForwardReference, QOpcUa::UaStatusCode statusCode)

Dieses Signal wird ausgelöst, nachdem eine Operation mit ` addReference()` abgeschlossen wurde. ` sourceNodeId`, ` referenceTypeId`, ` targetNodeId ` und ` isForwardReference ` sind die Werte aus dem Aufruf von ` addReference()`. ` statusCode ` enthält das Ergebnis der Operation.

[since QtOpcUa 5.13] QOpcUaApplicationIdentity QOpcUaClient::applicationIdentity() const

Gibt die Anwendungs-ID dieser Instanz von „ QOpcUaClient “ zurück.

Diese Funktion wurde in QtOpcUa 5.13 eingeführt.

Siehe auch ` setApplicationIdentity()`.

const QOpcUaAuthenticationInformation &QOpcUaClient::authenticationInformation() const

Gibt die aktuellen Authentifizierungsdaten zurück.

Siehe auch ` setAuthenticationInformation()`.

QString QOpcUaClient::backend() const

Gibt den Namen des Backends zurück, das von dieser Instanz von QOpcUaClient verwendet wird, z. B. „open62541“.

[signal, since QtOpcUa 5.13] void QOpcUaClient::connectError(QOpcUaErrorState *errorState)

Dieses Signal wird ausgelöst, wenn beim Aufbau der Verbindung ein Fehler aufgetreten ist. Der Parameter „ errorState “ enthält Informationen zum Fehler.

Bei clientseitigen Fehlern können diese ignoriert werden, indem „ QOpcUaErrorState::setIgnoreError “ für das Objekt aufgerufen wird.

Während der Ausführung eines mit diesem Signal verbundenen Slots wird das Backend angehalten und wartet, bis alle Slots zurückkehren. Dies ermöglicht es, einen Benutzerdialog einzublenden, um den Endbenutzer beispielsweise zu fragen, ob er einem unbekannten Zertifikat vertrauen soll, bevor das Backend fortfährt.

Diese Funktion wurde in QtOpcUa 5.13 eingeführt.

[invokable, since QtOpcUa 5.13] void QOpcUaClient::connectToEndpoint(const QOpcUaEndpointDescription &endpoint)

Stellt eine Verbindung zu dem in „ endpoint “ angegebenen OPC-UA-Endpunkt her.

QEndpointDescription endpointDescription;
...
client->connectToEndpoint(endpointDescription);

Eine Liste der verfügbaren Endpunkte wird in der Regel durch Aufruf von ` QOpcUaClient::requestEndpoints()` abgerufen.

Wenn der Endpunkt eine Benutzernamen-Authentifizierung erfordert, muss in QOpcUaAuthenticationInformation mindestens ein Benutzername festgelegt sein. Wird diese Funktion aufgerufen, bevor Authentifizierungsinformationen festgelegt wurden, wird die anonyme Authentifizierung verwendet.

QOpcUaAuthenticationInformation authInfo;
authInfo.setUsernameAuthentication("user", "password");

client->setAuthenticationInformation(authInfo);

Diese Funktion wurde in QtOpcUa 5.13 eingeführt.

Siehe auch connected(), stateChanged(), setAuthenticationInformation() und QOpcUaEndpointDescription.

[signal] void QOpcUaClient::connected()

Dieses Signal wird ausgesendet, wenn eine Verbindung hergestellt wurde.

[since 6.6] QOpcUaConnectionSettings QOpcUaClient::connectionSettings() const

Gibt die Verbindungseinstellungen für diesen Client zurück.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch ` setConnectionSettings()`.

bool QOpcUaClient::deleteNode(const QString &nodeId, bool deleteTargetReferences = true)

Löscht den Knoten mit der Knoten-ID „ nodeId “ vom Server. Wenn „ deleteTargetReferences “ den Wert „ false “ hat, werden nur die Verweise mit dem Quellknoten „ nodeId “ gelöscht. Wenn „ deleteTargetReferences “ den Wert „ true “ hat, werden auch Verweise mit „ nodeId “ als Ziel gelöscht.

Gibt „ true “ zurück, wenn der asynchrone Aufruf erfolgreich weitergeleitet wurde.

Der Erfolg der Operation wird im Signal „ deleteNodeFinished()“ zurückgegeben.

Der folgende Beispielcode löscht einen Knoten und alle Verweise darauf vom Server:

m_client->deleteNode(QOpcUaExpandedNodeId("ns=3;s=MyNewVariableNode"), true);

Siehe auch „ addNode()“ und „ deleteNodeFinished()“.

[signal] void QOpcUaClient::deleteNodeFinished(QString nodeId, QOpcUa::UaStatusCode statusCode)

Dieses Signal wird ausgelöst, nachdem eine Operation mit ` deleteNode()` abgeschlossen wurde. ` nodeId ` ist die Knoten-ID aus dem Aufruf von ` deleteNode()`. ` statusCode ` enthält das Ergebnis der Operation.

bool QOpcUaClient::deleteReference(const QOpcUaDeleteReferenceItem &referenceToDelete)

Löscht die durch referenceToDelete beschriebene Referenz vom Server.

Gibt „ true “ zurück, wenn der asynchrone Aufruf erfolgreich ausgelöst wurde.

Der Erfolg des Vorgangs wird über das Signal ` deleteReferenceFinished()` zurückgegeben.

Der folgende Beispielcode löscht eine Referenz auf einen Knoten aus dem Ordner „Objects“:

QOpcUaDeleteReferenceItem item;
item.setSourceNodeId(QOpcUa::namespace0Id(QOpcUa::NodeIds::Namespace0::ObjectsFolder));
item.setReferenceTypeId(QOpcUa::nodeIdFromInteger(0, static_cast<quint32>(QOpcUa::ReferenceTypeId::Organizes)));
item.setIsForwardReference(true);
item.setTargetNodeId(QOpcUaExpandedNodeId("ns=3;s=MyNewVariableNode"));
item.setDeleteBidirectional(true);

m_client->deleteReference(item);

Siehe auch „ addReference()“, „ deleteReferenceFinished()“ und „ QOpcUaDeleteReferenceItem “.

[signal] void QOpcUaClient::deleteReferenceFinished(QString sourceNodeId, QString referenceTypeId, QOpcUaExpandedNodeId targetNodeId, bool isForwardReference, QOpcUa::UaStatusCode statusCode)

Dieses Signal wird ausgelöst, nachdem eine Operation mit ` deleteReference()` abgeschlossen wurde. ` sourceNodeId`, ` referenceTypeId`, ` targetNodeId ` und ` isForwardReference ` sind die Werte aus dem Aufruf von ` deleteReference()`. ` statusCode ` enthält das Ergebnis der Operation.

[invokable] void QOpcUaClient::disconnectFromEndpoint()

Trennt die Verbindung zum Server.

Siehe auch disconnected() und connectToEndpoint().

[signal] void QOpcUaClient::disconnected()

Dieses Signal wird ausgegeben, wenn eine Verbindung nach einer Schließenanforderung geschlossen wurde.

QOpcUaEndpointDescription QOpcUaClient::endpoint() const

Gibt die Beschreibung des Endpunkts zurück, mit dem der Client derzeit verbunden ist oder zuletzt verbunden war.

[signal] void QOpcUaClient::endpointsRequestFinished(QList<QOpcUaEndpointDescription> endpoints, QOpcUa::UaStatusCode statusCode, QUrl requestUrl)

Dieses Signal wird ausgelöst, nachdem ein Aufruf von ` requestEndpoints()` abgeschlossen wurde. ` statusCode ` enthält das Ergebnis des Aufrufs. Ist das Ergebnis ` Good`, enthält ` endpoints ` die Beschreibungen aller auf dem Server verfügbaren Endpunkte. ` requestUrl ` enthält die URL, die im Aufruf von ` requestEndpoints()` verwendet wurde.

QOpcUaClient::ClientError QOpcUaClient::error() const

Gibt den aktuellen Fehlerstatus des Clients zurück.

bool QOpcUaClient::findServers(const QUrl &url, const QStringList &localeIds = QStringList(), const QStringList &serverUris = QStringList())

Startet eine asynchrone „FindServers“-Anfrage, um eine Liste bekannter Server von einem Server oder Discovery-Server unter url abzurufen. Gibt „ true “ zurück, wenn der asynchrone Aufruf erfolgreich versendet wurde.

localeIds kann verwendet werden, um die Sprache der von der Anfrage zurückgegebenen Anwendungsnamen auszuwählen. Das Format ist in OPC UA 1.05 Teil 3, 8.4 festgelegt, zum Beispiel „en“ für Englisch oder „de-DE“ für Deutsch (Deutschland). Wenn mehr als eine Locale-ID angegeben wird, verwendet der Server die erste Übereinstimmung. Wenn keine Übereinstimmung vorliegt oder „ localeIds “ leer ist, wählt der Server eine Standard-Locale aus.

serverUris kann verwendet werden, um die Ergebnisse auf Server zu beschränken, deren Anwendungsbeschreibung eine übereinstimmende `applicationUri` enthält. Um beispielsweise die aktuelle URL des Servers mit der `applicationUri` „MyPLC“ zu ermitteln, kann der folgende Aufruf verwendet werden:

client->findServers(discoveryServerUrl, QStringList(), QStringList({"MyPLC"}));

Die Ergebnisse werden im Signal ` findServersFinished()` zurückgegeben.

[signal] void QOpcUaClient::findServersFinished(QList<QOpcUaApplicationDescription> servers, QOpcUa::UaStatusCode statusCode, QUrl requestUrl)

Dieses Signal wird ausgelöst, nachdem eine Operation mit ` findServers()` abgeschlossen wurde. ` statusCode ` enthält das Ergebnis der Operation. Wenn das Ergebnis ` Good` lautet, enthält ` servers ` die Anwendungsbeschreibungen aller dem abgefragten Server bekannten Server, die den Filterkriterien entsprachen. ` requestUrl ` enthält die URL, die im Aufruf von ` findServers()` verwendet wurde.

bool QOpcUaClient::isNamespaceAutoupdateEnabled() const

Gibt zurück, ob die automatische Aktualisierung des Namespace-Arrays aktiviert ist.

QStringList QOpcUaClient::namespaceArray() const

Gibt den zwischengespeicherten Wert des Namespace-Arrays zurück.

Der Wert ist erst gültig, nachdem das Signal „ namespaceArrayUpdated()“ ausgelöst wurde.

Siehe auch ` updateNamespaceArray()` und ` namespaceArrayUpdated()`.

[signal] void QOpcUaClient::namespaceArrayChanged(QStringList namespaces)

Dieses Signal wird ausgelöst, nachdem sich das Namespace-Array geändert hat. „ namespaces “ enthält den Inhalt der Namespace-Tabelle des Servers. Der Index eines Eintrags in „ namespaces “ entspricht dem in der Knoten-ID verwendeten Namespace-Index.

Siehe auch namespaceArrayUpdated() und updateNamespaceArray().

[signal] void QOpcUaClient::namespaceArrayUpdated(QStringList namespaces)

Dieses Signal wird ausgegeben, nachdem ein „ updateNamespaceArray “-Vorgang abgeschlossen wurde. „ namespaces “ enthält den Inhalt der Namespace-Tabelle des Servers. Der Index eines Eintrags in „ namespaces “ entspricht dem in der Knoten-ID verwendeten Namespace-Index.

Wenn der Inhalt des Namespace-Arrays nach der Aktualisierung unverändert bleibt, wird dieses Signal dennoch ausgelöst.

Siehe auch namespaceArrayChanged() und updateNamespaceArray().

int QOpcUaClient::namespaceAutoupdateInterval() const

Gibt das aktuell angepasste Aktualisierungsintervall des Namensraum-Arrays zurück.

Siehe auch setNamespaceAutoupdateInterval(int interval).

QOpcUaNode *QOpcUaClient::node(const QOpcUaExpandedNodeId &expandedNodeId)

Gibt ein „ QOpcUaNode “-Objekt zurück, das dem durch „ expandedNodeId “ identifizierten OPC-UA-Knoten zugeordnet ist. Der Aufrufer wird zum Eigentümer des Knotenobjekts.

Befindet sich der Knoten nicht auf dem aktuell verbundenen Server, kann der Namensraum nicht aufgelöst werden, ist die Knoten-ID fehlerhaft oder ist der Client nicht verbunden, wird ` nullptr ` zurückgegeben.

Siehe auch updateNamespaceArray().

QOpcUaNode *QOpcUaClient::node(const QString &nodeId)

Gibt ein „ QOpcUaNode “-Objekt zurück, das dem durch „ nodeId “ identifizierten OPC-UA-Knoten zugeordnet ist. Der Aufrufer wird zum Eigentümer des Knotenobjekts.

Ist der Client nicht verbunden, wird „ nullptr “ zurückgegeben. Die Backends können in anderen Fehlerfällen (beispielsweise bei einer fehlerhaften Knoten-ID) ebenfalls „ nullptr “ zurückgeben.

[signal, since QtOpcUa 5.13] void QOpcUaClient::passwordForPrivateKeyRequired(QString keyFilePath, QString *password, bool previousTryWasInvalid)

Dieses Signal wird ausgelöst, wenn ein Passwort für einen verschlüsselten privaten Schlüssel abgefragt wird. Der Parameter „ keyFilePath “ enthält den Dateipfad zu dem verwendeten Schlüssel. Der Parameter „ previousTryWasInvalid “ ist „true“, wenn ein vorheriger Versuch, den Schlüssel zu entschlüsseln, fehlgeschlagen ist (d. h. ungültiges Passwort). Der Parameter „ password “ verweist auf ein „ QString “, das mit dem tatsächlichen Passwort für den Schlüssel gefüllt werden muss. Falls der vorherige Versuch fehlgeschlagen ist, enthält es das zuvor verwendete Passwort.

Während der Ausführung eines mit diesem Signal verbundenen Slots wird das Backend angehalten und wartet, bis alle Slots zurückkehren. Dies ermöglicht es, einen Benutzerdialog einzublenden, um den Endbenutzer nach dem Passwort zu fragen.

Diese Funktion wurde in QtOpcUa 5.13 eingeführt.

[since QtOpcUa 5.13] QOpcUaPkiConfiguration QOpcUaClient::pkiConfiguration() const

Gibt die PKI-Konfiguration der Anwendung für diese „ QOpcUaClient “-Instanz zurück.

Diese Funktion wurde in QtOpcUa 5.13 eingeführt.

Siehe auch setPkiConfiguration().

QOpcUaQualifiedName QOpcUaClient::qualifiedNameFromNamespaceUri(const QString &namespaceUri, const QString &name, bool *ok = nullptr) const

Versucht, aus „ namespaceUri “ und der Namenszeichenfolge „ name “ einen qualifizierten Namen zu bilden. Gibt den resultierenden qualifizierten Namen zurück. Es wird ein leerer qualifizierter Name zurückgegeben, wenn „ namespaceUri “ nicht aufgelöst werden kann.

ok wird auf true gesetzt, wenn die Auflösung der Namensraum-URI erfolgreich war. Konnte die Namensraum-URI nicht aufgelöst werden, wird ok auf false gesetzt.

[since 6.3] QOpcUaHistoryReadResponse *QOpcUaClient::readHistoryData(const QOpcUaHistoryReadRawRequest &request)

Startet einen „Read Raw History“- request -Dienst für einen oder mehrere Knoten. Hierbei handelt es sich um die Darstellung „ Qt OPC UA “ für den OPC UA-Dienst „ReadHistory“ zum Auslesen von Rohhistoriedaten , wie in OPC UA 1.05, Teil 4, Abschnitt 5.10.3 definiert.

Der Start-Zeitstempel, der End-Zeitstempel, die Anzahl der Werte pro Knoten, „returnBounds“ und die zu lesenden Knoten können in einem „ QOpcUaHistoryReadRawRequest “ angegeben werden.

Gibt ein ` QOpcUaHistoryReadResponse ` zurück, das den Status der Anfrage enthält, sofern die asynchrone Anfrage erfolgreich versendet wurde. Die Ergebnisse werden über das Signal ` QOpcUaHistoryReadResponse::readHistoryDataFinished(const QList<QOpcUaHistoryData> &results, QOpcUa::UaStatusCode serviceResult)` zurückgegeben.

Im folgenden Beispiel werden die historischen Daten der letzten zwei Tage von zwei Knoten abgefragt und ausgegeben. Das Ergebnis ist auf zehn Werte pro Knoten begrenzt.

QOpcUaHistoryReadRawRequest request(
            { QOpcUaReadItem("ns=1;s=myValue1"), QOpcUaReadItem("ns=1;s=myValue2") },
            QDateTime::currentDateTime(),
            QDateTime::currentDateTime().addDays(-2),
            10,
            true);

QOpcUaHistoryReadResponse*response = m_client->readHistoryData(request);
if (response) {
   QObject::connect(response, &QOpcUaHistoryReadResponse::readHistoryDataFinished,
                    [] (QList<QOpcUaHistoryData> Ergebnisse, QOpcUa::UaStatusCode serviceResult) {
                        if (serviceResult != QOpcUa::UaStatusCode::Good) {
                            qWarning() << "Fetching historical data failed with:" << serviceResult;
                        } else {
                            for (const auto& result : results) {
                                qInfo() << "NodeId:" << result.nodeId();
                               for (const auto &dataValue: result.result())
                                    qInfo() << "Value:" << dataValue.value();
                            }
                        }
                    });
}

Diese Funktion wurde in Qt 6.3 eingeführt.

[since 6.7] QOpcUaHistoryReadResponse *QOpcUaClient::readHistoryEvents(const QOpcUaHistoryReadEventRequest &request)

Startet eine Abfrage des Leseereignisverlaufs für eine oder mehrere Knoten-IDs mit den Parametern unter request.

Gibt ein ` QOpcUaHistoryReadResponse ` zurück, das den Status der Anfrage enthält, sofern die asynchrone Anfrage erfolgreich versendet wurde. Die Ergebnisse werden über das Signal ` QOpcUaHistoryReadResponse::readHistoryEventsFinished` (`const QList<QOpcUaHistoryEvent> &results, QOpcUa::UaStatusCode serviceResult`) zurückgegeben.

Das folgende Beispiel ruft historische Ereignisse der letzten zwei Tage für zwei Knoten ab. Pro Knoten werden jeweils bis zu 10 Ereignisse zurückgegeben. Solange weitere Ereignisse vorhanden sind, die dem Filter und dem angegebenen Zeitbereich entsprechen, ist ` hasMoreData() ` wahr, und es können weitere Ereignisse über `readMoreData()` abgerufen werden.

QOpcUaMonitoringParameters::EventFilter filter;
filter << QOpcUaSimpleAttributeOperand("Message");
filter << QOpcUaSimpleAttributeOperand("Time");

const QOpcUaHistoryReadEventRequest request({ QOpcUaReadItem("ns=2;s=EventHistorian"), QOpcUaReadItem("ns=2;s=EventHistorian2") },
                                            QDateTime::currentDateTime().addDays(-2), QDateTime::currentDateTime(),
                                            filter, 10);

// Das Antwortobjekt muss vom Benutzer freigegeben werden, nachdem alle gewünschten Daten abgerufen wurden
const auto response = opcuaClient->readHistoryEvents(request);

QObject::connect(response, &QOpcUaHistoryReadResponse::readHistoryEventsFinished, this,
                 [response](const QList<QOpcUaHistoryEvent> &results, QOpcUa::UaStatusCode serviceResult) {
    if (serviceResult != QOpcUa::UaStatusCode::Good) {
        qDebug() << "Service call failed with" << serviceResult;
       return;
    }

    // Das bisher Erreichte ausgeben
    for (const auto &result: response->events()) {
        qDebug() << "Results for" << result.nodeId() << result.statusCode();
       for (const auto &event: result.events())
            qDebug() << "    Event:" << event;
    }

    if (response->hasMoreData())
        response->readMoreData();
});

Diese Funktion wurde in Qt 6.7 eingeführt.

bool QOpcUaClient::readNodeAttributes(const QList<QOpcUaReadItem> &nodesToRead)

Startet das Auslesen mehrerer Attribute auf verschiedenen Knoten. Für jeden Eintrag in „ nodesToRead “ können die Knoten-ID, das Attribut und ein Indexbereich angegeben werden.

Gibt „true“ zurück, wenn die asynchrone Anfrage erfolgreich versendet wurde. Die Ergebnisse werden über das Signal „ readNodeAttributesFinished()“ zurückgegeben.

Diese Lesefunktion bietet eine alternative Möglichkeit zum Auslesen von Knotenattributen, die in Szenarien eingesetzt werden kann, in denen die Werte einer großen Anzahl von Knotenattributen auf verschiedenen Knoten ausgelesen werden müssen, ohne dass die anderen Funktionen der auf „ QOpcUaNode “ basierenden API, wie beispielsweise die Überwachung von Wertänderungen, benötigt werden. Alle Leseelemente in der Anfrage werden in einer einzigen Anfrage an den Server gesendet und in einer einzigen Antwort beantwortet, die ein einziges „ readNodeAttributesFinished()“-Signal erzeugt. Dies reduziert den Netzwerk-Overhead und die Anzahl der Signal-Slot-Verbindungen, wenn viele verschiedene Knoten beteiligt sind.

Im folgenden Beispiel werden das Attribut „display name“ sowie die beiden Indexbereiche „0:2“ und „5:7“ des Attributs „value“ desselben Knotens und das gesamte Attribut „value“ eines zweiten Knotens mit einem einzigen Dienstaufruf gelesen:

QList<QOpcUaReadItem> request;
request.push_back(QOpcUaReadItem("ns=1;s=MyArrayNode",
                                 QOpcUa::NodeAttribute::DisplayName));
request.push_back(QOpcUaReadItem("ns=1;s=MyArrayNode",
                                 QOpcUa::NodeAttribute::Value, "0:2"));
request.push_back(QOpcUaReadItem("ns=1;s=MyArrayNode",
                                 QOpcUa::NodeAttribute::Value, "5:7"));
request.push_back(QOpcUaReadItem("ns=1;s=MyScalarNode));
m_client->readNodeAttributes(request);

Siehe auch QOpcUaReadItem und readNodeAttributesFinished().

[signal] void QOpcUaClient::readNodeAttributesFinished(QList<QOpcUaReadResult> results, QOpcUa::UaStatusCode serviceResult)

Dieses Signal wird ausgelöst, nachdem ein readNodeAttributes()-Vorgang abgeschlossen wurde.

Die Elemente in „ results “ haben dieselbe Reihenfolge wie die Elemente in der Anfrage. Für jedes angeforderte Element gibt es in „ results “ einen Wert zusammen mit Zeitstempeln und dem Statuscode. „ serviceResult “ enthält den Statuscode des OPC-UA-Lese-Dienstes.

Siehe auch readNodeAttributes(), QOpcUaReadResult und QOpcUaReadItem.

[since 6.7] bool QOpcUaClient::registerNodes(const QStringList &nodesToRegister)

Registriert die Knoten-IDs unter „ nodesToRegister “ auf dem Server und gibt „ true “ zurück, wenn die Anfrage erfolgreich weitergeleitet wurde. Die Ergebnisse werden über das Signal „ registerNodesFinished()“ zurückgegeben.

Der Knotenregistrierungsdienst wird verwendet, um dem Server mitzuteilen, dass auf einen Knoten häufig zugegriffen wird, damit er beispielsweise die Verbindung zu einer externen Ressource offen halten kann. Der Server kann außerdem eine Alias-Knoten-ID zurückgeben, die vorzugsweise numerisch sein sollte. Dies kann nützlich sein, wenn ein Knoten mit einer langen Zeichenfolge als Knoten-ID in vielen Anfragen verwendet wird. Der tatsächliche Leistungsgewinn (sofern vorhanden) hängt von der Implementierung des Servers ab.

Die Gültigkeit der registrierten Knoten-IDs ist nur für die aktuelle Sitzung gewährleistet. Nicht mehr benötigte Registrierungen sollten so schnell wie möglich aufgehoben werden, damit der Server die zugehörigen Ressourcen freigeben kann.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch ` unregisterNodes()`.

[signal, since 6.7] void QOpcUaClient::registerNodesFinished(const QStringList &nodesToRegister, const QStringList &registeredNodeIds, QOpcUa::UaStatusCode statusCode)

Dieses Signal wird ausgelöst, nachdem ein Vorgang mit ` registerNodes()` abgeschlossen wurde. ` nodesToRegister ` enthält die Knoten-IDs aus der Anfrage zu Korrelationszwecken. Die vom Server zurückgegebenen Knoten-IDs befinden sich in ` registeredNodeIds ` und sind in derselben Reihenfolge wie die IDs in der Anfrage. ` statusCode ` gibt an, ob der Vorgang erfolgreich war.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch „ registerNodes()“.

bool QOpcUaClient::requestEndpoints(const QUrl &url)

Startet eine asynchrone „ GetEndpoints “-Anfrage, um eine Liste der verfügbaren Endpunkte vom Server unter url abzurufen. Gibt „ true “ zurück, wenn der asynchrone Aufruf erfolgreich versendet wurde.

Die Endpunktinformationen werden im Signal „ endpointsRequestFinished()“ zurückgegeben.

QString QOpcUaClient::resolveExpandedNodeId(const QOpcUaExpandedNodeId &expandedNodeId, bool *ok = nullptr) const

Versucht, „ expandedNodeId “ in eine Knoten-ID-Zeichenkette mit numerischem Namespace-Index aufzulösen. Gibt die Knoten-ID-Zeichenkette zurück, wenn die Konvertierung erfolgreich war.

Eine leere Zeichenkette wird zurückgegeben, wenn der Namensraumindex nicht aufgelöst werden kann oder wenn der Bezeichnerteil der erweiterten Knoten-ID fehlerhaft ist. ok wird auf true gesetzt, wenn die Konvertierung erfolgreich war. Konnte die erweiterte Knoten-ID nicht aufgelöst werden, wird ok auf false gesetzt.

[since QtOpcUa 5.13] void QOpcUaClient::setApplicationIdentity(const QOpcUaApplicationIdentity &identity)

Legt die Anwendungsidentität für diese „ QOpcUaClient “-Instanz auf „ identity “ fest.

Diese Funktion wurde in QtOpcUa 5.13 eingeführt.

Siehe auch „ applicationIdentity()“.

void QOpcUaClient::setAuthenticationInformation(const QOpcUaAuthenticationInformation &authenticationInformation)

Legt die Authentifizierungsdaten dieses Clients auf „ authenticationInformation “ fest.

Siehe auch authenticationInformation() und connectToEndpoint().

[since 6.6] void QOpcUaClient::setConnectionSettings(const QOpcUaConnectionSettings &connectionSettings)

Legt die Verbindungseinstellungen für diesen Client auf connectionSettings fest.

Beispiel:

QOpcUaConnectionSettings settings;
// Ask the server to give localized texts in german with french as fallback
settings.setSessionLocaleIds({ "de", "fr" });
// We need to call some long running methods, increase the request timeout
settings.setRequestTimeout(std::chrono::minutes(2));
opcuaClient->setConnectionSettings(settings);

Die Werte von connectionSettings werden ab diesem Zeitpunkt auf alle neuen Verbindungen angewendet.

Das Plugin „ open62541 “ unterstützt die Aktualisierung der Session-Locale-IDs für die aktuelle Verbindung. Alle anderen Werte, die geändert werden, deren Aktualisierung während einer bestehenden Verbindung jedoch nicht unterstützt wird, führen zu einer Warnmeldung und werden beim nächsten Aufruf von ` connectToEndpoint()` übernommen.

Diese Funktion wurde in Qt 6.6 eingeführt.

Siehe auch ` connectionSettings()`.

void QOpcUaClient::setNamespaceAutoupdate(bool isEnabled)

Aktiviert die automatische Aktualisierung der Namespace-Tabelle.

Wenn diese Option aktiviert ist, wird die lokale Kopie der Namespace-Tabelle automatisch aktualisiert. Bei einer Änderung des Arrays wird ein „ namespaceArrayUpdated “ ausgegeben. Mit „ isEnabled “ lässt sich festlegen, ob die automatische Aktualisierung aktiviert oder deaktiviert ist.

Auf dem Knoten des Servers wird ein Abonnement eingerichtet, um Änderungen zu verfolgen. Falls ein Server keine Abonnements unterstützt, funktioniert dies nicht und ` isNamespaceAutoupdateEnabled ` gibt ` false` zurück.

Siehe auch „ namespaceArray()“ und „ namespaceArrayUpdated()“.

void QOpcUaClient::setNamespaceAutoupdateInterval(int interval)

Legt das Intervall für das Abonnement der Namespace-Tabelle fest.

Das Abonnement kann vom Server angepasst werden.

interval Legt das Intervall in Millisekunden fest, in dem auf Änderungen geprüft wird. Der Standardwert ist einmal pro Sekunde.

Siehe auch namespaceAutoupdateInterval() und QOpcUaClient::setNamespaceAutoupdate(bool isEnabled).

[since QtOpcUa 5.13] void QOpcUaClient::setPkiConfiguration(const QOpcUaPkiConfiguration &config)

Legt die PKI-Konfiguration der Anwendung für diese „ QOpcUaClient “-Instanz auf „ config “ fest.

Diese Funktion wurde in QtOpcUa 5.13 eingeführt.

Siehe auch pkiConfiguration().

[since QtOpcUa 5.14] QStringList QOpcUaClient::supportedSecurityPolicies() const

Gibt die vom verwendeten Backend unterstützten Sicherheitsrichtlinien zurück.

Diese Funktion ist derzeit als Technology Preview verfügbar, daher können sich die von der Funktion bereitgestellte API und Funktionalität jederzeit ohne vorherige Ankündigung ändern.

Diese Funktion wurde in QtOpcUa 5.14 eingeführt.

[since QtOpcUa 5.14] QList<QOpcUaUserTokenPolicy::TokenType> QOpcUaClient::supportedUserTokenTypes() const

Gibt die vom verwendeten Backend unterstützten Benutzer-Token-Typen zurück.

Diese Funktion ist derzeit als Technology Preview verfügbar, daher können sich die von der Funktion bereitgestellte API und Funktionalität jederzeit ohne vorherige Ankündigung ändern.

Diese Funktion wurde in QtOpcUa 5.14 eingeführt.

Siehe auch QOpcUaUserTokenPolicy::TokenType.

[since 6.7] bool QOpcUaClient::unregisterNodes(const QStringList &nodesToUnregister)

Hebt die Registrierung der Knoten-IDs in „ nodesToUnregister “ auf dem Server auf und gibt „ true “ zurück, wenn die Anforderung erfolgreich versendet wurde. Die Ergebnisse werden über das Signal „ unregisterNodesFinished()“ zurückgegeben.

Die an ` nodesToUnregister ` zu übergebenden Knoten-IDs müssen zuvor über ` registerNodes()` abgerufen worden sein.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch ` registerNodes()`.

[signal, since 6.7] void QOpcUaClient::unregisterNodesFinished(const QStringList &nodesToUnregister, QOpcUa::UaStatusCode statusCode)

Dieses Signal wird ausgelöst, nachdem ein ` unregisterNodes()`-Vorgang abgeschlossen wurde. ` nodesToUnregister ` enthält die Knoten-IDs aus der Anfrage zu Korrelationszwecken. ` statusCode ` gibt an, ob der Vorgang erfolgreich war.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch ` unregisterNodes()`.

bool QOpcUaClient::updateNamespaceArray()

Fordert eine Aktualisierung des Namespace-Arrays vom Server an. Gibt „ true “ zurück, wenn der Vorgang erfolgreich ausgelöst wurde.

Das Signal „ namespaceArrayUpdated()“ wird ausgelöst, nachdem der Vorgang abgeschlossen ist.

Siehe auch „ namespaceArray()“ und „ namespaceArrayUpdated()“.

bool QOpcUaClient::writeNodeAttributes(const QList<QOpcUaWriteItem> &nodesToWrite)

Startet einen Schreibvorgang für mehrere Attribute auf verschiedenen Knoten. Für jeden Eintrag in „ nodesToWrite “ können die Knoten-ID, das Attribut, der Wert, der Werttyp und ein Indexbereich angegeben werden.

Gibt ` true ` zurück, wenn die asynchrone Anfrage erfolgreich versendet wurde. Die Ergebnisse werden über das Signal ` writeNodeAttributesFinished()` zurückgegeben.

Diese Schreibfunktion bietet eine alternative Möglichkeit zum Schreiben von Knotenattributen, die in Szenarien genutzt werden kann, in denen die Werte einer großen Anzahl von Knotenattributen auf verschiedenen Knoten geschrieben werden müssen, ohne dass die anderen Funktionen der auf „ QOpcUaNode “ basierenden API – wie die Überwachung von Wertänderungen – benötigt werden. Alle Schreibelemente in der Anfrage werden in einer einzigen Anfrage an den Server gesendet und in einer einzigen Antwort beantwortet, die ein einziges „ writeNodeAttributesFinished()“-Signal erzeugt. Dies reduziert den Netzwerk-Overhead und die Anzahl der Signal-Slot-Verbindungen, wenn viele verschiedene Knoten beteiligt sind.

Im folgenden Beispiel werden die „Values“-Attribute zweier verschiedener Knoten in einem einzigen Aufruf geschrieben. Der zweite Knoten verfügt über einen Array-Wert, von dem nur die ersten beiden Elemente überschrieben werden:

QList<QOpcUaWriteItem> request;

request.append(QOpcUaWriteItem("ns=2;s=Demo.Static.Scalar.Double", QOpcUa::NodeAttribute::Value,
                                  23.0, QOpcUa::Types::Double));
request.append(QOpcUaWriteItem("ns=2;s=Demo.Static.Arrays.UInt32", QOpcUa::NodeAttribute::Value,
                                  QVariantList({0, 1, 2}), QOpcUa::Types::UInt32, "0:2"));

m_client->writeNodeAttributes(request);

Siehe auch „ QOpcUaWriteItem “ und „ writeNodeAttributesFinished()“.

[signal] void QOpcUaClient::writeNodeAttributesFinished(QList<QOpcUaWriteResult> results, QOpcUa::UaStatusCode serviceResult)

Dieses Signal wird ausgelöst, nachdem ein writeNodeAttributes()-Vorgang abgeschlossen wurde.

Die Elemente in „ results “ haben dieselbe Reihenfolge wie die Elemente in der Schreibanforderung. Sie enthalten den Wert, die Zeitstempel und den vom Server empfangenen Statuscode sowie die Knoten-ID, das Attribut und den Indexbereich aus dem Schreibelement. Dies erleichtert den Abgleich des Ergebnisses mit der Anforderung.

serviceResult ist der Statuscode des OPC-UA-Schreibdienstes. Wenn „ serviceResult “ nicht „ Good “ lautet, weisen die Einträge in „ results “ ebenfalls einen ungültigen Statuscode auf und dürfen nicht verwendet werden.

Siehe auch „ writeNodeAttributes()“ und „ QOpcUaWriteResult “.