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 spécifié dans attribute.

La valeur n’est valide qu’après l’émission du signal « attributeRead ». Si aucune valeur n’est mise en cache pour l’attribut, un objet « QVariant » vide est renvoyé.

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

Renvoie le code d'erreur correspondant à l'attribut spécifié dans attribute.

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

S'il n'y a aucune entrée dans le cache d'attributs, la valeur « BadNoEntryExists » est renvoyée.

Voir également QOpcUa::errorCategory.

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

Ce signal est émis une fois l'opération readAttributes() ou readAttributeRange() terminée. Le récepteur doit vérifier le code d'état pour connaître les attributs contenus dans attributes.

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

Ce signal est émis une fois que la valeur contenue dans le cache d’attributs a été mise à jour à la suite d’une notification de modification des données provenant du serveur, d’une opération de lecture ou d’écriture. Le message « value » contient la nouvelle valeur de l’attribut du nœud « attr ».

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

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

Ce signal est émis une fois l'opération writeAttribute(), writeAttributes() ou writeAttributeRange() terminée.

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 de 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é correctement expédié.

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 de navigation 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 parcours vers l'avant à partir du nœud sur lequel cette méthode est appelée. L'opération de parcours collecte des informations sur les nœuds enfants associés au nœud et transmet les résultats via le signal browseFinished().

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

Pour ne demander que les nœuds 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, cela peut être utilisé pour obtenir toutes les propriétés d’un nœud en passant HasProperty dans referenceType. Les résultats peuvent être filtrés pour ne contenir que les nœuds appartenant à 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 une fois que l'opération browseChildren() ou browse() s'est terminée.

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

Voir également 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 fournis via « args ». Le résultat est renvoyé via le signal « methodCallFinished ».

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

QOpcUaClient *QOpcUaNode::client() const

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

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

Ce signal est émis après la réception d'une notification de modification des données. Le message « value » contient la nouvelle valeur de l'attribut « attr » du nœud.

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.

Renvoie true si l'appel asynchrone a été dispatché 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 une fois qu’un appel asynchrone à ` disableMonitoring()` s’est achevé. ` statusCode ` contient le code d’état généré par l’opération. Une fois ce signal émis, ` 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 dans 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.

Une fois l’appel terminé, le signal enableMonitoringFinished est émis. Il existe plusieurs cas d’erreur dans lesquels un code d’état d’erreur est généré : un abonnement dont l’identifiant est spécifié dans settings n’existe pas, le nœud n’existe pas sur le serveur, le nœud ne dispose pas de l’attribut demandé ou le nombre maximal 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 de surveillance d’événements collecte les valeurs sélectionnées des attributs de nœud de l’objet événement et de ses nœuds enfants. Tout nœud disposant d’une source d’événements peut faire l’objet d’une surveillance des événements. Pour surveiller les événements d’un nœud, l’attribut « EventNotifier » doit être surveillé à l’aide d’un EventFilter contenant les champs d’événement dont l’utilisateur a besoin et, éventuellement, une clause «where» permettant de filtrer les événements selon des critères (pour plus de détails, voir QOpcUaMonitoringParameters::EventFilter).

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

Ce signal est émis une fois qu’un appel asynchrone à la fonction ` enableMonitoring()` s’est achevé. Une fois ce signal émis, la fonction ` monitoringStatus()` renvoie des informations valides pour ` attr`. La variable ` statusCode ` contient le code d’état de l’opération.

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

Ce signal est émis lorsqu’un nouvel événement est reçu.

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

[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 une fois que l'appel de la méthode « methodNodeId » s'est achevé sur le serveur. « statusCode » contient le code d'état de l'appel de méthode, tandis que « result » contient les arguments de sortie de la méthode. « result » est vide si la méthode ne comporte aucun argument de sortie ou si « 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 une surveillance des modifications de données existante afin d'utiliser filter comme filtre de modification de données.

Renvoie « true » si la demande de modification du filtre a bien été transmise au backend.

monitoringStatusChanged Un événement « for attr » est émis une fois l'opération terminée.

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

Modifie une surveillance d'événement existante afin d'utiliser « eventFilter » comme filtre d'événement.

Renvoie « true » si la requête de modification du filtre a bien été transmise au backend.

monitoringStatusChanged Un événement « EventNotifier » est émis une fois l’opération terminée.

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. Elle tente de définir le paramètre « item » de l'élément surveillé ou de l'abonnement associé à « attr » sur « 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 code d’état d’erreur est généré s’il n’existe aucun élément surveillé associé à l’attribut demandé, si la modification du paramètre demandé n’est pas prise en charge 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. Cette fonction peut être utilisée pour vérifier la réussite de l'appel enableMonitoring() ou pour déterminer si les paramètres ont été modifiés. Les valeurs renvoyées ne sont valides qu'après l'émission des signaux enableMonitoringFinished ou monitoringStatusChanged pour attr. Si l'état est interrogé avant l'émission d'un signal, la fonction QOpcUaMonitoringParameters::statusCode() renvoie BadNoEntryExists.

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

Ce signal est émis une fois l'exécution d'un appel asynchrone à la méthode ` modifyMonitoring()` terminée. 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'identifiant 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 permettant de sélectionner une partie d'un tableau. Elle est définie dans la norme OPC UA 1.05, partie 4, section 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 bidimensionnel.

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

Les valeurs d’attribut 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 situé à l'adresse 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 requête d'historique des événements en lecture pour ce nœud à l'aide des paramètres startTime, endTime, filter et numValues. Le paramètre filter est utilisé par le serveur pour déterminer quels événements et quels ensembles de champs doivent être renvoyés.

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

L’exemple suivant récupère les événements historiques des deux derniers jours. Jusqu’à 10 événements 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().

QScopedPointer<QOpcUaNode> node(opcuaClient->node("ns=2;s=EventHistorian"));
QVERIFY(node != nullptr);

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

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

                     // 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.

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

Lance une requête d'historique de lecture pour ce nœud. Il s'agit de la représentation « Qt OPC UA » du service «ReadHistory» d'OPC UA, destiné à la lecture de données historiques brutes, telle que définie dans la norme OPC UA 1.05, partie 4, section 5.10.3. Elle lit l'historique en fonction des paramètres suivants : startTime, endTime, numValues et returnBounds.

Renvoie un objet ` QOpcUaHistoryReadResponse ` contenant l’état de la requête si celle-ci 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 d’un nœud sont demandées et affiché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> résultats, 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 requête d'historique de lecture pour ce nœud. Le paramètre supplémentaire ` timestampsToReturn ` détermine quels horodatages 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 pour l'attribut « Value » du nœud.

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

Voir également readAttributes().

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

Convertit le chemin de navigation path en un ou plusieurs identifiants de nœuds à partir de ce nœud, à l'aide du service « TranslateBrowsePathsToNodeIds » spécifié dans la norme OPC UA 1.05, partie 4, section 5.8.4.

Renvoie « true » si l'appel asynchrone a été correctement transmis.

TranslateBrowsePathsToNodeIds est principalement utilisé pour programmer à partir de définitions de types plutôt qu’à partir 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 se composer d’un nœud de départ portant le nom de navigation « Machine », qui possède un composant portant le nom de navigation « Fan ». Ce ventilateur comporte un composant dont le nom de navigation est « RPM », qui est un nœud de type « Variable » contenant la valeur actuelle du régime (RPM) 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 menant du nœud « machine » au nœud « RPM » est identique. Si un client souhaite lire la valeur actuelle de RPM, il doit appeler la fonction resolveBrowsePath() en indiquant le nœud « machine » comme nœud de départ et le chemin de navigation menant 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é par la fonction ` resolveBrowsePathFinished()` contient l’identifiant du nœud « RPM », qui peut être utilisé pour accéder aux attributs de ce 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 une fois l'appel à ` resolveBrowsePath()` terminé.

QOpcUaBrowsePathTarget targets contient les résultats correspondants, correspond au code d'état de l'opération. Si n'est pas , est vide. Le chemin de navigation correspond au chemin de navigation issu de la requête. Il peut être utilisé pour associer les résultats aux requêtes. statusCode statusCode Good targets path

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

Renvoie l'horodatage serveur correspondant à la dernière lecture ou modification des données de attribute. Tant qu'au moins un signal attributeRead ou dataChangeOccurred n'a pas été émis, une date-heure nulle est renvoyée.

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

Renvoie l'horodatage source correspondant à la dernière lecture ou modification des données de attribute. Tant qu'au moins un signal attributeRead ou dataChangeOccurred n'a pas été émis, une date-heure 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 qu’après la lecture ou l’écriture réussie de l’attribut « Value », ou après qu’une modification des données issue d’une surveillance a mis à jour le cache d’attributs. Ceci est signalé par un signal « attributeRead() » ou « attributeWritten() » avec le code d’état « Good », ou par un signal « dataChangeOccurred() » pour l’attribut « Value ».

Si le cache d’attributs ne contient aucune valeur, une valeur « QVariant » non valide est renvoyée.

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

QOpcUa::UaStatusCode QOpcUaNode::valueAttributeError() const

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

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

Ce signal est émis lorsque l'attribut « value » du cache d'attributs a été mis à jour à la suite d'une notification de modification des données provenant du serveur, d'une opération de lecture ou d'écriture. La variable « value » contient la nouvelle valeur de l'attribut « value ».

Cette fonction a été introduite dans Qt 6.7.

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

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

Écrit la valeur value dans l'attribut indiqué dans attribute en utilisant les informations de type provenant de type. Renvoie true si l'appel asynchrone a été correctement déclenché.

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

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

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

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

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

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

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

Le paramètre valueAttributeType peut être utilisé pour fournir des informations de type pour 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 la valeur « value » dans l'attribut « Value » du nœud en utilisant les informations de type provenant de type.

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

Voir également writeAttribute().