Connection QML Type

Stellt eine Verbindung zu einem Server her. Mehr...

Dieser Typ ist seit QtOpcUa 6.9 veraltet. Wir raten dringend davon ab, ihn in neuem Code zu verwenden.

• Liste aller Mitglieder, einschließlich geerbter Mitglieder

Eigenschaften

• authenticationInformation : AuthenticationInformation
• availableBackends : stringlist
• backend : string
• connected : bool
• connection : QOpcUaClient
• currentEndpoint : QOpcUaEndpointDescription
• defaultConnection : bool
• namespaces : stringlist
• supportedSecurityPolicies : stringlist
• supportedUserTokenTypes : array[tokenTypes]

Signale

• nodeChanged()
• readNodeAttributesFinished(readResults)
• writeNodeAttributesFinished(writeResults)

Methoden

• void connectToEndpoint(endpointDescription)
• void disconnectFromEndpoint()
• bool readNodeAttributes(valuesToBeRead)
• bool writeNodeAttributes(valuesToBeWritten)

Ausführliche Beschreibung

Die Haupt-API nutzt Backends, um Verbindungen herzustellen. Sie müssen das Backend vor jedem Verbindungsversuch festlegen.

import QtOpcUa as QtOpcUa

QtOpcUa.Connection {
    backend: "open62541"
}

Component.onCompleted: {
    connection.connectToEndpoint("opc.tcp://127.0.0.1:43344");
}

Dokumentation zu den Eigenschaften

authenticationInformation : AuthenticationInformation

Legen Sie die Authentifizierungsdaten für diese Verbindung fest. Die Authentifizierungsdaten müssen vor dem Aufruf von ` connectToEndpoint` festgelegt werden. Wenn keine Authentifizierungsdaten festgelegt sind, wird der anonyme Modus verwendet. Dies hat keine Auswirkungen auf die aktuelle Verbindung. Wenn die Verbindung zum Client getrennt und anschließend wiederhergestellt wird, werden die neuen Anmeldedaten verwendet. Wird diese Eigenschaft vor dem Festlegen von „ backend “ gelesen oder geschrieben, werden Schreibvorgänge ignoriert und beim Lesen wird der ungültige Wert „ AuthenticationInformation “ zurückgegeben.

availableBackends : stringlist [read-only]

Gibt die Namen aller verfügbaren Backends als Liste zurück. Diese werden bei der Verbindungsherstellung zur Auswahl eines Backends verwendet.

Siehe auch Connection::backend.

backend : string

Legen Sie das Backend fest, das für eine Verbindung zum Server verwendet werden soll. Dies muss vor jedem Verbindungsversuch erfolgen.

Siehe auch Connection::availableBackends.

connected : bool [read-only]

Status der Verbindung. true, wenn eine Verbindung besteht, andernfalls false.

connection : QOpcUaClient

Diese Eigenschaft dient ausschließlich dazu, eine Verbindung aus C++ einzubinden. Bei einer komplexen Konfiguration einer Verbindung können Sie alle Details über C++ abwickeln. Sobald die Verbindung hergestellt ist, kann sie über diese Eigenschaft an QML übergeben werden. Die Verantwortung für den Client wird an QML übertragen.

class MyClass : public QObject {
    Q_OBJECT
    Q_PROPERTY(QOpcUaClient* connection READ connection NOTIFY connectionChanged)

public:
    MyClass (QObject* parent = nullptr);
    QOpcUaClient *connection() const;

signals:
    void connectionChanged(QOpcUaClient *);

Durch das Auslösen des Signals „ connectionChanged “, sobald die Einrichtung des Clients abgeschlossen ist, wird die Verbindung vom folgenden QML-Code verwendet.

import QtOpcUa as QtOpcUa

MyClass {
    id: myclass
}

QtOpcUa.Connection {
    connection: myclass.connection
 }

currentEndpoint : QOpcUaEndpointDescription

Eine Endpunktbeschreibung des Servers, mit dem die Verbindung hergestellt wurde. Wenn keine Verbindung besteht, wird eine leere Endpunktbeschreibung zurückgegeben.

defaultConnection : bool

Legt diese Verbindung als Standardverbindung fest. Normalerweise muss jedem Knoten eine Verbindung zugewiesen werden, die er verwenden soll. Wenn diese Eigenschaft auf „ true “ gesetzt ist, wird diese Verbindung in allen Fällen verwendet, in denen für einen Knoten keine Verbindung festgelegt ist. Bereits hergestellte Verbindungen sind davon nicht betroffen. Wenn „ defaultConnection “ bei mehreren Verbindungen auf „ true “ gesetzt ist, wird die letzte Verbindung verwendet.

QtOpcUa.Connection {
    ...
    defaultConnection: true
    ...
}

Siehe auch Node.

namespaces : stringlist [read-only]

Liste aller Zeichenfolgen der auf dem verbundenen Server registrierten Namespace-URIs.

supportedSecurityPolicies : stringlist

Eine Liste von Zeichenketten, die die unterstützten Sicherheitsrichtlinien enthalten

Diese Eigenschaft ist derzeit als Technology Preview verfügbar; daher können sich die bereitgestellte API und die Funktionen jederzeit ohne vorherige Ankündigung ändern.

supportedUserTokenTypes : array[tokenTypes]

Ein Array mit den Richtlinienarten für alle unterstützten Benutzertoken-Typen.

Diese Eigenschaft ist derzeit als Technology Preview verfügbar; daher können sich die bereitgestellte API und die Funktionen jederzeit ohne vorherige Ankündigung ändern.

Signal-Dokumentation

nodeChanged()

Wird ausgelöst, wenn sich der zugrunde liegende Knoten geändert hat. Dies geschieht, wenn sich der Namensraum oder die Kennung von NodeId geändert hat.

readNodeAttributesFinished(readResults)

Wird ausgelöst, wenn die mit ` readNodeAttributes()` gestartete Leseanforderung abgeschlossen ist. Der Parameter ` readResults ` ist ein Array aus ` ReadResult `-Einträgen, das die vom Server angeforderten Werte enthält.

connection.onReadNodeAttributesFinished(results) {
    for (var i = 0; results.length; i++) {
        if (results[i].status.isGood) {
            console.log(results[i].value);
        } else {
            // handle error
        }
    }
}

Siehe auch readNodeAttributes() und ReadResult.

writeNodeAttributesFinished(writeResults)

Wird ausgelöst, wenn der mit ` writeNodeAttributes()` gestartete Schreibvorgang abgeschlossen ist. Der Parameter ` writeResults ` ist ein Array aus ` WriteResult `-Einträgen, das die vom Server angeforderten Werte enthält.

for (var i = 0; i < writeResults.length; i++) {
    console.log(writeResults[i].nodeId);
    console.log(writeResults[i].namespaceName);
    console.log(writeResults[i].attribute);

    if (writeResults[i].status.isBad) {
        // value was not written
    }
}

Siehe auch ` writeNodeAttributes()` und ` WriteResult`.

Methodendokumentation

void connectToEndpoint(endpointDescription)

Stellt eine Verbindung zu dem Endpunkt her, der mit „ endpointDescription “ angegeben wurde.

Siehe auch EndpointDescription.

void disconnectFromEndpoint()

Trennt eine bestehende Verbindung.

bool readNodeAttributes(valuesToBeRead)

Diese Funktion dient dazu, mehrere Werte auf einmal von einem Server abzurufen. Gibt „ true “ zurück, wenn die Leseanfrage erfolgreich übermittelt wurde.

Der Parameter „ valuesToBeRead “ muss ein JavaScript-Array mit Einträgen vom Typ „ ReadItem “ sein.

// List of items to read
var readItemList = [];
// Item to be added to the list of items to be read
var readItem;

// Prepare an item to be read

// Create a new read item and fill properties
readItem = QtOpcUa.ReadItem.create();
readItem.ns = "http://qt-project.org";
readItem.nodeId = "s=Demo.Static.Scalar.Double";
readItem.attribute = QtOpcUa.Constants.NodeAttribute.DisplayName;

// Add the prepared item to the list of items to be read
readItemList.push(readItem);

// Add further items
[...]

if (!connection.readNodeAttributes(readItemList)) {
    // handle error
}

Das Ergebnis der Leseanfrage wird über das Signal „ readNodeAttributesFinished()“ bereitgestellt.

Siehe auch „ readNodeAttributesFinished()“ und „ ReadItem “.

bool writeNodeAttributes(valuesToBeWritten)

Diese Funktion dient dazu, mehrere Werte auf einmal an einen Server zu schreiben. Gibt „ true “ zurück, wenn die Schreibanforderung erfolgreich versendet wurde.

Der Parameter „ valuesToBeWritten “ muss ein JavaScript-Array mit Einträgen vom Typ „ WriteItem “ sein.

// List of items to write
var writeItemList = [];
// Item to be added to the list of items to be written
var writeItem;

// Prepare an item to be written

// Create a new write item and fill properties
writeItem = QtOpcUa.WriteItem.create();
writeItem.ns = "http://qt-project.org";
writeItem.nodeId = "s=Demo.Static.Scalar.Double";
writeItem.attribute = QtOpcUa.Constants.NodeAttribute.Value;
writeItem.value = 32.1;
writeItem.valueType = QtOpcUa.Constants.Double;

// Add the prepared item to the list of items to be written
writeItemList.push(writeItem);

// Add further items
[...]

if (!connection.writeNodeAttributes(writeItemList)) {
    // handle error
}

Das Ergebnis der Schreibanforderung wird über das Signal „ Connection::writeNodeAttributesFinished()“ bereitgestellt.

Siehe auch „ Connection::writeNodeAttributesFinished()“ und „ WriteItem “.