QOpcUaClient Class

Documentation des fonctions membres

[virtual noexcept] QOpcUaClient::~QOpcUaClient()

Supprime l'instance de ` QOpcUaClient `.

bool QOpcUaClient::addNode(const QOpcUaAddNodeItem &nodeToAdd)

Ajoute le nœud décrit par nodeToAdd sur le serveur.

Renvoie true si l'appel asynchrone a été envoyé avec succès.

La réussite de l'opération est renvoyée via le signal addNodeFinished().

L'exemple de code suivant ajoute un nouveau nœud « Variable » sur le serveur :

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);

Voir également deleteNode(), addNodeFinished() et QOpcUaAddNodeItem.

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

Ce signal est émis une fois l'opération addNode() terminée. requestedNodeId correspond à l'identifiant du nœud demandé lors de l'appel addNode(), tandis que assignedNodeId correspond à l'identifiant que le serveur a attribué au nouveau nœud. statusCode contient le résultat de l'opération. Si le résultat est Bad, assignedNodeId est vide et aucun nœud n'a été ajouté à l'espace d'adressage du serveur.

bool QOpcUaClient::addReference(const QOpcUaAddReferenceItem &referenceToAdd)

Ajoute au serveur la référence décrite par referenceToAdd.

Renvoie true si l'appel asynchrone a été envoyé avec succès.

La réussite de l'opération est renvoyée dans le signal addReferenceFinished().

L'exemple de code suivant ajoute une référence à un nœud dans le dossier « Objects » :

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);

Voir également deleteReference(), addReferenceFinished() et QOpcUaAddReferenceItem.

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

Ce signal est émis une fois l'opération addReference() terminée. sourceNodeId, referenceTypeId, targetNodeId et isForwardReference sont les valeurs issues de l'appel à la fonction addReference(). statusCode contient le résultat de l'opération.

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

Renvoie l'identité d'application de cette instance d'QOpcUaClient.

Cette fonction a été introduite dans QtOpcUa 5.13.

Voir aussi setApplicationIdentity().

const QOpcUaAuthenticationInformation &QOpcUaClient::authenticationInformation() const

Renvoie les informations d'authentification actuelles.

Voir également setAuthenticationInformation().

QString QOpcUaClient::backend() const

Renvoie le nom du backend utilisé par cette instance de QOpcUaClient, par exemple « open62541 ».

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

Ce signal est émis lorsqu'une erreur s'est produite lors de l'établissement de la connexion. Le paramètre ` errorState ` contient des informations sur l'erreur.

En cas d’erreurs côté client, celles-ci peuvent être ignorées en appelant la méthode QOpcUaErrorState::setIgnoreError sur l’objet.

Lors de l’exécution d’un slot connecté à ce signal, le backend est interrompu et attend que tous les slots se terminent. Cela permet d’afficher une boîte de dialogue demandant à l’utilisateur, par exemple, s’il souhaite faire confiance à un certificat inconnu avant que le backend ne reprenne son exécution.

Cette fonction a été introduite dans QtOpcUa 5.13.

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

Se connecte au point de terminaison OPC UA indiqué dans endpoint.

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

La liste des points de terminaison disponibles s'obtient généralement en appelant la fonction ` QOpcUaClient::requestEndpoints()`.

Si le point de terminaison nécessite une authentification par nom d'utilisateur, au moins un nom d'utilisateur doit être défini dans QOpcUaAuthenticationInformation. L'appel de cette fonction avant la définition d'informations d'authentification entraînera l'utilisation de l'authentification anonyme.

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

client->setAuthenticationInformation(authInfo);

Cette fonction a été introduite dans QtOpcUa 5.13.

Voir également connected(), stateChanged(), setAuthenticationInformation() et QOpcUaEndpointDescription.

[signal] void QOpcUaClient::connected()

Ce signal est émis lorsqu'une connexion a été établie.

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

Renvoie les paramètres de connexion de ce client.

Cette fonction a été introduite dans Qt 6.6.

Voir également setConnectionSettings().

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

Supprime du serveur le nœud dont l'identifiant est nodeId. Si deleteTargetReferences vaut false, seules les références dont le nœud source est nodeId sont supprimées. Si deleteTargetReferences vaut true, les références dont la cible est nodeId sont également supprimées.

Renvoie « true » si l’appel asynchrone a été dispatché avec succès.

La réussite de l’opération est signalée via le signal deleteNodeFinished().

L'exemple de code suivant supprime un nœud et toutes les références à celui-ci du serveur :

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

Voir également addNode() et deleteNodeFinished().

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

Ce signal est émis une fois l'opération deleteNode() terminée. nodeId correspond à l'identifiant du nœud issu de l'appel deleteNode(). statusCode contient le résultat de l'opération.

bool QOpcUaClient::deleteReference(const QOpcUaDeleteReferenceItem &referenceToDelete)

Supprime du serveur la référence décrite par referenceToDelete.

Renvoie true si l'appel asynchrone a été correctement déclenché.

La réussite de l'opération est signalée via le signal deleteReferenceFinished().

L'exemple de code suivant supprime une référence à un nœud du dossier « 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);

Voir également addReference(), deleteReferenceFinished() et QOpcUaDeleteReferenceItem.

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

Ce signal est émis une fois l'opération deleteReference() terminée. sourceNodeId, referenceTypeId, targetNodeId et isForwardReference correspondent aux valeurs renvoyées par l'appel à la fonction deleteReference(). statusCode contient le résultat de l'opération.

[invokable] void QOpcUaClient::disconnectFromEndpoint()

Se déconnecte du serveur.

Voir également disconnected() et connectToEndpoint().

[signal] void QOpcUaClient::disconnected()

Ce signal est émis lorsqu'une connexion a été fermée à la suite d'une demande de fermeture.

QOpcUaEndpointDescription QOpcUaClient::endpoint() const

Renvoie la description du point de terminaison auquel le client est actuellement connecté ou auquel il était connecté en dernier.

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

Ce signal est émis une fois l'opération ` requestEndpoints()` terminée. ` statusCode ` contient le résultat de l'opération. Si le résultat est ` Good`, ` endpoints ` contient les descriptions de tous les points de terminaison disponibles sur le serveur. ` requestUrl ` contient l'URL utilisée dans l'appel ` requestEndpoints()`.

QOpcUaClient::ClientError QOpcUaClient::error() const

Renvoie l'état d'erreur actuel du client.

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

Lance une requête FindServers asynchrone pour lire une liste de serveurs connus à partir d'un serveur ou d'un serveur de découverte à l'adresse url. Renvoie la valeur « true » si l'appel asynchrone a été envoyé avec succès.

localeIds Peut être utilisé pour sélectionner la langue des noms d’applications renvoyés par la requête. Le format est spécifié dans la norme OPC UA 1.05, partie 3, section 8.4 ; par exemple « en » pour l’anglais ou « de-DE » pour l’allemand (Allemagne). Si plusieurs identifiants de paramètres régionaux sont spécifiés, le serveur utilise la première correspondance. S’il n’y a pas de correspondance ou si localeIds est vide, le serveur choisit des paramètres régionaux par défaut.

serverUris peut être utilisé pour limiter les résultats aux serveurs dont la description d’application contient un applicationUri correspondant. Par exemple, pour trouver l’URL actuelle du serveur dont l’applicationUri est « MyPLC », l’appel suivant peut être utilisé :

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

Les résultats sont renvoyés dans le signal findServersFinished().

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

Ce signal est émis une fois l'opération findServers() terminée. La variable statusCode contient le résultat de l'opération. Si le résultat est Good, la variable servers contient les descriptions d'application de tous les serveurs connus du serveur interrogé et répondant aux critères de filtrage. La variable requestUrl contient l'URL utilisée dans l'appel findServers().

bool QOpcUaClient::isNamespaceAutoupdateEnabled() const

Indique si la mise à jour automatique du tableau des espaces de noms est activée.

QStringList QOpcUaClient::namespaceArray() const

Renvoie la valeur mise en cache du tableau des espaces de noms.

Cette valeur n'est valide qu'après l'émission du signal namespaceArrayUpdated().

Voir également updateNamespaceArray() et namespaceArrayUpdated().

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

Ce signal est émis lorsque le tableau des espaces de noms a été modifié. ` namespaces ` contient le contenu de la table des espaces de noms du serveur. L'index d'une entrée dans ` namespaces ` correspond à l'index de l'espace de noms utilisé dans l'identifiant du nœud.

Voir également namespaceArrayUpdated() et updateNamespaceArray().

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

Ce signal est émis une fois l'opération « updateNamespaceArray » terminée. Le paramètre « namespaces » contient le contenu de la table des espaces de noms du serveur. L'index d'une entrée dans « namespaces » correspond à l'index de l'espace de noms utilisé dans l'identifiant du nœud.

Si le contenu du tableau d'espaces de noms reste inchangé après la mise à jour, ce signal est néanmoins émis.

Voir également namespaceArrayChanged() et updateNamespaceArray().

int QOpcUaClient::namespaceAutoupdateInterval() const

Renvoie l'intervalle de mise à jour révisé actuel du tableau d'espaces de noms.

Voir également setNamespaceAutoupdateInterval(int interval).

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

Renvoie un objet « QOpcUaNode » associé au nœud OPC UA identifié par expandedNodeId. L'appelant devient propriétaire de l'objet nœud.

Si le nœud ne se trouve pas sur le serveur actuellement connecté, si l'espace de noms ne peut pas être résolu, si l'identifiant du nœud est incorrect ou si le client n'est pas connecté, la fonction renvoie nullptr.

Voir également updateNamespaceArray().

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

Renvoie un objet ` QOpcUaNode ` associé au nœud OPC UA identifié par ` nodeId`. L'appelant devient propriétaire de l'objet nœud.

Si le client n'est pas connecté, la valeur « nullptr » est renvoyée. Les backends peuvent également renvoyer « nullptr » dans d'autres cas d'erreur (par exemple, en cas d'identifiant de nœud mal formé).

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

Ce signal est émis lorsqu'un mot de passe est requis pour une clé privée chiffrée. Le paramètre keyFilePath contient le chemin d'accès au fichier de la clé utilisée. Le paramètre previousTryWasInvalid est à « true » si une tentative précédente de déchiffrement de la clé a échoué (c'est-à-dire en cas de mot de passe invalide). Le paramètre password pointe vers un objet de type « QString » qui doit être renseigné avec le mot de passe effectif de la clé. Si la tentative précédente a échoué, il contient le mot de passe utilisé précédemment.

Lors de l'exécution d'un slot connecté à ce signal, le backend est suspendu et attend que tous les slots reviennent. Cela permet d'afficher une boîte de dialogue pour demander le mot de passe à l'utilisateur final.

Cette fonction a été introduite dans QtOpcUa 5.13.

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

Renvoie la configuration PKI de l'application pour cette instance d'QOpcUaClient.

Cette fonction a été introduite dans QtOpcUa 5.13.

Voir également setPkiConfiguration().

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

Tente de créer un nom qualifié à partir de namespaceUri et de la chaîne de caractères name. Renvoie le nom qualifié obtenu. Un nom qualifié vide est renvoyé si namespaceUri ne peut pas être résolu.

ok sera défini sur true si la résolution de l'URI de l'espace de noms a abouti. Si l'URI de l'espace de noms n'a pas pu être résolu, ok sera défini sur false.

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

Lance une requête de lecture de l'historique brut ( request ) pour un ou plusieurs nœuds. Il s'agit de la représentation « Qt OPC UA » du service OPC UA « ReadHistory », destiné à la lecture des données historiques brutes définies dans la norme OPC UA 1.05, partie 4, section 5.10.3.

L'horodatage de début, l'horodatage de fin, le nombre de valeurs par nœud, les limites de retour (returnBounds) et les nœuds à lire peuvent être spécifiés dans une requête « QOpcUaHistoryReadRawRequest ».

Renvoie un objet ` QOpcUaHistoryReadResponse ` contenant l’état de la requête si la requête asynchrone a été envoyée avec succès. Les résultats sont renvoyés via le signal ` QOpcUaHistoryReadResponse::readHistoryDataFinished` (const QList<QOpcUaHistoryData> &results, QOpcUa::UaStatusCode serviceResult).

Dans l’exemple suivant, les données historiques des deux derniers jours de deux nœuds sont demandées et affichées. Le résultat est limité à dix valeurs par nœud.

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> résultats, QOpcUa::UaStatusCode résultatService) {
                        if (résultatService != 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();
                            }
                        }
                    });
}

Cette fonction a été introduite dans Qt 6.3.

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

Lance une requête d'historique des événements de lecture pour un ou plusieurs identifiants de nœuds, à l'aide des paramètres indiqués dans request.

Renvoie un objet ` QOpcUaHistoryReadResponse ` contenant l’état de la requête si celle-ci a été envoyée avec succès de manière asynchrone. Les résultats sont renvoyés via le signal ` QOpcUaHistoryReadResponse::readHistoryEventsFinished` (const QList<QOpcUaHistoryEvent> &results, QOpcUa::UaStatusCode serviceResult).

L'exemple suivant récupère l'historique des événements des deux derniers jours pour deux nœuds. Jusqu’à 10 événements par nœud sont renvoyés à la fois. Tant qu’il existe d’autres événements correspondant au filtre et à la plage de temps fournie, hasMoreData() sera vrai et d’autres événements pourront être récupérés via readMoreData().

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);

// L'objet de réponse doit être libéré par l'utilisateur une fois toutes les données souhaitées récupérées
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;
    }

    // Afficher ce que nous avons obtenu jusqu'à présent
    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();
});

Cette fonction a été introduite dans Qt 6.7.

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

Lance une lecture de plusieurs attributs sur différents nœuds. L'identifiant du nœud, l'attribut et une plage d'index peuvent être spécifiés pour chaque entrée dans ` nodesToRead`.

Renvoie « true » si la requête asynchrone a été envoyée avec succès. Les résultats sont renvoyés via le signal readNodeAttributesFinished().

Cette fonction de lecture offre une alternative pour lire les attributs des nœuds ; elle peut être utilisée dans des scénarios où il est nécessaire de lire les valeurs d’un grand nombre d’attributs de nœuds sur différents nœuds sans avoir recours aux autres fonctionnalités de l’API basée sur ` QOpcUaNode `, telles que la surveillance des changements de valeurs. Tous les éléments à lire dans la requête sont envoyés au serveur en une seule requête et font l’objet d’une réponse unique qui génère un seul signal ` readNodeAttributesFinished()`. Cela réduit la charge réseau et le nombre de connexions de slots de signal lorsque de nombreux nœuds différents sont impliqués.

Dans l’exemple suivant, l’attribut « display name » et les deux plages d’index « 0:2 » et « 5:7 » de l’attribut « value » d’un même nœud, ainsi que l’intégralité de l’attribut « value » d’un deuxième nœud, sont lus à l’aide d’un seul appel de service :

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);

Voir également QOpcUaReadItem et readNodeAttributesFinished().

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

Ce signal est émis une fois l'opération readNodeAttributes() terminée.

Les éléments contenus dans ` results ` suivent le même ordre que ceux de la requête. Pour chaque élément demandé, ` results` contient une valeur accompagnée d’horodatages et du code d’état. ` serviceResult ` contient le code d’état renvoyé par le service de lecture OPC UA.

Voir également readNodeAttributes(), QOpcUaReadResult et QOpcUaReadItem.

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

Enregistre les identifiants de nœuds dans ` nodesToRegister ` sur le serveur et renvoie ` true ` si la requête a bien été transmise. Les résultats sont renvoyés via le signal ` registerNodesFinished()`.

Le service d'enregistrement des nœuds sert à signaler au serveur qu'un nœud sera fréquemment consulté, afin qu'il puisse effectuer des opérations telles que le maintien d'une connexion ouverte vers une ressource externe. Le serveur peut également renvoyer un identifiant de nœud alias, qu’il est recommandé de choisir numérique. Cela peut s’avérer utile si un nœud doté d’un identifiant sous forme de longue chaîne de caractères est utilisé dans de nombreuses requêtes. Le gain de performance réel (le cas échéant) dépend de l’implémentation du serveur.

La validité des identifiants de nœuds enregistrés n’est garantie que pour la session en cours. Tout enregistrement qui n’est plus nécessaire doit être supprimé dès que possible afin que le serveur puisse libérer les ressources associées.

Cette fonction a été introduite dans Qt 6.7.

Voir également ` unregisterNodes()`.

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

Ce signal est émis une fois l'opération ` registerNodes()` terminée. ` nodesToRegister ` contient les identifiants de nœuds issus de la requête, à des fins de corrélation. Les identifiants de nœuds renvoyés par le serveur se trouvent dans ` registeredNodeIds ` et suivent le même ordre que les identifiants de la requête. ` statusCode ` indique si l'opération a abouti.

Cette fonction a été introduite dans Qt 6.7.

Voir également registerNodes().

bool QOpcUaClient::requestEndpoints(const QUrl &url)

Lance une requête asynchrone GetEndpoints pour lire la liste des points de terminaison disponibles sur le serveur à l'adresse url. Renvoie true si l'appel asynchrone a bien été envoyé.

Les informations relatives aux points de terminaison sont renvoyées dans le signal endpointsRequestFinished().

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

Tente de résoudre expandedNodeId en une chaîne d'identifiant de nœud comportant un index d'espace de noms numérique. Renvoie la chaîne d'identifiant de nœud si la conversion a réussi.

Une chaîne vide est renvoyée si l'index de l'espace de noms ne peut pas être résolu ou si la partie « identifiant » de l'identifiant de nœud développé est mal formée. ok sera défini sur true si la conversion a réussi. Si l'identifiant de nœud développé n'a pas pu être résolu, ok sera défini sur false.

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

Définit l'identité de l'application pour cette instance d'QOpcUaClient sur identity.

Cette fonction a été introduite dans QtOpcUa 5.13.

Voir également applicationIdentity().

void QOpcUaClient::setAuthenticationInformation(const QOpcUaAuthenticationInformation &authenticationInformation)

Définit les informations d'authentification de ce client sur authenticationInformation.

Voir également authenticationInformation() et connectToEndpoint().

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

Définit les paramètres de connexion de ce client sur connectionSettings.

Exemple :

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);

Les valeurs provenant de connectionSettings sont appliquées à toutes les nouvelles connexions établies à partir de ce moment.

Le plugin open62541 prend en charge la mise à jour des identifiants de paramètres régionaux de session pour la connexion en cours. Toutes les autres valeurs modifiées mais ne pouvant pas être mises à jour pendant la connexion génèrent un message d’avertissement et seront appliquées lors du prochain appel à la fonction ` connectToEndpoint()`.

Cette fonction a été introduite dans Qt 6.6.

Voir également connectionSettings().

void QOpcUaClient::setNamespaceAutoupdate(bool isEnabled)

Active la mise à jour automatique de la table des espaces de noms.

L'activation de cette option permettra de mettre à jour automatiquement la copie locale de la table des espaces de noms. Un événement « namespaceArrayUpdated » sera émis lorsque le tableau sera modifié. La variable « isEnabled » détermine si la mise à jour automatique est activée ou désactivée.

Un abonnement sera créé sur le nœud du serveur afin de suivre les modifications. Si un serveur ne prend pas en charge les abonnements, cette fonctionnalité ne fonctionnera pas et la méthode ` isNamespaceAutoupdateEnabled ` renverra la valeur ` false`.

Voir également namespaceArray() et namespaceArrayUpdated().

void QOpcUaClient::setNamespaceAutoupdateInterval(int interval)

Définit l'intervalle de l'abonnement à la table d'espaces de noms.

L'abonnement peut être modifié par le serveur.

interval Détermine l’intervalle de vérification des modifications, en millisecondes. La valeur par défaut est d’une fois par seconde.

Voir également namespaceAutoupdateInterval() et QOpcUaClient::setNamespaceAutoupdate(bool isEnabled).

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

Définit la configuration PKI de l'application pour cette instance d'QOpcUaClient sur config.

Cette fonction a été introduite dans QtOpcUa 5.13.

Voir également pkiConfiguration().

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

Renvoie les politiques de sécurité prises en charge par le backend utilisé.

Cette fonction est actuellement disponible en avant-première technologique ; par conséquent, l'API et les fonctionnalités fournies par cette fonction sont susceptibles d'être modifiées à tout moment sans préavis.

Cette fonction a été introduite dans QtOpcUa 5.14.

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

Renvoie les types de jetons utilisateur pris en charge par le backend utilisé.

Cette fonction est actuellement disponible en avant-première technologique ; par conséquent, l'API et les fonctionnalités fournies par cette fonction sont susceptibles d'être modifiées à tout moment sans préavis.

Cette fonction a été introduite dans QtOpcUa 5.14.

Voir également QOpcUaUserTokenPolicy::TokenType.

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

Désenregistre les identifiants de nœuds dans ` nodesToUnregister ` sur le serveur et renvoie ` true ` si la requête a bien été traitée. Les résultats sont renvoyés via le signal ` unregisterNodesFinished()`.

Les identifiants de nœuds à passer dans ` nodesToUnregister ` doivent avoir été obtenus via ` registerNodes()`.

Cette fonction a été introduite dans Qt 6.7.

Voir également registerNodes().

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

Ce signal est émis une fois l'opération ` unregisterNodes()` terminée. ` nodesToUnregister ` contient les identifiants des nœuds issus de la requête, à des fins de corrélation. ` statusCode ` indique si l'opération a abouti.

Cette fonction a été introduite dans Qt 6.7.

Voir également unregisterNodes().

bool QOpcUaClient::updateNamespaceArray()

Demande au serveur une mise à jour du tableau des espaces de noms. Renvoie true si l'opération a été envoyée avec succès.

Le signal namespaceArrayUpdated() est émis une fois l'opération terminée.

Voir également ` namespaceArray()` et ` namespaceArrayUpdated()`.

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

Lance une opération d'écriture portant sur plusieurs attributs dans différents nœuds. L'identifiant du nœud, l'attribut, la valeur, le type de valeur et une plage d'index peuvent être spécifiés pour chaque entrée de nodesToWrite.

Renvoie ` true ` si la requête asynchrone a été envoyée avec succès. Les résultats sont renvoyés via le signal ` writeNodeAttributesFinished()`.

Cette fonction d’écriture offre une méthode alternative pour écrire les attributs des nœuds ; elle peut être utilisée dans les cas où les valeurs d’un grand nombre d’attributs de nœuds sur différents nœuds doivent être écrites sans avoir recours aux autres fonctionnalités de l’API basée sur QOpcUaNode, telles que la surveillance des changements de valeur. Tous les éléments d’écriture de la requête sont envoyés au serveur en une seule requête et font l’objet d’une réponse unique qui génère un seul signal ` writeNodeAttributesFinished()`. Cela réduit la charge réseau et le nombre de connexions de slots de signal lorsque de nombreux nœuds différents sont impliqués.

Dans l’exemple suivant, les attributs « Values » de deux nœuds différents sont écrits en un seul appel. Le deuxième nœud possède une valeur de type tableau dont seuls les deux premiers éléments sont écrasés :

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);

Voir également QOpcUaWriteItem et writeNodeAttributesFinished().

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

Ce signal est émis une fois l'opération writeNodeAttributes() terminée.

Les éléments de results suivent le même ordre que ceux de la requête d'écriture. Ils contiennent la valeur, les horodatages et le code d'état reçus du serveur, ainsi que l'identifiant du nœud, l'attribut et la plage d'index de l'élément d'écriture. Cela facilite la mise en correspondance du résultat avec la requête.

serviceResult est le code d'état du service d'écriture OPC UA. Si serviceResult n'est pas Good, les entrées de results comportent également un code d'état invalide et ne doivent pas être utilisées.

Voir également writeNodeAttributes() et QOpcUaWriteResult.