En esta página

QOpcUaClient Class

QOpcUaClient permite interactuar con un servidor OPC UA. Más información...

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

Tipos públicos

enum ClientError { NoError, InvalidUrl, AccessDenied, ConnectionError, UnknownError, …, CertificateUntrusted }
enum ClientState { Disconnected, Connecting, Connected, Closing }

Propiedades

Funciones públicas

virtual ~QOpcUaClient()
bool addNode(const QOpcUaAddNodeItem &nodeToAdd)
bool addReference(const QOpcUaAddReferenceItem &referenceToAdd)
(since QtOpcUa 5.13) QOpcUaApplicationIdentity applicationIdentity() const
const QOpcUaAuthenticationInformation &authenticationInformation() const
QString backend() const
(since QtOpcUa 5.13) void connectToEndpoint(const QOpcUaEndpointDescription &endpoint)
(since 6.6) QOpcUaConnectionSettings connectionSettings() const
bool deleteNode(const QString &nodeId, bool deleteTargetReferences = true)
bool deleteReference(const QOpcUaDeleteReferenceItem &referenceToDelete)
void disconnectFromEndpoint()
QOpcUaEndpointDescription endpoint() const
QOpcUaClient::ClientError error() const
bool findServers(const QUrl &url, const QStringList &localeIds = QStringList(), const QStringList &serverUris = QStringList())
bool isNamespaceAutoupdateEnabled() const
QStringList namespaceArray() const
int namespaceAutoupdateInterval() const
QOpcUaNode *node(const QOpcUaExpandedNodeId &expandedNodeId)
QOpcUaNode *node(const QString &nodeId)
(since QtOpcUa 5.13) QOpcUaPkiConfiguration pkiConfiguration() const
QOpcUaQualifiedName qualifiedNameFromNamespaceUri(const QString &namespaceUri, const QString &name, bool *ok = nullptr) const
(since 6.3) QOpcUaHistoryReadResponse *readHistoryData(const QOpcUaHistoryReadRawRequest &request)
(since 6.7) QOpcUaHistoryReadResponse *readHistoryEvents(const QOpcUaHistoryReadEventRequest &request)
bool readNodeAttributes(const QList<QOpcUaReadItem> &nodesToRead)
(since 6.7) bool registerNodes(const QStringList &nodesToRegister)
bool requestEndpoints(const QUrl &url)
QString resolveExpandedNodeId(const QOpcUaExpandedNodeId &expandedNodeId, bool *ok = nullptr) const
(since QtOpcUa 5.13) void setApplicationIdentity(const QOpcUaApplicationIdentity &identity)
void setAuthenticationInformation(const QOpcUaAuthenticationInformation &authenticationInformation)
(since 6.6) void setConnectionSettings(const QOpcUaConnectionSettings &connectionSettings)
void setNamespaceAutoupdate(bool isEnabled)
void setNamespaceAutoupdateInterval(int interval)
(since QtOpcUa 5.13) void setPkiConfiguration(const QOpcUaPkiConfiguration &config)
QOpcUaClient::ClientState state() const
(since QtOpcUa 5.14) QStringList supportedSecurityPolicies() const
(since QtOpcUa 5.14) QList<QOpcUaUserTokenPolicy::TokenType> supportedUserTokenTypes() const
(since 6.7) bool unregisterNodes(const QStringList &nodesToUnregister)
bool updateNamespaceArray()
bool writeNodeAttributes(const QList<QOpcUaWriteItem> &nodesToWrite)

Señales

void addNodeFinished(QOpcUaExpandedNodeId requestedNodeId, QString assignedNodeId, QOpcUa::UaStatusCode statusCode)
void addReferenceFinished(QString sourceNodeId, QString referenceTypeId, QOpcUaExpandedNodeId targetNodeId, bool isForwardReference, QOpcUa::UaStatusCode statusCode)
(since QtOpcUa 5.13) void connectError(QOpcUaErrorState *errorState)
void connected()
void deleteNodeFinished(QString nodeId, QOpcUa::UaStatusCode statusCode)
void deleteReferenceFinished(QString sourceNodeId, QString referenceTypeId, QOpcUaExpandedNodeId targetNodeId, bool isForwardReference, QOpcUa::UaStatusCode statusCode)
void disconnected()
void endpointsRequestFinished(QList<QOpcUaEndpointDescription> endpoints, QOpcUa::UaStatusCode statusCode, QUrl requestUrl)
void errorChanged(QOpcUaClient::ClientError error)
void findServersFinished(QList<QOpcUaApplicationDescription> servers, QOpcUa::UaStatusCode statusCode, QUrl requestUrl)
void namespaceArrayChanged(QStringList namespaces)
void namespaceArrayUpdated(QStringList namespaces)
(since QtOpcUa 5.13) void passwordForPrivateKeyRequired(QString keyFilePath, QString *password, bool previousTryWasInvalid)
void readNodeAttributesFinished(QList<QOpcUaReadResult> results, QOpcUa::UaStatusCode serviceResult)
(since 6.7) void registerNodesFinished(const QStringList &nodesToRegister, const QStringList &registeredNodeIds, QOpcUa::UaStatusCode statusCode)
void stateChanged(QOpcUaClient::ClientState state)
(since 6.7) void unregisterNodesFinished(const QStringList &nodesToUnregister, QOpcUa::UaStatusCode statusCode)
void writeNodeAttributesFinished(QList<QOpcUaWriteResult> results, QOpcUa::UaStatusCode serviceResult)

Descripción detallada

QOpcUaClient

QOpcUaClient implementa las funciones básicas de cliente para comunicarse con dispositivos y aplicaciones compatibles con OPC UA. Esto incluye consultar un servidor de descubrimiento en busca de servidores conocidos, solicitar una lista de puntos finales a un servidor, así como conectarse y desconectarse.

Tras conectarse correctamente a un servidor, QOpcUaClient permite obtener objetos « QOpcUaNode », que facilitan una mayor interacción con los nodos del servidor OPC UA. Para operaciones que afectan a varios nodos, QOpcUaClient ofrece una API que permite leer múltiples atributos de varios nodos en una única solicitud al servidor.

QOpcUaClient también mantiene una copia local de la matriz de espacios de nombres del servidor, que se crea tras una conexión satisfactoria. Esta información puede consultarse o actualizarse mientras dure la conexión. La copia de la matriz de espacios de nombres también se utiliza para la resolución de identificadores de nodo expandidos y la creación de nombres calificados a partir de un URI de espacio de nombres.

Direccionamiento de nodos

Para obtener una introducción a los nodos y a los identificadores de nodo, consulte QOpcUaNode.

Uso

Crea un objeto ` QOpcUaClient ` utilizando ` QOpcUaProvider`, solicita una lista de puntos finales al servidor mediante ` requestEndpoints ` y llama a ` connectToEndpoint()` para conectarte a uno de los puntos finales disponibles. Una vez establecida la conexión, se solicita un objeto ` QOpcUaNode ` para el nodo raíz.

QOpcUaProvider provider;
if (provider.availableBackends().isEmpty())
    return;
QOpcUaClient*client = provider.createClient(provider.availableBackends()[0]);
if (!client)
    return;
// Conectarse a la señal «stateChanged». Se pueden utilizar ranuras compatibles de QObject en lugar de una lambda.
QObject::connect(client, &QOpcUaClient::stateChanged, [client](QOpcUaClient::ClientState estado) {
    qDebug() << "Client state changed:" << state;
   if (estado== QOpcUaClient::ClientState::Connected) {
        QOpcUaNode*nodo = cliente->nodo("ns=0;i=84");
        si (nodo)
            qDebug() << "A node object has been created";
    }
});

QObject::connect(client, &QOpcUaClient::endpointsRequestFinished,
                 [client](QList<QOpcUaEndpointDescription> endpoints) {
    qDebug() << "Endpoints returned:" << endpoints.count();
   if (endpoints.size())
        client->connectToEndpoint(endpoints.first()); // Conectarse al primer punto final de la lista
});

client->requestEndpoints(QUrl("opc.tcp://127.0.0.1:4840")); // Solicita una lista de puntos finales al servidor

Documentación sobre los tipos de miembros

enum QOpcUaClient::ClientError

Este tipo de enumeración especifica el estado de error actual del cliente.

ConstanteValorDescripción
QOpcUaClient::NoError0No se ha producido ningún error.
QOpcUaClient::InvalidUrl1Se ha especificado incorrectamente la URL a la que conectarse o ha fallado la conexión a dicha URL.
QOpcUaClient::AccessDenied2Ha fallado el intento de conectarse a un servidor con nombre de usuario y contraseña debido a credenciales incorrectas.
QOpcUaClient::ConnectionError3Se ha producido un error en la conexión.
QOpcUaClient::UnknownError4Se ha producido un error desconocido.
QOpcUaClient::UnsupportedAuthenticationInformation5No se admite el tipo o los datos de la información de autenticación proporcionados.
QOpcUaClient::InvalidAuthenticationInformation6La información de autenticación proporcionada no es válida.
QOpcUaClient::InvalidEndpointDescription7La descripción del punto final no es válida, por ejemplo, debido a una URL vacía o a la ausencia de tokens de identidad de usuario.
QOpcUaClient::NoMatchingUserIdentityTokenFound8El punto final seleccionado no admite el tipo de token solicitado ni las políticas admitidas.
QOpcUaClient::UnsupportedSecurityPolicy9La política de seguridad del punto final no es compatible.
QOpcUaClient::InvalidPki10No se ha podido cargar un certificado o una clave de la PKI, o bien no es válido.
QOpcUaClient::CertificateUntrusted11El certificado del servidor no es de confianza

enum QOpcUaClient::ClientState

Este tipo de enumeración especifica el estado de la conexión del cliente.

ConstanteValorDescripción
QOpcUaClient::Disconnected0El cliente no está conectado a ningún servidor.
QOpcUaClient::Connecting1El cliente se está conectando actualmente a un servidor.
QOpcUaClient::Connected2El cliente está conectado a un servidor.
QOpcUaClient::Closing3El cliente ha estado conectado y solicita desconectarse del servidor.

Documentación de propiedades

[read-only] error : ClientError

Especifica el estado de error actual del cliente.

Funciones de acceso:

QOpcUaClient::ClientError error() const

Señal del notificador:

void errorChanged(QOpcUaClient::ClientError error)

[read-only] state : ClientState

Especifica el estado actual de la conexión del cliente.

Funciones de acceso:

QOpcUaClient::ClientState state() const

Señal del notificador:

void stateChanged(QOpcUaClient::ClientState state)

Documentación de la función miembro

[virtual noexcept] QOpcUaClient::~QOpcUaClient()

Elimina la instancia de « QOpcUaClient ».

bool QOpcUaClient::addNode(const QOpcUaAddNodeItem &nodeToAdd)

Añade al servidor el nodo descrito en nodeToAdd.

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

El éxito de la operación se devuelve en la señal addNodeFinished().

El siguiente código de ejemplo añade un nuevo nodo «Variable» en el servidor:

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

Véase también deleteNode(), addNodeFinished() y QOpcUaAddNodeItem.

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

Esta señal se emite una vez finalizada una operación addNode(). requestedNodeId es el identificador del nodo solicitado en la llamada addNode(), assignedNodeId es el identificador que el servidor ha asignado al nuevo nodo. statusCode contiene el resultado de la operación. Si el resultado es Bad, assignedNodeId está vacío y no se ha añadido ningún nodo al espacio de direcciones del servidor.

bool QOpcUaClient::addReference(const QOpcUaAddReferenceItem &referenceToAdd)

Añade al servidor la referencia descrita en referenceToAdd.

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

El éxito de la operación se devuelve en la señal addReferenceFinished().

El siguiente código de ejemplo añade una referencia a un nodo en la carpeta «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);

Véase también deleteReference(), addReferenceFinished() y QOpcUaAddReferenceItem.

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

Esta señal se emite una vez finalizada una operación de tipo « addReference()». « sourceNodeId », « referenceTypeId », « targetNodeId » y « isForwardReference » son los valores de la llamada a « addReference()». « statusCode » contiene el resultado de la operación.

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

Devuelve la identidad de aplicación de esta instancia de ` QOpcUaClient `.

Esta función se introdujo en QtOpcUa 5.13.

Véase también setApplicationIdentity().

const QOpcUaAuthenticationInformation &QOpcUaClient::authenticationInformation() const

Devuelve la información de autenticación actual.

Véase también setAuthenticationInformation().

QString QOpcUaClient::backend() const

Devuelve el nombre del backend utilizado por esta instancia de QOpcUaClient, por ejemplo, «open62541».

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

Esta señal se emite cuando se produce un error durante el establecimiento de la conexión. El parámetro « errorState » contiene información sobre el error.

En caso de errores del lado del cliente, estos pueden ignorarse llamando a QOpcUaErrorState::setIgnoreError en el objeto.

Durante la ejecución de un slot conectado a esta señal, el backend se detiene y espera a que todos los slots devuelvan un resultado. Esto permite mostrar un cuadro de diálogo al usuario final para preguntarle, por ejemplo, si confía en un certificado desconocido antes de que el backend continúe.

Esta función se introdujo en QtOpcUa 5.13.

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

Se conecta al punto final OPC UA indicado en endpoint.

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

Normalmente, la lista de puntos finales disponibles se obtiene llamando a QOpcUaClient::requestEndpoints().

Si el punto final requiere autenticación mediante nombre de usuario, se debe establecer al menos un nombre de usuario en QOpcUaAuthenticationInformation. Si se llama a esta función antes de configurar la información de autenticación, se utilizará la autenticación anónima.

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

client->setAuthenticationInformation(authInfo);

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Esta función se introdujo en QtOpcUa 5.13.

Véase también connected(), stateChanged(), setAuthenticationInformation() y QOpcUaEndpointDescription.

[signal] void QOpcUaClient::connected()

Esta señal se emite cuando se ha establecido una conexión.

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

Devuelve la configuración de conexión de este cliente.

Esta función se introdujo en Qt 6.6.

Véase también setConnectionSettings().

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

Elimina del servidor el nodo con el identificador nodeId. Si deleteTargetReferences es false, solo se eliminan las referencias cuyo nodo de origen sea nodeId. Si deleteTargetReferences es true, también se eliminan las referencias cuyo destino sea nodeId.

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

El éxito de la operación se devuelve en la señal deleteNodeFinished().

El siguiente código de ejemplo elimina un nodo y todas las referencias al mismo del servidor:

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

Véase también addNode() y deleteNodeFinished().

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

Esta señal se emite una vez finalizada la operación « deleteNode()». « nodeId » es el identificador del nodo obtenido en la llamada a « deleteNode()». « statusCode » contiene el resultado de la operación.

bool QOpcUaClient::deleteReference(const QOpcUaDeleteReferenceItem &referenceToDelete)

Elimina del servidor la referencia descrita por ` referenceToDelete `.

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

El resultado de la operación se devuelve en la señal deleteReferenceFinished().

El siguiente código de ejemplo elimina una referencia a un nodo de la carpeta «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);

Véase también addReference(), deleteReferenceFinished() y QOpcUaDeleteReferenceItem.

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

Esta señal se emite una vez finalizada una operación de tipo « deleteReference()». « sourceNodeId », « referenceTypeId », « targetNodeId » y « isForwardReference » son los valores de la llamada a « deleteReference()». « statusCode » contiene el resultado de la operación.

[invokable] void QOpcUaClient::disconnectFromEndpoint()

Se desconecta del servidor.

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Véase también disconnected() y connectToEndpoint().

[signal] void QOpcUaClient::disconnected()

Esta señal se emite cuando se ha cerrado una conexión a raíz de una solicitud de cierre.

QOpcUaEndpointDescription QOpcUaClient::endpoint() const

Devuelve la descripción del punto final al que el cliente está conectado actualmente o al que estuvo conectado por última vez.

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

Esta señal se emite una vez finalizada la operación requestEndpoints(). statusCode contiene el resultado de la operación. Si el resultado es Good, endpoints contiene las descripciones de todos los puntos finales disponibles en el servidor. requestUrl contiene la URL que se utilizó en la llamada requestEndpoints().

QOpcUaClient::ClientError QOpcUaClient::error() const

Devuelve el estado de error actual del cliente.

Nota: Funcióngetter para la propiedad «error».

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

Inicia una solicitud asíncrona FindServers para leer una lista de servidores conocidos desde un servidor o un servidor de descubrimiento en url. Devuelve true si la llamada asíncrona se ha enviado correctamente.

localeIds Se puede utilizar para seleccionar el idioma de los nombres de las aplicaciones devueltos por la solicitud. El formato se especifica en OPC UA 1.05, parte 3, apartado 8.4; por ejemplo, «en» para inglés o «de-DE» para alemán (Alemania). Si se especifica más de un identificador de configuración regional, el servidor utiliza la primera coincidencia. Si no hay ninguna coincidencia o localeIds está vacío, el servidor elige una configuración regional por defecto.

serverUris Se puede utilizar para restringir los resultados a los servidores que tengan un applicationUri coincidente en su descripción de la aplicación. Por ejemplo, para encontrar la URL actual del servidor con el applicationUri «MyPLC», se puede utilizar la siguiente llamada:

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

Los resultados se devuelven en la señal findServersFinished().

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

Esta señal se emite una vez finalizada una operación findServers(). statusCode contiene el resultado de la operación. Si el resultado es Good, servers contiene las descripciones de aplicación de todos los servidores conocidos por el servidor consultado que se ajustan a los criterios de filtrado. requestUrl contiene la URL que se utilizó en la llamada findServers().

bool QOpcUaClient::isNamespaceAutoupdateEnabled() const

Devuelve si la actualización automática de la matriz de espacios de nombres está activada.

QStringList QOpcUaClient::namespaceArray() const

Devuelve el valor almacenado en caché de la matriz de espacios de nombres.

El valor solo es válido después de que se haya emitido la señal namespaceArrayUpdated().

Véase también ` updateNamespaceArray()` y ` namespaceArrayUpdated()`.

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

Esta señal se emite después de que haya cambiado la matriz de espacios de nombres. namespaces contiene el contenido de la tabla de espacios de nombres del servidor. El índice de una entrada en namespaces se corresponde con el índice del espacio de nombres utilizado en el identificador del nodo.

Véase también namespaceArrayUpdated() y updateNamespaceArray().

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

Esta señal se emite una vez finalizada una operación de « updateNamespaceArray ». « namespaces » contiene el contenido de la tabla de espacios de nombres del servidor. El índice de una entrada en « namespaces » se corresponde con el índice del espacio de nombres utilizado en el identificador del nodo.

Si el contenido de la matriz de espacios de nombres permanece igual tras la actualización, esta señal se emite de todos modos.

Véanse también namespaceArrayChanged() y updateNamespaceArray().

int QOpcUaClient::namespaceAutoupdateInterval() const

Devuelve el intervalo de actualización revisado actual de la matriz de espacios de nombres.

Véase también setNamespaceAutoupdateInterval(int interval).

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

Devuelve un objeto « QOpcUaNode » asociado al nodo OPC UA identificado por expandedNodeId. El autor de la llamada se convierte en el propietario del objeto del nodo.

Si el nodo no se encuentra en el servidor al que se está conectado actualmente, no se puede resolver el espacio de nombres, el identificador del nodo tiene un formato incorrecto o el cliente no está conectado, se devuelve nullptr.

Véase también updateNamespaceArray().

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

Devuelve un objeto ` QOpcUaNode ` asociado al nodo OPC UA identificado por ` nodeId`. El llamante pasa a ser el propietario del objeto del nodo.

Si el cliente no está conectado, se devuelve un objeto ` nullptr `. Los backends también pueden devolver ` nullptr ` en otros casos de error (por ejemplo, si el identificador del nodo tiene un formato incorrecto).

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

Esta señal se emite cuando se requiere una contraseña para una clave privada cifrada. El parámetro keyFilePath contiene la ruta del archivo de la clave que se utiliza. El parámetro previousTryWasInvalid es «true» si un intento anterior de descifrar la clave ha fallado (es decir, contraseña no válida). El parámetro password apunta a un objeto QString que debe rellenarse con la contraseña real de la clave. En caso de que el intento anterior haya fallado, contiene la contraseña utilizada anteriormente.

Durante la ejecución de una ranura conectada a esta señal, el backend se detiene y espera a que todas las ranuras devuelvan un resultado. Esto permite que aparezca un cuadro de diálogo para solicitar la contraseña al usuario final.

Esta función se introdujo en QtOpcUa 5.13.

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

Devuelve la configuración PKI de la aplicación de esta instancia de ` QOpcUaClient `.

Esta función se introdujo en QtOpcUa 5.13.

Véase también setPkiConfiguration().

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

Intenta crear un nombre calificado a partir de namespaceUri y la cadena de nombre name. Devuelve el nombre calificado resultante. Se devuelve un nombre calificado vacío si no se puede resolver namespaceUri.

ok se establecerá en true si la resolución de la URI del espacio de nombres se ha realizado correctamente. Si no se ha podido resolver la URI del espacio de nombres, ok se establecerá en false.

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

Inicia un historial de lectura sin procesar request para uno o varios nodos. Se trata de la representación Qt OPC UA del servicio «ReadHistory» de OPC UA para 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.

En un « QOpcUaHistoryReadRawRequest » se pueden especificar la marca de tiempo de inicio, la marca de tiempo de finalización, el número de valores por nodo, «returnBounds» y los nodos que se van a leer.

Devuelve un objeto ` 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 e imprimen los datos históricos de los dos últimos días de dos nodos. El resultado se limita a diez valores por nodo.

QOpcUaHistoryReadRawRequest request(
            { QOpcUaReadItem("ns=1;s=myValue1"), QOpcUaReadItem("ns=1;s=myValue2") },
            QDateTime::currentDateTime(),
            QDateTime::currentDateTime().addDays(-2),
            10,
            true);

QOpcUaHistoryReadResponse*response = m_client->readHistoryData(solicitud);
if (response) {
   QObject::connect(response, &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 *QOpcUaClient::readHistoryEvents(const QOpcUaHistoryReadEventRequest &request)

Inicia una solicitud de historial de eventos de lectura para uno o varios identificadores de nodo con los parámetros que figuran en request.

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 para dos nodos. Se devuelven hasta 10 eventos por nodo 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 obtener más eventos mediante readMoreData().

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

const QOpcUaHistoryReadEventRequest request({ QOpcUaReadItem("ns=2;s=EventHistorian"), QOpcUaReadItem("ns=2;s=EventHistorian2") },
                                            QDateTime::currentDateTime().addDays(-2), QDateTime::currentDateTime(),
                                            filter, 10);

// El usuario debe liberar el objeto de respuesta una vez que se hayan recuperado todos los datos deseados
const auto response = opcuaClient->readHistoryEvents(request);

QObject::connect(response, &QOpcUaHistoryReadResponse::readHistoryEventsFinished, this,
                 [response](const QList<QOpcUaHistoryEvent> &results, QOpcUa::UaStatusCode serviceResult) {
    if (serviceResult != QOpcUa::UaStatusCode::Good) {
        qDebug() << "Service call failed with" << serviceResult;
       return;
    }

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

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

Inicia una lectura de varios atributos en diferentes nodos. Se pueden especificar el identificador del nodo, el atributo y un rango de índices para cada entrada en ` nodesToRead`.

Devuelve «true» si la solicitud asíncrona se ha enviado correctamente. Los resultados se devuelven en la señal readNodeAttributesFinished().

Esta función de lectura ofrece una forma alternativa de leer los atributos de los nodos, que puede utilizarse en situaciones en las que sea necesario leer los valores de un gran número de atributos de nodos en diferentes nodos sin necesidad de recurrir a otras características de la API basada en ` QOpcUaNode `, como la supervisión de cambios en los valores. Todos los elementos de lectura de la solicitud se envían al servidor en una única solicitud y se responden en una única respuesta que genera una única señal ` readNodeAttributesFinished()`. Esto reduce la sobrecarga de red y el número de conexiones de ranuras de señal si intervienen muchos nodos diferentes.

En el siguiente ejemplo, se leen el atributo «display name» y los dos rangos de índice «0:2» y «5:7» del atributo «value» del mismo nodo, así como la totalidad del atributo «value» de un segundo nodo, mediante una única llamada al servicio:

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

Véase también « QOpcUaReadItem » y « readNodeAttributesFinished()».

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

Esta señal se emite una vez finalizada una operación readNodeAttributes().

Los elementos de results siguen el mismo orden que los elementos de la solicitud. Para cada elemento solicitado, hay un valor junto con marcas de tiempo y el código de estado en results. serviceResult contiene el código de estado del servicio de lectura de OPC UA.

Véase también readNodeAttributes(), QOpcUaReadResult y QOpcUaReadItem.

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

Registra los identificadores de los nodos en nodesToRegister en el servidor y devuelve true si la solicitud se ha enviado correctamente. Los resultados se devuelven a través de la señal registerNodesFinished().

El servicio de registro de nodos se utiliza para indicar al servidor que se va a acceder con frecuencia a un nodo, de modo que pueda realizar operaciones como mantener abierta la conexión a un recurso externo. El servidor también puede devolver un identificador de nodo alias, que se recomienda que sea numérico. Esto puede resultar útil si se utiliza en muchas solicitudes un nodo con un identificador de nodo que es una cadena larga. La ganancia real de rendimiento (si la hay) depende de la implementación del servidor.

Solo se garantiza que los identificadores de nodo registrados sean válidos para la sesión actual. Cualquier registro que ya no sea necesario debe darse de baja lo antes posible para que el servidor pueda liberar los recursos asociados.

Esta función se introdujo en Qt 6.7.

Véase también ` unregisterNodes()`.

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

Esta señal se emite una vez finalizada una operación ` registerNodes()`. ` nodesToRegister ` contiene los identificadores de los nodos de la solicitud, con fines de correlación. Los identificadores de los nodos devueltos por el servidor se encuentran en ` registeredNodeIds ` y siguen el mismo orden que los identificadores de la solicitud. ` statusCode ` indica si la operación se ha realizado correctamente.

Esta función se introdujo en Qt 6.7.

Véase también registerNodes().

bool QOpcUaClient::requestEndpoints(const QUrl &url)

Inicia una solicitud asíncrona GetEndpoints para leer una lista de puntos finales disponibles del servidor en url. Devuelve true si la llamada asíncrona se ha enviado correctamente.

La información sobre los puntos finales se devuelve en la señal endpointsRequestFinished().

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

Intenta resolver expandedNodeId en una cadena de identificación de nodo con un índice numérico de espacio de nombres. Devuelve la cadena de identificación de nodo si la conversión se ha realizado correctamente.

Se devuelve una cadena vacía si no se puede resolver el índice del espacio de nombres o si la parte del identificador del identificador de nodo expandido tiene un formato incorrecto. ok se establecerá en true si la conversión se ha realizado correctamente. Si no se ha podido resolver el identificador de nodo expandido, ok se establecerá en false.

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

Establece la identidad de la aplicación para esta instancia de ` QOpcUaClient ` en ` identity`.

Esta función se introdujo en QtOpcUa 5.13.

Véase también applicationIdentity().

void QOpcUaClient::setAuthenticationInformation(const QOpcUaAuthenticationInformation &authenticationInformation)

Establece la información de autenticación de este cliente en authenticationInformation.

Véanse también authenticationInformation() y connectToEndpoint().

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

Establece los parámetros de conexión de este cliente a connectionSettings.

Ejemplo:

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

Los valores de connectionSettings se aplican a cualquier nueva conexión a partir de este momento.

El complemento open62541 permite actualizar los identificadores de configuración regional de la sesión para la conexión actual. El resto de valores que se modifiquen, pero que no admitan la actualización mientras se está conectado, generarán un mensaje de advertencia y se aplicarán durante la siguiente llamada a ` connectToEndpoint()`.

Esta función se introdujo en Qt 6.6.

Véase también connectionSettings().

void QOpcUaClient::setNamespaceAutoupdate(bool isEnabled)

Permite la actualización automática de la tabla de espacios de nombres.

Al habilitar esta opción, la copia local de la tabla de espacios de nombres se mantendrá actualizada automáticamente. Se emitirá un evento « namespaceArrayUpdated » cuando cambie el array. « isEnabled » determina si la actualización automática está habilitada o deshabilitada.

Se creará una suscripción en el nodo del servidor para realizar un seguimiento de los cambios. En caso de que un servidor no admita suscripciones, esto no funcionará y isNamespaceAutoupdateEnabled devolverá false.

Véase también namespaceArray() y namespaceArrayUpdated().

void QOpcUaClient::setNamespaceAutoupdateInterval(int interval)

Establece el intervalo de la suscripción a la tabla de espacios de nombres.

El servidor puede modificar la suscripción.

interval Determina el intervalo para comprobar si hay cambios, en milisegundos. El valor por defecto es una vez por segundo.

Véase también namespaceAutoupdateInterval() y QOpcUaClient::setNamespaceAutoupdate(bool isEnabled).

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

Establece la configuración PKI de la aplicación para esta instancia de QOpcUaClient en config.

Esta función se introdujo en QtOpcUa 5.13.

Véase también pkiConfiguration().

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

Devuelve las políticas de seguridad compatibles con el backend utilizado.

Esta función está disponible actualmente como «Technology Preview» y, por lo tanto, la API y la funcionalidad que ofrece pueden estar sujetas a cambios en cualquier momento sin previo aviso.

Esta función se introdujo en QtOpcUa 5.14.

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

Devuelve los tipos de tokens de usuario compatibles con el backend utilizado.

Esta función está disponible actualmente como «Technology Preview» (vista previa tecnológica) y, por lo tanto, la API y la funcionalidad que ofrece pueden estar sujetas a cambios en cualquier momento sin previo aviso.

Esta función se introdujo en QtOpcUa 5.14.

Véase también QOpcUaUserTokenPolicy::TokenType.

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

Da de baja los ID de nodo en nodesToUnregister en el servidor y devuelve true si la solicitud se ha enviado correctamente. Los resultados se devuelven en la señal unregisterNodesFinished().

Los identificadores de nodo que se deben pasar a ` nodesToUnregister ` deben haberse obtenido mediante ` registerNodes()`.

Esta función se introdujo en Qt 6.7.

Véase también registerNodes().

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

Esta señal se emite una vez finalizada una operación ` unregisterNodes()`. ` nodesToUnregister ` contiene los identificadores de los nodos de la solicitud, con fines de correlación. ` statusCode ` indica si la operación se ha realizado correctamente.

Esta función se introdujo en Qt 6.7.

Véase también unregisterNodes().

bool QOpcUaClient::updateNamespaceArray()

Solicita al servidor una actualización de la matriz de espacios de nombres. Devuelve un valor de « true » si la operación se ha enviado correctamente.

La señal namespaceArrayUpdated() se emite una vez finalizada la operación.

Véanse también ` namespaceArray()` y ` namespaceArrayUpdated()`.

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

Inicia una operación de escritura de varios atributos en diferentes nodos. Para cada entrada de nodesToWrite se pueden especificar el identificador del nodo, el atributo, el valor, el tipo de valor y un rango de índices.

Devuelve ` true ` si la solicitud asíncrona se ha enviado correctamente. Los resultados se devuelven en la señal ` writeNodeAttributesFinished()`.

Esta función de escritura ofrece una forma alternativa de escribir atributos de nodos que puede utilizarse en situaciones en las que sea necesario escribir los valores de un gran número de atributos de nodos en diferentes nodos sin necesidad de recurrir a otras características de la API basada en QOpcUaNode, como la supervisión de cambios en los valores. Todos los elementos de escritura de la solicitud se envían al servidor en una única solicitud y se responden en una única respuesta que genera una única señal writeNodeAttributesFinished(). Esto reduce la sobrecarga de red y el número de conexiones de ranuras de señal si intervienen muchos nodos diferentes.

En el siguiente ejemplo, los atributos «Values» de dos nodos diferentes se escriben en una sola llamada. El segundo nodo tiene un valor de matriz del que solo se sobrescriben los dos primeros elementos:

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

Véase también « QOpcUaWriteItem » y « writeNodeAttributesFinished()».

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

Esta señal se emite una vez finalizada una operación writeNodeAttributes().

Los elementos de results siguen el mismo orden que los elementos de la solicitud de escritura. Contienen el valor, las marcas de tiempo y el código de estado recibidos del servidor, así como el identificador del nodo, el atributo y el rango de índices del elemento de escritura. Esto facilita la correspondencia entre el resultado y la solicitud.

serviceResult es el código de estado del servicio de escritura de OPC UA. Si serviceResult no es Good, las entradas de results también tienen un código de estado no válido y no deben utilizarse.

Véase también writeNodeAttributes() y QOpcUaWriteResult.

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