QOpcUaClient Class

Member Function Documentation

[virtual noexcept] QOpcUaClient::~QOpcUaClient()

Détruit l'instance 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.

Le succès de l'opération est renvoyé dans 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 aussi deleteNode(), addNodeFinished() et QOpcUaAddNodeItem.

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

Ce signal est émis après la fin d'une opération addNode(). requestedNodeId est l'identifiant de nœud demandé lors de l'appel addNode(), assignedNodeId est l'identifiant de nœud 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 la référence décrite par referenceToAdd au serveur.

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

Le succès de l'opération est renvoyé 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 après la fin d'une opération addReference(). sourceNodeId Les valeurs de l'appel à addReference() sont referenceTypeId, targetNodeId et isForwardReference. statusCode contient le résultat de l'opération.

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

Renvoie l'identité de l'application de cette instance 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 aussi 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 QOpcUaErrorState::setIgnoreError sur l'objet.

Pendant l'exécution d'un slot connecté à ce signal, le backend est arrêté et attend que tous les slots reviennent. Cela permet d'afficher une boîte de dialogue pour demander à l'utilisateur final, par exemple, s'il doit faire confiance à un certificat inconnu avant que le backend ne continue.

Cette fonction a été introduite dans QtOpcUa 5.13.

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

Se connecte au point d'accès OPC UA indiqué dans endpoint.

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

Une liste des points de terminaison disponibles est généralement obtenue en appelant QOpcUaClient::requestEndpoints().

Si le point d'accès 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'une information d'authentification utilisera l'authentification anonyme.

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

client->setAuthenticationInformation(authInfo);

Cette fonction a été introduite dans QtOpcUa 5.13.

Voir aussi 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 pour ce client.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi setConnectionSettings().

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

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

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

Le succès de l'opération est renvoyé par le signal deleteNodeFinished().

L'exemple de code suivant supprime un nœud et toutes les références à ce nœud sur le 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 après la fin d'une opération deleteNode(). nodeId est l'identifiant du nœud provenant 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é envoyé avec succès.

Le succès de l'opération est renvoyé dans 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 après la fin de l'opération deleteReference(). sourceNodeId Les valeurs de l'appel à deleteReference() sont referenceTypeId, targetNodeId et isForwardReference. 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 d'accès auquel le client est actuellement connecté ou auquel il a été connecté pour la dernière fois.

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

Ce signal est émis après la fin d'une opération requestEndpoints(). statusCode contient le résultat de l'opération. Si le résultat est Good, endpoints contient les descriptions de tous les points d'extrémité 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 asynchrone FindServers pour lire une liste de serveurs connus à partir d'un serveur ou d'un serveur de découverte à l'adresse url. Renvoie true si l'appel asynchrone a été envoyé avec succès.

localeIds peut être utilisé pour sélectionner la langue des noms d'application renvoyés par la requête. Le format est spécifié dans OPC UA 1.05 partie 3, 8.4, par exemple "en" pour l'anglais, ou "de-DE" pour l'allemand (Allemagne). Si plus d'un identifiant de locale est spécifié, le serveur utilise la première correspondance. S'il n'y a pas de correspondance ou si localeIds est vide, le serveur choisit une locale par défaut.

serverUris peut être utilisé pour restreindre les résultats aux serveurs dont la description contient une applicationUri correspondante. Par exemple, pour trouver l'URL actuelle du serveur avec l'applicationUri "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 à la fin de l'opération findServers(). statusCode contient le résultat de l'opération. Si le résultat est Good, servers contient les descriptions d'application de tous les serveurs connus du serveur interrogé qui correspondent aux critères de filtrage. requestUrl contient l'URL qui a été utilisée dans l'appel findServers().

bool QOpcUaClient::isNamespaceAutoupdateEnabled() const

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

QStringList QOpcUaClient::namespaceArray() const

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

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

Voir aussi updateNamespaceArray() et namespaceArrayUpdated().

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

Ce signal est émis après que le tableau des espaces de noms a changé. 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 noeud.

Voir aussi namespaceArrayUpdated() et updateNamespaceArray().

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

Ce signal est émis après la fin de l'opération updateNamespaceArray. 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 des espaces de noms reste le même après la mise à jour, ce signal est néanmoins émis.

Voir aussi namespaceArrayChanged() et updateNamespaceArray().

int QOpcUaClient::namespaceAutoupdateInterval() const

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

Voir aussi 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 node.

Si le nœud n'est pas sur le serveur actuellement connecté, si l'espace de noms ne peut pas être résolu, si l'identifiant du nœud est malformé ou si le client n'est pas connecté, nullptr est renvoyé.

Voir aussi 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 node.

Si le client n'est pas connecté, nullptr est renvoyé. Les backends peuvent également renvoyer nullptr pour d'autres cas d'erreur (par exemple pour un identifiant de nœud malformé).

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

Ce signal est émis lorsqu'un mot de passe pour une clé privée cryptée est requis. Le paramètre keyFilePath contient le chemin d'accès à la clé utilisée. Le paramètre previousTryWasInvalid est vrai si une tentative précédente de décryptage de la clé a échoué (mot de passe invalide). Le paramètre password pointe vers un QString qui doit être rempli avec le mot de passe réel de la clé. Si la tentative précédente a échoué, il contient le mot de passe utilisé précédemment.

Pendant l'exécution d'un slot connecté à ce signal, le backend est arrêté et attend que tous les slots reviennent. Cela permet d'ouvrir 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 de l'ICP de l'application de cette instance QOpcUaClient.

Cette fonction a été introduite dans QtOpcUa 5.13.

Voir aussi 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é résultant. Un nom qualifié vide est renvoyé si namespaceUri ne peut pas être résolu.

ok sera défini à true si la résolution de l'URI de l'espace de noms a été effectuée avec succès. Si l'URI de l'espace de noms n'a pas pu être résolu, ok sera remplacé par false.

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

Lance une 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 de lecture de données historiques brutes défini dans OPC UA 1.05 partie 4, 5.10.3.

Les dates de début et de fin, le nombre de valeurs par nœud, les limites de retour et les nœuds à lire peuvent être spécifiés dans une page QOpcUaHistoryReadRawRequest.

Renvoie une adresse QOpcUaHistoryReadResponse qui contient l'état de la demande si la demande asynchrone a été envoyée avec succès. Les résultats sont renvoyés dans 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 imprimées. Le résultat est limité à dix valeurs par nœud.

QOpcUaHistoryReadRawRequest request( { QOpcUaReadItem("ns=1;s=maValeur1"), 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> results, 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();
                            } } }) ; }

Cette fonction a été introduite dans Qt 6.3.

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

Lance une demande de lecture de l'historique des événements pour un ou plusieurs identifiants de nœuds avec les paramètres indiqués dans request.

Renvoie une adresse QOpcUaHistoryReadResponse qui contient l'état de la demande si la demande asynchrone a été envoyée avec succès. Les résultats sont renvoyés dans le signal QOpcUaHistoryReadResponse::readHistoryEventsFinished(const QList<QOpcUaHistoryEvent> &results, QOpcUa::UaStatusCode serviceResult).

L'exemple suivant permet de récupérer les événements historiques des deux derniers jours pour deux nœuds. Jusqu'à 10 événements par nœud sont renvoyés à la fois. S'il y a plus d'événements correspondant au filtre et à l'intervalle de temps fourni, hasMoreData() sera vrai et d'autres événements pourront être récupérés via readMoreData().

QOpcUaMonitoringParameters::EventFilter filter ; filter<< QOpcUaSimpleAttributeOperand("Message") ; filter<< QOpcUaSimpleAttributeOperand("Heure") ;const QOpcUaHistoryReadEventRequest request({ QOpcUaReadItem("ns=2;s=EventHistorian"), QOpcUaReadItem("ns=2;s=EventHistorian2")},  QDateTime::currentDateTime().addDays(-2), QDateTime::currentDateTime(),filter, 10) ;// L'objet response doit être libéré par l'utilisateur une fois que toutes les données souhaitées ont été récupéréesconst 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; } // Imprimer 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 la 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.

Retourne vrai si la requête asynchrone a été envoyée avec succès. Les résultats sont renvoyés par le signal readNodeAttributesFinished().

Cette fonction de lecture offre un autre moyen de lire les attributs des nœuds, qui peut être utilisé dans des scénarios où les valeurs d'un grand nombre d'attributs de nœuds sur différents nœuds doivent être lues sans nécessiter les autres fonctionnalités de l'API basée sur QOpcUaNode, telles que la surveillance des changements de valeur. Tous les éléments lus dans la demande sont envoyés au serveur en une seule demande et reçoivent une seule réponse qui génère un seul signal readNodeAttributesFinished(). Cela permet de réduire la surcharge du réseau et le nombre de connexions de fente de signal si de nombreux nœuds différents sont concernés.

Dans l'exemple suivant, l'attribut display name et les deux plages d'index "0:2" et "5:7" de l'attribut value du même nœud et l'attribut value entier d'un second 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 aussi QOpcUaReadItem et readNodeAttributesFinished().

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

Ce signal est émis après la fin de l'opération readNodeAttributes().

Les éléments de results ont le même ordre que les éléments de la demande. Pour chaque élément demandé, il y a une valeur ainsi que des horodatages et le code d'état dans results. serviceResult contient le code d'état du service OPC UA Read.

Voir aussi readNodeAttributes(), QOpcUaReadResult, et QOpcUaReadItem.

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

Enregistre les identifiants de nœuds contenus dans nodesToRegister sur le serveur et renvoie true si la demande a été traitée avec succès. Les résultats sont renvoyés dans le signal registerNodesFinished().

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

Les identifiants de nœuds enregistrés ne sont garantis que pour la session en cours. Tout enregistrement qui n'est plus nécessaire doit être désenregistré 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 aussi unregisterNodes().

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

Ce signal est émis après la fin de l'opération registerNodes(). nodesToRegister contient les identifiants de nœuds de la demande à des fins de corrélation. Les identifiants de nœuds renvoyés par le serveur sont dans registeredNodeIds et ont le même ordre que les identifiants de la requête. statusCode indique si l'opération a réussi.

Cette fonction a été introduite dans Qt 6.7.

Voir aussi registerNodes().

bool QOpcUaClient::requestEndpoints(const QUrl &url)

Lance une requête asynchrone GetEndpoints pour lire une liste de points d'extrémité disponibles sur le serveur à l'adresse url. Retourne true si l'appel asynchrone a été envoyé avec succès.

Les informations sur les points d'accès 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 avec un index numérique d'espace de noms. 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 étendu est malformée. ok sera mis à true si la conversion a été réussie. Si l'identifiant du nœud étendu n'a pas pu être résolu, ok sera remplacé par false.

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

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

Cette fonction a été introduite dans QtOpcUa 5.13.

Voir aussi applicationIdentity().

void QOpcUaClient::setAuthenticationInformation(const QOpcUaAuthenticationInformation &authenticationInformation)

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

Voir aussi authenticationInformation() et connectToEndpoint().

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

Définit les paramètres de connexion pour ce client à 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 de connectionSettings sont appliquées à toutes les nouvelles connexions après ce point.

Le plugin open62541 prend en charge la mise à jour des paramètres linguistiques de la session pour la connexion en cours. Toutes les autres valeurs qui sont modifiées mais qui ne supportent pas d'être mises à jour pendant la connexion provoquent un message d'avertissement et seront appliquées lors du prochain appel à connectToEndpoint().

Cette fonction a été introduite dans Qt 6.6.

Voir aussi connectionSettings().

void QOpcUaClient::setNamespaceAutoupdate(bool isEnabled)

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

En activant cette option, la copie locale de la table de l'espace de noms sera automatiquement mise à jour. namespaceArrayUpdated sera émis lorsque le tableau aura changé. 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 pour suivre les modifications. Si le serveur ne prend pas en charge les abonnements, cela ne fonctionnera pas et isNamespaceAutoupdateEnabled renverra false.

Voir également namespaceArray() et namespaceArrayUpdated().

void QOpcUaClient::setNamespaceAutoupdateInterval(int interval)

Définit l'intervalle pour l'abonnement à la table de l'espace de noms.

L'abonnement peut être révisé par le serveur.

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

Voir aussi namespaceAutoupdateInterval() et QOpcUaClient::setNamespaceAutoupdate(bool isEnabled).

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

Définit la configuration de l'ICP de l'application pour cette instance QOpcUaClient à config.

Cette fonction a été introduite dans QtOpcUa 5.13.

Voir aussi 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 tant qu'aperçu technologique, et par conséquent l'API et les fonctionnalités fournies par la fonction peuvent ê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 d'utilisateur pris en charge par le backend utilisé.

Cette fonction est actuellement disponible en tant qu'aperçu technologique, et par conséquent l'API et les fonctionnalités fournies par la fonction peuvent être modifiées à tout moment sans préavis.

Cette fonction a été introduite dans QtOpcUa 5.14.

Voir aussi QOpcUaUserTokenPolicy::TokenType.

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

Désenregistre les identifiants de nœuds contenus dans nodesToUnregister sur le serveur et renvoie true si la demande a été traitée avec succès. Les résultats sont renvoyés dans le signal unregisterNodesFinished().

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

Cette fonction a été introduite dans Qt 6.7.

Voir aussi registerNodes().

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

Ce signal est émis après la fin de l'opération unregisterNodes(). nodesToUnregister contient les identifiants de nœuds de la requête à des fins de corrélation. statusCode indique si l'opération a réussi.

Cette fonction a été introduite dans Qt 6.7.

Voir aussi unregisterNodes().

bool QOpcUaClient::updateNamespaceArray()

Demande au serveur de mettre à jour le tableau des espaces de noms. Retourne true si l'opération a été exécutée avec succès.

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

Voir aussi namespaceArray() et namespaceArrayUpdated().

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

Lance une écriture pour plusieurs attributs sur 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 dans nodesToWrite.

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

Cette fonction d'écriture offre un autre moyen d'écrire les attributs des nœuds, qui peut être utilisé dans des scénarios où les valeurs d'un grand nombre d'attributs de nœuds sur différents nœuds doivent être écrites sans nécessiter les 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 demande sont envoyés au serveur en une seule requête et reçoivent une seule réponse qui génère un seul signal writeNodeAttributesFinished(). Cela permet de réduire la surcharge du réseau et le nombre de connexions de fente de signal si de nombreux nœuds différents sont concerné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 un tableau de valeurs 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 après la fin de l'opération writeNodeAttributes().

Les éléments de results ont le même ordre que les éléments de la demande d'écriture. Ils contiennent la valeur, l'horodatage et le code d'état reçus du serveur, ainsi que l'identifiant du nœud, l'attribut et l'intervalle d'index de l'élément d'écriture. Cela facilite la correspondance entre le résultat et la demande.

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

Voir également writeNodeAttributes() et QOpcUaWriteResult.