QOpcUaNode Class

Documentation des fonctions membres

[static constexpr] QOpcUa::NodeAttributes QOpcUaNode::allBaseAttributes()

Contient tous les attributs de la classe de nœud de base OPC UA.

QVariant QOpcUaNode::attribute(QOpcUa::NodeAttribute attribute) const

Renvoie la valeur de l'attribut indiqué dans attribute.

La valeur n'est valable qu'après l'émission du signal attributeRead. Une adresse QVariant vide est renvoyée s'il n'y a pas de valeur en cache pour l'attribut.

QOpcUa::UaStatusCode QOpcUaNode::attributeError(QOpcUa::NodeAttribute attribute) const

Renvoie le code d'erreur pour l'attribut indiqué dans attribute.

Le code d'erreur n'est valide qu'après l'émission du signal attributeRead ou attributeWritten.

S'il n'y a pas d'entrée dans le cache d'attributs, BadNoEntryExists est renvoyé.

Voir aussi QOpcUa::errorCategory.

[signal] void QOpcUaNode::attributeRead(QOpcUa::NodeAttributes attributes)

Ce signal est émis après la fin d'une opération readAttributes() ou readAttributeRange(). Le récepteur doit vérifier le code d'état pour les attributs contenus dans attributes.

[signal] void QOpcUaNode::attributeUpdated(QOpcUa::NodeAttribute attr, QVariant value)

Ce signal est émis après que la valeur du cache d'attributs a été mise à jour par une notification de changement de données provenant du serveur, une opération de lecture ou d'écriture. value contient la nouvelle valeur de l'attribut de nœud attr.

Voir aussi attribute(), attributeError(), serverTimestamp(), sourceTimestamp() et valueAttributeUpdated().

[signal] void QOpcUaNode::attributeWritten(QOpcUa::NodeAttribute attribute, QOpcUa::UaStatusCode statusCode)

Ce signal est émis après la fin d'une opération writeAttribute(), writeAttributes() ou writeAttributeRange().

Avant l'émission de ce signal, le cache d'attributs est mis à jour en cas d'écriture réussie. Pour writeAttributes(), un signal est émis pour chaque attribut dans l'appel d'écriture. statusCode contient les informations de réussite de l'opération d'écriture sur attribute.

bool QOpcUaNode::browse(const QOpcUaBrowseRequest &request)

Lance un appel de navigation à partir de ce nœud.

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

Toutes les références correspondant aux critères spécifiés dans request sont renvoyées dans le signal browseFinished().

Par exemple, un appel browse inverse peut être utilisé pour trouver le nœud parent d'un nœud de propriété :

QOpcUaBrowseRequest request;
request.setBrowseDirection(QOpcUaBrowseRequest::BrowseDirection::Inverse);
request.setReferenceTypeId(QOpcUa::ReferenceTypeId::HasProperty);
propertyNode->browse(request);

bool QOpcUaNode::browseChildren(QOpcUa::ReferenceTypeId referenceType = QOpcUa::ReferenceTypeId::HierarchicalReferences, QOpcUa::NodeClasses nodeClassMask = QOpcUa::NodeClass::Undefined)

Exécute un appel de recherche en avant à partir du nœud sur lequel cette méthode est appelée. L'opération de navigation recueille des informations sur les nœuds enfants connectés au nœud et fournit les résultats dans le signal browseFinished().

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

Pour ne demander que les enfants connectés au nœud par un certain type de référence, referenceType doit être défini sur ce type de référence. Par exemple, ceci peut être utilisé pour obtenir toutes les propriétés d'un nœud en passant HasProperty à referenceType. Les résultats peuvent être filtrés pour ne contenir que les nœuds ayant certaines classes de nœuds en les définissant dans nodeClassMask.

[signal] void QOpcUaNode::browseFinished(QList<QOpcUaReferenceDescription> children, QOpcUa::UaStatusCode statusCode)

Ce signal est émis après la fin d'une opération browseChildren() ou browse().

children contient des informations sur tous les nœuds qui correspondent aux critères de browseChildren(). statusCode contient le résultat du service de l'opération de navigation. Si statusCode n'est pas Good, le vecteur children transmis est vide.

Voir aussi QOpcUaReferenceDescription.

bool QOpcUaNode::callMethod(const QString &methodNodeId, const QList<QOpcUa::TypedVariant> &args = QList<QOpcUa::TypedVariant>())

Appelle la méthode OPC UA methodNodeId avec les paramètres donnés par args. Le résultat est renvoyé dans le signal methodCallFinished.

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

QOpcUaClient *QOpcUaNode::client() const

Renvoie un pointeur sur le client qui a créé ce nœud.

[signal] void QOpcUaNode::dataChangeOccurred(QOpcUa::NodeAttribute attr, QVariant value)

Ce signal est émis après réception d'une notification de changement de données. value contient la nouvelle valeur de l'attribut de nœud attr.

Voir également attribute(), serverTimestamp() et sourceTimestamp().

bool QOpcUaNode::disableMonitoring(QOpcUa::NodeAttributes attr)

Cette méthode désactive la surveillance des attributs indiqués dans attr.

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

Une fois l'appel terminé, le signal disableMonitoringFinished est émis et monitoringStatus renvoie une valeur construite par défaut avec le code d'état BadMonitoredItemIdIinvalid pour attr.

[signal] void QOpcUaNode::disableMonitoringFinished(QOpcUa::NodeAttribute attr, QOpcUa::UaStatusCode statusCode)

Ce signal est émis après la fin d'un appel asynchrone à disableMonitoring(). statusCode contient le code d'état généré par l'opération. Après l'émission de ce signal, monitoringStatus renvoie une valeur construite par défaut avec le code d'état BadMonitoredItemIdIinvalid pour attr.

bool QOpcUaNode::enableMonitoring(QOpcUa::NodeAttributes attr, const QOpcUaMonitoringParameters &settings)

Cette méthode crée un élément surveillé pour chacun des attributs indiqués à l'adresse attr. Les paramètres de settings sont utilisés pour la création des éléments surveillés et de l'abonnement.

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

À la fin de l'appel, le signal enableMonitoringFinished est émis. Il existe plusieurs cas d'erreur dans lesquels un mauvais code d'état est généré : Un abonnement avec l'identifiant d'abonnement spécifié dans settings n'existe pas, le nœud n'existe pas sur le serveur, le nœud n'a pas l'attribut demandé ou le nombre maximum d'éléments surveillés pour le serveur est atteint.

La même méthode est utilisée pour activer la surveillance des événements. Les événements sont des objets spéciaux dans l'espace d'adressage OPC UA qui contiennent des informations sur un événement qui s'est produit. Si un événement est déclenché sur le serveur, un élément surveillé recueille les valeurs sélectionnées des attributs de nœud de l'objet d'événement et de ses nœuds enfants. Chaque nœud ayant une source d'événement peut être surveillé pour des événements. Pour surveiller les événements d'un nœud, l'attribut EventNotifier doit être surveillé à l'aide d'un EventFilter qui contient les champs d'événement dont l'utilisateur a besoin et, éventuellement, une clause where qui permet de filtrer les événements en fonction de critères (pour plus de détails, voir QOpcUaMonitoringParameters::EventFilter).

[signal] void QOpcUaNode::enableMonitoringFinished(QOpcUa::NodeAttribute attr, QOpcUa::UaStatusCode statusCode)

Ce signal est émis après la fin d'un appel asynchrone à enableMonitoring(). Après l'émission de ce signal, monitoringStatus() renvoie des informations valides pour attr. statusCode contient le code d'état de l'opération.

[signal] void QOpcUaNode::eventOccurred(QVariantList eventFields)

Ce signal est émis après la réception d'un nouvel événement.

eventFields contient les valeurs des champs de l'événement dans l'ordre spécifié dans la clause select du filtre d'événement.

[static constexpr] QOpcUa::NodeAttributes QOpcUaNode::mandatoryBaseAttributes()

Contient tous les attributs obligatoires de la classe de nœud de base OPC UA.

[signal] void QOpcUaNode::methodCallFinished(QString methodNodeId, QVariant result, QOpcUa::UaStatusCode statusCode)

Ce signal est émis après la fin d'un appel de méthode pour methodNodeId sur le serveur. statusCode contient le code d'état de l'appel de méthode, result contient les arguments de sortie de la méthode. result est vide si la méthode n'a pas d'arguments de sortie ou statusCode n'est pas Good. La variante result est soit une valeur unique s'il n'y a qu'un seul argument de sortie, soit une liste de variantes si la fonction appelée a renvoyé plusieurs arguments de sortie.

if (result.canConvert<QVariantList>()) {
    // handle list type
} else {
    // handle value type
}

bool QOpcUaNode::modifyDataChangeFilter(QOpcUa::NodeAttribute attr, const QOpcUaMonitoringParameters::DataChangeFilter &filter)

Modifie un contrôle de changement de données existant pour utiliser filter comme filtre de changement de données.

Retourne true si la demande de modification du filtre a été envoyée avec succès au backend.

monitoringStatusChanged pour attr est émis après la fin de l'opération.

bool QOpcUaNode::modifyEventFilter(const QOpcUaMonitoringParameters::EventFilter &eventFilter)

Modifie un suivi d'événement existant pour utiliser eventFilter comme filtre d'événement.

Retourne true si la demande de modification du filtre a été envoyée avec succès au backend.

monitoringStatusChanged pour EventNotifier est émis après la fin de l'opération.

bool QOpcUaNode::modifyMonitoring(QOpcUa::NodeAttribute attr, QOpcUaMonitoringParameters::Parameter item, const QVariant &value)

Cette méthode modifie les paramètres de l'élément surveillé ou de l'abonnement. Le paramètre item de l'élément surveillé ou de l'abonnement associé à attr fait l'objet d'une tentative d'attribution de la valeur value.

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

Une fois l'appel terminé, le signal monitoringStatusChanged est émis. Ce signal contient les paramètres modifiés et le code d'état. Un mauvais code d'état est généré s'il n'y a pas d'élément surveillé associé à l'attribut demandé, si la modification du paramètre demandé n'est pas implémentée ou si le serveur a rejeté la valeur demandée.

QOpcUaMonitoringParameters QOpcUaNode::monitoringStatus(QOpcUa::NodeAttribute attr)

Renvoie les paramètres de surveillance associés à l'attribut attr. Ceci peut être utilisé pour vérifier le succès de enableMonitoring() ou si les paramètres ont été révisés. Les valeurs renvoyées ne sont valables que si enableMonitoringFinished ou monitoringStatusChanged a été émis pour attr. Si l'état est demandé avant qu'un signal n'ait été émis, QOpcUaMonitoringParameters::statusCode() renvoie BadNoEntryExists.

[signal] void QOpcUaNode::monitoringStatusChanged(QOpcUa::NodeAttribute attr, QOpcUaMonitoringParameters::Parameters items, QOpcUa::UaStatusCode statusCode)

Ce signal est émis après la fin d'un appel asynchrone à modifyMonitoring(). L'attribut du nœud pour lequel l'opération a été demandée est renvoyé dans attr. items contient les paramètres qui ont été modifiés. statusCode contient le résultat de l'opération de modification sur le serveur.

QString QOpcUaNode::nodeId() const

Renvoie l'ID du nœud OPC UA.

bool QOpcUaNode::readAttributeRange(QOpcUa::NodeAttribute attribute, const QString &indexRange)

Lance une opération de lecture asynchrone pour l'attribut de nœud attribute. indexRange est une chaîne de caractères qui peut être utilisée pour sélectionner une partie d'un tableau. Elle est définie dans OPC UA 1.05 partie 4, 7.27. Le premier élément d'un tableau est 0, "1" renvoie le deuxième élément, "0:9" renvoie les 10 premiers éléments, "0,1" renvoie le deuxième élément de la première ligne d'un tableau à deux dimensions.

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

Les valeurs des attributs ne contiennent des informations valides qu'après l'émission du signal attributeRead.

bool QOpcUaNode::readAttributes(QOpcUa::NodeAttributes attributes = mandatoryBaseAttributes())

Lance une opération de lecture asynchrone des attributs du nœud dans attributes.

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

Les valeurs des attributs ne contiennent des informations valides qu'après l'émission du signal attributeRead.

[since 6.7] QOpcUaHistoryReadResponse *QOpcUaNode::readHistoryEvents(const QDateTime &startTime, const QDateTime &endTime, QOpcUaMonitoringParameters::EventFilter &filter, quint32 numValues = 0)

Lance une demande de lecture de l'historique des événements pour ce nœud en utilisant les paramètres startTime, endTime, filter et numValues. Le serveur utilise le paramètre filter pour déterminer les événements et l'ensemble de leurs champs à renvoyer.

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. Jusqu'à 10 événements 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().

QScopedPointer<QOpcUaNode> node(opcuaClient->node("ns=2;s=EventHistorian")) ; QVERIFY(node != nullptr) ;QOpcUaMonitoringParameters::EventFilter filter ; filter<< QOpcUaSimpleAttributeOperand("Message") ; filter<< QOpcUaSimpleAttributeOperand("Heure") ;const auto response =  node->readHistoryEvents(QDateTime::currentDateTime().addDays(-2), QDateTime::currentDateTime(), filter, 10) ;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.

[since 6.3] QOpcUaHistoryReadResponse *QOpcUaNode::readHistoryRaw(const QDateTime &startTime, const QDateTime &endTime, quint32 numValues, bool returnBounds)

Lance une requête de lecture de l'historique pour ce nœud. Il s'agit de la représentation Qt OPC UA du service OPC UA ReadHistory pour la lecture de données historiques brutes défini dans OPC UA 1.05 partie 4, 5.10.3. Il lit l'historique en se basant sur les paramètres startTime, endTime, numValues, et returnBounds.

Il 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 d'un nœud sont demandées et imprimées. Le résultat est limité à dix valeurs par nœud.

QOpcUaHistoryReadResponse *response =  node->readHistoryRaw(QDateTime::currentDateTime(),                    QDateTime::currentDateTime().addDays(-2), 10, true) ;if (response) { QObject::connect(response123, &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 *QOpcUaNode::readHistoryRaw(const QDateTime &startTime, const QDateTime &endTime, quint32 numValues, bool returnBounds, QOpcUa::TimestampsToReturn timestampsToReturn)

Lance une demande de lecture de l'historique pour ce nœud. Le paramètre supplémentaire timestampsToReturn détermine les horodatages qui seront renvoyés pour chaque valeur.

Cette fonction a été introduite dans Qt 6.7.

bool QOpcUaNode::readValueAttribute()

Lance une opération de lecture asynchrone de l'attribut Value du nœud.

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

Voir aussi readAttributes().

bool QOpcUaNode::resolveBrowsePath(const QList<QOpcUaRelativePathElement> &path)

Résout le chemin de navigation path en un ou plusieurs identifiants de nœuds à partir de ce nœud en utilisant le service TranslateBrowsePathsToNodeIds spécifié dans OPC UA 1.05 partie 4, 5.8.4.

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

TranslateBrowsePathsToNodeIds est principalement utilisé pour programmer par rapport à des définitions de type au lieu d'un ensemble concret de nœuds dans l'espace d'adressage OPC UA. Par exemple, une définition de type pour un modèle de machine pourrait consister en un nœud de départ avec le nom de navigation "Machine" qui a un composant avec le nom de navigation "Ventilateur". Le ventilateur possède un composant dont le nom de recherche est "RPM", qui est un nœud variable contenant la valeur RPM actuelle du ventilateur. Il existe plusieurs machines de ce type et chacune d'entre elles est mappée dans l'espace d'adressage OPC UA en tant qu'objet du type machine. Pour chacun de ces objets machine, le chemin entre le nœud machine et le nœud "RPM" est le même. Si un client souhaite lire la valeur actuelle du RPM, il doit appeler resolveBrowsePath() avec le nœud de la machine comme nœud de départ et le chemin d'accès de la machine au nœud "RPM" :

QScopedPointer<QOpcUaNode> node(opcuaClient->node("ns=1;s=machine1"));

QList<QOpcUaRelativePathElement> path;
path.append(QOpcUaRelativePathElement(QOpcUaQualifiedName(1, "Fan"), QOpcUa::ReferenceTypeId::HasComponent));
path.append(QOpcUaRelativePathElement(QOpcUaQualifiedName(1, "RPM"), QOpcUa::ReferenceTypeId::HasComponent));
node->resolveBrowsePath(path);

Le résultat renvoyé dans resolveBrowsePathFinished() contient l'identifiant du nœud "RPM" qui peut être utilisé pour accéder aux attributs du nœud :

if (!results.size())) {    qWarning() << "Browse path resolution failed";
   return; }if (results.at(0).isFullyResolved()) { QOpcUaNode *rpmNode =  client->node(results.at(0).targetId()) ; if (!rpmNode) {       qWarning() << "Failed to create node";
      return; } // Connecter les slots, appeler les méthodes} else {    qWarning() << "Browse path could not be fully resolved, the target node is on another server";
   return; }

[signal] void QOpcUaNode::resolveBrowsePathFinished(QList<QOpcUaBrowsePathTarget> targets, QList<QOpcUaRelativePathElement> path, QOpcUa::UaStatusCode statusCode)

Ce signal est émis après la fin d'un appel à resolveBrowsePath().

QOpcUaBrowsePathTarget targets contient les correspondances, statusCode est le code d'état de l'opération. Si statusCode n'est pas Good, targets est vide. Le chemin de navigation path est le chemin de navigation de la requête. Il peut être utilisé pour associer des résultats à des demandes.

QDateTime QOpcUaNode::serverTimestamp(QOpcUa::NodeAttribute attribute) const

Renvoie l'horodatage du serveur à partir de la dernière lecture ou modification des données de attribute. Avant qu'au moins un signal attributeRead ou dataChangeOccurred n'ait été émis, une date nulle est renvoyée.

QDateTime QOpcUaNode::sourceTimestamp(QOpcUa::NodeAttribute attribute) const

Renvoie l'horodatage de la source à partir de la dernière lecture ou modification des données de attribute. Avant qu'au moins un signal attributeRead ou dataChangeOccurred n'ait été émis, une date nulle est renvoyée.

QVariant QOpcUaNode::valueAttribute() const

Renvoie la valeur de l'attribut Value du nœud.

La valeur renvoyée n'est valide que si l'attribut Value a été lu ou écrit avec succès ou si un changement de données provenant d'un suivi a mis à jour le cache de l'attribut. Ceci est indiqué par un signal attributeRead() ou attributeWritten() avec le code d'état Good ou un signal dataChangeOccurred() pour l'attribut Value.

S'il n'y a pas de valeur dans le cache d'attributs, une adresse QVariant invalide est renvoyée.

Voir également readValueAttribute(), writeValueAttribute() et valueAttributeError().

QOpcUa::UaStatusCode QOpcUaNode::valueAttributeError() const

Renvoie le code d'erreur pour l'attribut Value du nœud. Le code d'état Good indique une valeur de retour valide pour valueAttribute(). S'il n'y a pas d'entrée dans le cache d'attributs, BadNoEntryExists est renvoyé.

[signal, since 6.7] void QOpcUaNode::valueAttributeUpdated(const QVariant &value)

Ce signal est émis après que l'attribut value dans le cache d'attribut a été mis à jour par une notification de changement de données du serveur, une opération de lecture ou d'écriture. value contient la nouvelle valeur de l'attribut value.

Cette fonction a été introduite dans Qt 6.7.

Voir aussi attribute(), attributeError(), serverTimestamp(), sourceTimestamp() et attributeUpdated().

bool QOpcUaNode::writeAttribute(QOpcUa::NodeAttribute attribute, const QVariant &value, QOpcUa::Types type = QOpcUa::Types::Undefined)

Écrit value dans l'attribut indiqué dans attribute en utilisant les informations de type de type. Retourne true si l'appel asynchrone a été envoyé avec succès.

Si le paramètre type est omis, le backend tente de trouver le type correct. Les types par défaut suivants sont pris en compte :

bool QOpcUaNode::writeAttributeRange(QOpcUa::NodeAttribute attribute, const QVariant &value, const QString &indexRange, QOpcUa::Types type = QOpcUa::Types::Undefined)

Écrit value dans l'attribut indiqué dans attribute en utilisant les informations de type de type. Pour indexRange, voir readAttributeRange().

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

bool QOpcUaNode::writeAttributes(const QOpcUaNode::AttributeMap &toWrite, QOpcUa::Types valueAttributeType = QOpcUa::Types::Undefined)

Exécute une opération d'écriture pour les attributs et les valeurs spécifiés dans toWrite.

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

Le paramètre valueAttributeType peut être utilisé pour fournir des informations sur le type de l'attribut value. Tous les autres attributs ont des types connus.

Voir également writeAttribute().

bool QOpcUaNode::writeValueAttribute(const QVariant &value, QOpcUa::Types type = QOpcUa::Types::Undefined)

Écrit value dans l'attribut Value du nœud en utilisant les informations de type de type.

Retourne true si l'appel asynchrone a été exécuté avec succès.

Voir aussi writeAttribute().