En esta página

QOpcUaNode Class

QOpcUaNode permite interactuar con un nodo OPC UA. Más información...

Encabezado: #include <QOpcUaNode>
CMake: find_package(Qt6 REQUIRED COMPONENTS OpcUa)
target_link_libraries(mytarget PRIVATE Qt6::OpcUa)
qmake: QT += opcua
Heredado de: QObject

Tipos públicos

Funciones públicas

QVariant attribute(QOpcUa::NodeAttribute attribute) const
QOpcUa::UaStatusCode attributeError(QOpcUa::NodeAttribute attribute) const
bool browse(const QOpcUaBrowseRequest &request)
bool browseChildren(QOpcUa::ReferenceTypeId referenceType = QOpcUa::ReferenceTypeId::HierarchicalReferences, QOpcUa::NodeClasses nodeClassMask = QOpcUa::NodeClass::Undefined)
bool callMethod(const QString &methodNodeId, const QList<QOpcUa::TypedVariant> &args = QList<QOpcUa::TypedVariant>())
QOpcUaClient *client() const
bool disableMonitoring(QOpcUa::NodeAttributes attr)
bool enableMonitoring(QOpcUa::NodeAttributes attr, const QOpcUaMonitoringParameters &settings)
bool modifyDataChangeFilter(QOpcUa::NodeAttribute attr, const QOpcUaMonitoringParameters::DataChangeFilter &filter)
bool modifyEventFilter(const QOpcUaMonitoringParameters::EventFilter &eventFilter)
bool modifyMonitoring(QOpcUa::NodeAttribute attr, QOpcUaMonitoringParameters::Parameter item, const QVariant &value)
QOpcUaMonitoringParameters monitoringStatus(QOpcUa::NodeAttribute attr)
QString nodeId() const
bool readAttributeRange(QOpcUa::NodeAttribute attribute, const QString &indexRange)
bool readAttributes(QOpcUa::NodeAttributes attributes = mandatoryBaseAttributes())
(since 6.7) QOpcUaHistoryReadResponse *readHistoryEvents(const QDateTime &startTime, const QDateTime &endTime, QOpcUaMonitoringParameters::EventFilter &filter, quint32 numValues = 0)
(since 6.3) QOpcUaHistoryReadResponse *readHistoryRaw(const QDateTime &startTime, const QDateTime &endTime, quint32 numValues, bool returnBounds)
(since 6.7) QOpcUaHistoryReadResponse *readHistoryRaw(const QDateTime &startTime, const QDateTime &endTime, quint32 numValues, bool returnBounds, QOpcUa::TimestampsToReturn timestampsToReturn)
bool readValueAttribute()
bool resolveBrowsePath(const QList<QOpcUaRelativePathElement> &path)
QDateTime serverTimestamp(QOpcUa::NodeAttribute attribute) const
QDateTime sourceTimestamp(QOpcUa::NodeAttribute attribute) const
QVariant valueAttribute() const
QOpcUa::UaStatusCode valueAttributeError() const
bool writeAttribute(QOpcUa::NodeAttribute attribute, const QVariant &value, QOpcUa::Types type = QOpcUa::Types::Undefined)
bool writeAttributeRange(QOpcUa::NodeAttribute attribute, const QVariant &value, const QString &indexRange, QOpcUa::Types type = QOpcUa::Types::Undefined)
bool writeAttributes(const QOpcUaNode::AttributeMap &toWrite, QOpcUa::Types valueAttributeType = QOpcUa::Types::Undefined)
bool writeValueAttribute(const QVariant &value, QOpcUa::Types type = QOpcUa::Types::Undefined)

Señales

void attributeRead(QOpcUa::NodeAttributes attributes)
void attributeUpdated(QOpcUa::NodeAttribute attr, QVariant value)
void attributeWritten(QOpcUa::NodeAttribute attribute, QOpcUa::UaStatusCode statusCode)
void browseFinished(QList<QOpcUaReferenceDescription> children, QOpcUa::UaStatusCode statusCode)
void dataChangeOccurred(QOpcUa::NodeAttribute attr, QVariant value)
void disableMonitoringFinished(QOpcUa::NodeAttribute attr, QOpcUa::UaStatusCode statusCode)
void enableMonitoringFinished(QOpcUa::NodeAttribute attr, QOpcUa::UaStatusCode statusCode)
void eventOccurred(QVariantList eventFields)
void methodCallFinished(QString methodNodeId, QVariant result, QOpcUa::UaStatusCode statusCode)
void monitoringStatusChanged(QOpcUa::NodeAttribute attr, QOpcUaMonitoringParameters::Parameters items, QOpcUa::UaStatusCode statusCode)
void resolveBrowsePathFinished(QList<QOpcUaBrowsePathTarget> targets, QList<QOpcUaRelativePathElement> path, QOpcUa::UaStatusCode statusCode)
(since 6.7) void valueAttributeUpdated(const QVariant &value)

Miembros públicos estáticos

QOpcUa::NodeAttributes allBaseAttributes()
QOpcUa::NodeAttributes mandatoryBaseAttributes()

Descripción detallada

El nodo es el elemento básico del espacio de direcciones OPC UA. Posee atributos como el nombre de exploración, el valor y las propiedades asociadas, y puede contener referencias a otros nodos del espacio de direcciones. Los nodos se organizan en espacios de nombres y tienen identificadores que pueden ser, por ejemplo, numéricos, una cadena de caracteres, un formato específico del espacio de nombres (opaco) o un identificador único global. Un nodo se identifica mediante el identificador del espacio de nombres y el identificador del nodo. Este identificador suele expresarse como una cadena de caracteres: el identificador de un nodo que reside en el espacio de nombres 0 y tiene el identificador numérico 42 da como resultado la cadena « ns=0;i=42 ». A un nodo con un identificador de cadena se le puede acceder a través de « ns=0;s=myStringIdentifier ».

Los objetos de este tipo son propiedad del usuario y deben eliminarse cuando ya no sean necesarios. Son válidos mientras exista el QOpcUaClient que los creó.

Lectura y escritura de atributos

Los atributos del nodo se leen del servidor cuando se invocan las funciones ` readAttributes()` o ` readAttributeRange()`. Los resultados se almacenan en caché localmente y pueden recuperarse mediante ` attribute()` una vez que se haya recibido la señal ` attributeRead `.

Los atributos se pueden escribir mediante writeAttribute(), writeAttributes() y writeAttributeRange() si el usuario dispone de los derechos necesarios. El éxito de la operación de escritura se notifica mediante la señal attributeWritten.

attributeError() contiene un código de estado asociado a la última operación de lectura o escritura del atributo. Se trata del código de estado de bajo nivel devuelto por el servicio OPC UA. Este código de estado puede simplificarse convirtiéndolo a un QOpcUa::ErrorCategory mediante QOpcUa::errorCategory().

Suscripciones y elementos supervisados

Las suscripciones son un concepto de OPC UA que permite recibir notificaciones de cambios en los datos o en caso de que se produzcan eventos, en lugar de sondear continuamente un nodo en busca de cambios. Los elementos supervisados definen cómo se vigilan los cambios en los atributos de un nodo. Se añaden a una suscripción y cualquier notificación que generen se reenvía al usuario a través de la suscripción. El usuario puede configurar el intervalo de las actualizaciones, así como muchas otras opciones de los elementos supervisados y las suscripciones.

QOpcUaNode ofrece una abstracción para interactuar con las suscripciones y los elementos supervisados. enableMonitoring() habilita las notificaciones de cambio de datos para uno o más atributos. La señal dataChangeOccurred contiene los nuevos valores y se actualiza la caché local. disableMonitoring() deshabilita las notificaciones de cambio de datos. La señal monitoringStatusChanged notifica los cambios en el estado de supervisión, por ejemplo, tras una habilitación o deshabilitación manual o un cambio de estado en el servidor.

La monitorización de eventos utiliza la misma API para la configuración y la gestión del ciclo de vida. El atributo EventNotifier debe monitorizarse mediante un EventFilter, que selecciona los campos de evento necesarios y filtra los eventos notificados según criterios definidos por el usuario. Los eventos se notifican en la señal eventOccurred() como un QVariantList, que contiene los valores de los campos de evento seleccionados.

La configuración de la suscripción y del elemento supervisado se puede modificar en tiempo de ejecución mediante modifyMonitoring().

Exploración del espacio de direcciones

El espacio de direcciones OPC UA está formado por nodos conectados mediante referencias. La función ` browseChildren ` sigue estas referencias en sentido directo y devuelve los atributos de todos los nodos conectados al nodo situado detrás de una instancia de ` QOpcUaNode ` en la señal ` browseFinished `. La función ` browse()` es similar a ` browseChildren()`, pero ofrece más opciones para configurar la llamada de exploración.

Llamadas a métodos

OPC UA especifica métodos en el servidor a los que el usuario puede llamar. QOpcUaNode lo admite a través de callMethod, que toma parámetros y devuelve los resultados de la llamada en la señal methodCallFinished.

Resolución de rutas de exploración

Para facilitar la programación basada en una descripción de tipos, OPC UA admite la resolución de una ruta de nombres de navegación que parte de un nodo determinado con el fin de obtener el identificador del nodo de destino. El método resolveBrowsePath() sigue una ruta que parte del nodo en el que se ha invocado y devuelve el resultado en la señal resolveBrowsePathFinished().

Ejemplo

Para conectar el cliente a un servidor y obtener un objeto ` QOpcUaNode `, véase ` QOpcUaClient`.

Una vez creado correctamente el nodo, se lee del servidor el BrowseName del nodo raíz:

QOpcUaNode*rootNode; // Creado anteriormente; véase la documentación de QOpcUaClient.
// Conexión a la señal «attributeRead». En lugar de una función lambda, se pueden utilizar slots compatibles de QObjects.
QObject::connect(rootNode, &QOpcUaNode::attributeRead, [rootNode, client](QOpcUa::NodeAttributes attr) {
    qDebug() << "Signal for attributes:" << attr;
   if (rootNode->attributeError(QOpcUa::NodeAttribute::BrowseName) != QOpcUa::UaStatusCode::Good) {
        qDebug() << "Failed to read attribute:" << rootNode->attributeError(QOpcUa::NodeAttribute::BrowseName);
        client->desconectarDePuntoFinal();
    }
    qDebug() << "Browse name:" << rootNode->attribute(QOpcUa::NodeAttribute::BrowseName).value<QOpcUaQualifiedName>().name();
});
rootNode->readAttributes(QOpcUa::NodeAttribute::BrowseName); // Inicia una operación de lectura del atributo «BrowseName» del nodo.

Documentación sobre los tipos de miembros

QOpcUaNode::AttributeMap

writeAttributes() utiliza este tipo para escribir más de un atributo a la vez. Se deben asignar valores de tipo « QVariant » a los atributos que se vayan a escribir.

Documentación de funciones miembro

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

Contiene todos los atributos de la clase de nodo base de OPC UA.

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

Devuelve el valor del atributo especificado en attribute.

El valor solo es válido una vez que se ha emitido la señal « attributeRead ». Si no hay ningún valor almacenado en caché para el atributo, se devuelve un objeto « QVariant » vacío.

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

Devuelve el código de error correspondiente al atributo especificado en attribute.

El código de error solo es válido después de que se haya emitido la señal « attributeRead » o « attributeWritten ».

Si no hay ninguna entrada en la caché de atributos, se devuelve BadNoEntryExists.

Véase también QOpcUa::errorCategory.

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

Esta señal se emite una vez finalizada una operación de tipo « readAttributes » () o « readAttributeRange » (). El receptor debe comprobar el código de estado para conocer los atributos que figuran en attributes.

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

Esta señal se emite después de que el valor de la caché de atributos se haya actualizado a raíz de una notificación de cambio de datos procedente del servidor, o de una operación de lectura o escritura. value contiene el nuevo valor del atributo del nodo attr.

Véase también attribute(), attributeError(), serverTimestamp(), sourceTimestamp() y valueAttributeUpdated().

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

Esta señal se emite una vez finalizada una operación de tipo ` writeAttribute()`, ` writeAttributes()` o ` writeAttributeRange()`.

Antes de que se emita esta señal, se actualiza la caché de atributos en caso de que la escritura se haya realizado correctamente. En el caso de writeAttributes(), se emite una señal por cada atributo incluido en la llamada de escritura. statusCode contiene la información sobre el éxito de la operación de escritura en attribute.

bool QOpcUaNode::browse(const QOpcUaBrowseRequest &request)

Inicia una llamada de exploración desde este nodo.

Devuelve ` true ` si la llamada asíncrona se ha enviado correctamente.

Todas las referencias que coincidan con los criterios especificados en request se devuelven en la señal browseFinished().

Por ejemplo, se puede utilizar una llamada de exploración inversa para encontrar el nodo padre de un nodo de propiedad:

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)

Ejecuta una llamada de exploración hacia adelante a partir del nodo en el que se invoca este método. La operación de exploración recopila información sobre los nodos hijos conectados al nodo y devuelve los resultados en la señal ` browseFinished()`.

Devuelve true si la llamada asíncrona se ha enviado correctamente.

Para solicitar únicamente los nodos hijos conectados al nodo mediante un tipo de referencia concreto, se debe establecer referenceType en dicho tipo de referencia. Por ejemplo, esto se puede utilizar para obtener todas las propiedades de un nodo pasando HasProperty en referenceType. Los resultados se pueden filtrar para que contengan únicamente nodos de determinadas clases de nodo estableciéndolas en nodeClassMask.

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

Esta señal se emite una vez finalizada una operación browseChildren() o browse().

children contiene información sobre todos los nodos que cumplían los criterios de browseChildren(). statusCode contiene el resultado de la operación de búsqueda. Si statusCode no es Good, el vector children pasado queda vacío.

Véase también QOpcUaReferenceDescription.

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

Llama al método OPC UA « methodNodeId » con los parámetros proporcionados a través de « args ». El resultado se devuelve en la señal « methodCallFinished ».

Devuelve ` true ` si la llamada asíncrona se ha enviado correctamente.

QOpcUaClient *QOpcUaNode::client() const

Devuelve un puntero al cliente que ha creado este nodo.

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

Esta señal se emite tras recibir una notificación de cambio de datos. value contiene el nuevo valor del atributo del nodo attr.

Véase también attribute(), serverTimestamp() y sourceTimestamp().

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

Este método desactiva la supervisión de los atributos indicados en attr.

Devuelve true si la llamada asíncrona se ha enviado correctamente.

Una vez finalizada la llamada, se emite la señal disableMonitoringFinished y monitoringStatus devuelve un valor construido por defecto con el código de estado BadMonitoredItemIdIinvalid para attr.

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

Esta señal se emite una vez finalizada una llamada asíncrona a ` disableMonitoring()`. ` statusCode ` contiene el código de estado generado por la operación. Una vez emitida esta señal, ` monitoringStatus ` devuelve un valor construido por defecto con el código de estado `BadMonitoredItemIdIinvalid` para ` attr`.

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

Este método crea un elemento supervisado para cada uno de los atributos indicados en attr. Para la creación de los elementos supervisados y de la suscripción se utilizan los ajustes de settings.

Devuelve true si la llamada asíncrona se ha enviado correctamente.

Una vez completada la llamada, se emite la señal enableMonitoringFinished. Existen varios casos de error en los que se genera un código de estado erróneo: no existe una suscripción con el identificador de suscripción especificado en settings, el nodo no existe en el servidor, el nodo no tiene el atributo solicitado o se ha alcanzado el número máximo de elementos supervisados para el servidor.

Se utiliza el mismo método para habilitar la supervisión de eventos. Los eventos son objetos especiales en el espacio de direcciones OPC UA que contienen información sobre un evento que se ha producido. Si se desencadena un evento en el servidor, un elemento de supervisión de eventos recopila valores seleccionados de los atributos de los nodos del objeto de evento y de sus nodos secundarios. Se pueden supervisar los eventos de cualquier nodo que tenga una fuente de eventos. Para supervisar los eventos de un nodo, se debe supervisar el atributo « EventNotifier » mediante un «EventFilter» que contenga los campos de evento que el usuario necesite y, opcionalmente, una cláusula «where» que se utilice para filtrar los eventos según determinados criterios (para más detalles, véase QOpcUaMonitoringParameters::EventFilter).

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

Esta señal se emite una vez finalizada una llamada asíncrona a enableMonitoring(). Una vez emitida esta señal, monitoringStatus() devuelve información válida para attr. statusCode contiene el código de estado de la operación.

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

Esta señal se emite tras la recepción de un nuevo evento.

eventFields Contiene los valores de los campos del evento en el orden especificado en la cláusula « select » del filtro de eventos.

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

Contiene todos los atributos obligatorios de la clase de nodo base de OPC UA.

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

Esta señal se emite una vez que ha finalizado en el servidor una llamada al método « methodNodeId ». « statusCode » contiene el código de estado de la llamada al método, mientras que « result » contiene los argumentos de salida del método. « result » está vacío si el método no tiene argumentos de salida o si « statusCode » no es « Good ». La variante result es un valor único si solo hay un argumento de salida, o bien contiene una lista de variantes en caso de que la función llamada haya devuelto varios argumentos de salida.

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

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

Modifica una supervisión de cambios en los datos ya existente para utilizar « filter » como filtro de cambios en los datos.

Devuelve « true » si la solicitud de modificación del filtro se ha enviado correctamente al backend.

monitoringStatusChanged Se emite un evento « attr » una vez finalizada la operación.

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

Modifica una supervisión de eventos ya existente para utilizar « eventFilter » como filtro de eventos.

Devuelve « true » si la solicitud de modificación del filtro se ha enviado correctamente al backend.

monitoringStatusChanged Se emite un evento « EventNotifier » una vez finalizada la operación.

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

Este método modifica la configuración del elemento supervisado o de la suscripción. Se intenta establecer el parámetro « item » del elemento supervisado o de la suscripción asociada a « attr » en « value ».

Devuelve « true » si la llamada asíncrona se ha enviado correctamente.

Una vez finalizada la llamada, se emite la señal « monitoringStatusChanged ». Esta señal contiene los parámetros modificados y el código de estado. Se genera un código de estado erróneo si no hay ningún elemento supervisado asociado al atributo solicitado, si la modificación del parámetro solicitado no está implementada o si el servidor ha rechazado el valor solicitado.

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

Devuelve los parámetros de supervisión asociados al atributo attr. Esto puede utilizarse para comprobar si la llamada a enableMonitoring() se ha realizado con éxito o si se han modificado los parámetros. Los valores devueltos solo son válidos una vez que se hayan emitido las señales enableMonitoringFinished o monitoringStatusChanged para attr. Si se consulta el estado antes de que se haya emitido una señal, QOpcUaMonitoringParameters::statusCode() devuelve BadNoEntryExists.

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

Esta señal se emite una vez finalizada una llamada asíncrona a ` modifyMonitoring()`. El atributo del nodo para el que se solicitó la operación se devuelve en ` attr`. ` items ` contiene los parámetros que se han modificado. ` statusCode ` contiene el resultado de la operación de modificación en el servidor.

QString QOpcUaNode::nodeId() const

Devuelve el identificador del nodo OPC UA.

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

Inicia una operación de lectura asíncrona para el atributo del nodo « attribute ». « indexRange » es una cadena que se puede utilizar para seleccionar una parte de una matriz. Se define en OPC UA 1.05, parte 4, apartado 7.27. El primer elemento de una matriz es 0; «1» devuelve el segundo elemento; «0:9» devuelve los primeros 10 elementos; «0,1» devuelve el segundo elemento de la primera fila de una matriz bidimensional.

Devuelve « true » si la llamada asíncrona se ha enviado correctamente.

Los valores de los atributos solo contienen información válida una vez que se ha emitido la señal « attributeRead ».

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

Inicia una operación de lectura asíncrona de los atributos del nodo en attributes.

Devuelve ` true ` si la llamada asíncrona se ha enviado correctamente.

Los valores de los atributos solo contienen información válida una vez que se ha emitido la señal attributeRead.

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

Inicia una solicitud de historial de eventos de lectura para este nodo utilizando los parámetros startTime, endTime, filter y numValues. El servidor utiliza el parámetro filter para determinar qué eventos y qué conjunto de sus campos se deben devolver.

Devuelve un ` QOpcUaHistoryReadResponse ` que contiene el estado de la solicitud si la solicitud asíncrona se ha enviado correctamente. Los resultados se devuelven en la señal ` QOpcUaHistoryReadResponse::readHistoryEventsFinished` (`const QList<QOpcUaHistoryEvent> &results, QOpcUa::UaStatusCode serviceResult`).

El siguiente ejemplo recupera los eventos históricos de los dos últimos días. Se devuelven hasta 10 eventos cada vez. Mientras haya más eventos que coincidan con el filtro y el intervalo de tiempo proporcionado, hasMoreData() será verdadero y se podrán recuperar más eventos mediante 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;
                     }

                     // Imprimimos lo que tenemos hasta ahora
                     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();
                 });

Esta función se introdujo en Qt 6.7.

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

Inicia una solicitud de historial de lectura para este nodo. Se trata de la representación Qt OPC UA del servicio «ReadHistory» de OPC UA, destinado a la lectura de datos históricos sin procesar, tal y como se define en la norma OPC UA 1.05, parte 4, apartado 5.10.3. Lee el historial basándose en los parámetros startTime, endTime, numValues y returnBounds.

Devuelve un ` QOpcUaHistoryReadResponse ` que contiene el estado de la solicitud si la solicitud asíncrona se ha enviado correctamente. Los resultados se devuelven en la señal ` QOpcUaHistoryReadResponse::readHistoryDataFinished(const QList<QOpcUaHistoryData> &results, QOpcUa::UaStatusCode serviceResult)`.

En el siguiente ejemplo, se solicitan y se muestran los datos históricos de los dos últimos días de un nodo. El resultado se limita a diez valores por nodo.

QOpcUaHistoryReadResponse*response = node->readHistoryRaw(QDateTime::currentDateTime(),
                                                           QDateTime::currentDateTime().addDays(-2),
                                                           10,
                                                           true);
if (response) {
    QObject::connect(response123, &QOpcUaHistoryReadResponse::readHistoryDataFinished,
                     [] (QList<QOpcUaHistoryData> resultados, QOpcUa::UaStatusCode resultadoDelServicio) {
        if (resultadoDelServicio != 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();
            }
        }
    });
}

Esta función se introdujo en Qt 6.3.

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

Inicia una solicitud de historial de lectura para este nodo. El parámetro adicional « timestampsToReturn » determina qué marcas de tiempo se devolverán para cada valor.

Esta función se introdujo en Qt 6.7.

bool QOpcUaNode::readValueAttribute()

Inicia una operación de lectura asíncrona del atributo «Value» del nodo.

Devuelve « true » si la llamada asíncrona se ha enviado correctamente.

Véase también readAttributes().

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

Resuelve la ruta de navegación path en uno o varios identificadores de nodo a partir de este nodo, utilizando el servicio «TranslateBrowsePathsToNodeIds» especificado en la norma OPC UA 1.05, parte 4, apartado 5.8.4.

Devuelve true si la llamada asíncrona se ha enviado correctamente.

TranslateBrowsePathsToNodeIds se utiliza principalmente para programar en función de definiciones de tipo, en lugar de un conjunto concreto de nodos en el espacio de direcciones de OPC UA. Por ejemplo, una definición de tipo para un modelo de máquina podría consistir en un nodo inicial con el nombre de navegación «Machine», que tiene un componente con el nombre de navegación «Fan». El ventilador tiene un componente con el nombre de navegación «RPM», que es un nodo de variable que contiene el valor actual de RPM del ventilador. Existen varias máquinas de ese tipo y cada una de ellas se asigna al espacio de direcciones OPC UA como un objeto del tipo de máquina. Para cada uno de estos objetos de máquina, la ruta desde el nodo de la máquina hasta el nodo «RPM» es la misma. Si un cliente desea leer el valor actual de RPM, debe llamar a la función resolveBrowsePath() indicando el nodo de la máquina como nodo inicial y la ruta de navegación desde la máquina hasta el nodo «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);

El resultado devuelto por ` resolveBrowsePathFinished()` contiene el identificador del nodo «RPM», que puede utilizarse para acceder a los atributos del nodo:

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;
   }
   // Conectar ranuras, llamar a métodos
} 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)

Esta señal se emite una vez finalizada la llamada a resolveBrowsePath().

QOpcUaBrowsePathTarget targets contiene los resultados; es el código de estado de la operación. Si no es , queda vacío. La ruta de navegación es la ruta de navegación de la solicitud. Se puede utilizar para asociar los resultados con las solicitudes. statusCode statusCode Good targets path

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

Devuelve la marca de tiempo del servidor correspondiente a la última lectura o modificación de datos de attribute. Antes de que se haya emitido al menos una señal de attributeRead o dataChangeOccurred, se devuelve una fecha y hora nulas.

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

Devuelve la marca de tiempo de origen correspondiente a la última lectura o al último cambio de datos de attribute. Antes de que se haya emitido al menos una señal de attributeRead o dataChangeOccurred, se devuelve una fecha y hora nulas.

QVariant QOpcUaNode::valueAttribute() const

Devuelve el valor del atributo «Value» del nodo.

El valor devuelto solo es válido después de que el atributo «Value» se haya leído o escrito correctamente, o después de que un cambio de datos procedente de una supervisión haya actualizado la caché de atributos. Esto se indica mediante una señal « attributeRead()» o « attributeWritten()» con el código de estado « Good », o mediante una señal « dataChangeOccurred()» para el atributo «Value».

Si no hay ningún valor en la caché de atributos, se devuelve un QVariant no válido.

Véanse también readValueAttribute(), writeValueAttribute() y valueAttributeError().

QOpcUa::UaStatusCode QOpcUaNode::valueAttributeError() const

Devuelve el código de error del atributo «Value» del nodo. El código de estado « Good » indica un valor de retorno válido para la función « valueAttribute()». Si no hay ninguna entrada en la caché de atributos, se devuelve « BadNoEntryExists ».

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

Esta señal se emite después de que el atributo «value» de la caché de atributos se haya actualizado mediante una notificación de cambio de datos procedente del servidor, una operación de lectura o una operación de escritura. « value » contiene el nuevo valor del atributo «value».

Esta función se introdujo en Qt 6.7.

Véase también attribute(), attributeError(), serverTimestamp(), sourceTimestamp() y attributeUpdated().

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

Escribe value en el atributo indicado en attribute utilizando la información de tipo de type. Devuelve true si la llamada asíncrona se ha enviado correctamente.

Si se omite el parámetro type, el backend intenta encontrar el tipo correcto. Se asumen los siguientes tipos por defecto:

Qt MetaTypeTipo OPC UA
BoolBoolean
UCharByte
CharSByte
UShortUInt16
ShortInt16
IntInt32
UIntUInt32
ULongLongUInt64
LongLongInt64
DoubleDouble
FloatFloat
QStringCadena
QDateTimeFecha y hora
QByteArrayByteString
QUuidGUID

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

Escribe « value » en el atributo indicado en « attribute » utilizando la información de tipo de « type ». Para « indexRange », consulta « readAttributeRange()».

Devuelve true si la llamada asíncrona se ha enviado correctamente.

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

Realiza una operación de escritura de los atributos y valores especificados en toWrite.

Devuelve ` true ` si la llamada asíncrona se ha enviado correctamente.

El parámetro ` valueAttributeType ` se puede utilizar para proporcionar información sobre el tipo del atributo «value». El resto de atributos tienen tipos conocidos.

Véase también writeAttribute().

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

Escribe value en el atributo «Value» del nodo utilizando la información de tipo de type.

Devuelve ` true ` si la llamada asíncrona se ha enviado correctamente.

Véase también writeAttribute().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.