En esta página

Bomba de agua

Interacción con un servidor OPC UA para crear una interfaz hombre-máquina (HMI) basada en QML para una bomba de agua sencilla.

El ejemplo«Bomba de agua» muestra cómo utilizar Qt OPC UA para interactuar con un servidor OPC UA con el fin de crear una interfaz HMI basada en QML para una máquina sencilla.

Aplicación de una bomba de agua con dos depósitos, controles de la bomba y panel de estado

Configuración del servidor

Antes de poder utilizar los ejemplos de «Water Pump», es necesario compilar el servidor de simulación «Water Pump». Puedes abrirlo y compilarlo en QtCreator o desde el terminal, como de costumbre.

La simulación

El servidor OPC UA incluido en este ejemplo ejecuta una simulación de una máquina que contiene dos depósitos, una bomba de agua y una válvula. El agua se puede bombear del primer depósito al segundo y, a continuación, se puede vaciar del segundo depósito abriendo la válvula. Ambas operaciones tienen un valor de consigna configurable por el usuario, lo que permite controlar la cantidad de agua que se bombea al segundo depósito o que se vacía de él.

En el servidor existen los siguientes nodos:

NodeIdFunción
ns=2;s=MáquinaLa carpeta que contiene los nodos de método y variable para la máquina
ns=2;s=Machine.StateEl estado de la máquina
ns=2;s=Máquina.Depósito1.PorcentajeDeLlenadoEl estado actual de llenado del primer depósito
ns=2;s=Machine.Tank2.PercentFilledEl estado actual de llenado del segundo depósito
ns=2;s=Machine.Tank2.TargetPercentEl valor de consigna para el bombeo y el lavado
ns=2;s=Machine.Tank2.ValveStateEl estado de la válvula del segundo depósito
ns=2;s=Machine.DesignationUna designación legible para el usuario de la máquina, con fines de visualización
ns=2;s=Machine.StartLlama a este método para poner en marcha la bomba
ns=2;s=Machine.StopLlama a este método para detener la bomba
ns=2;s=Machine.FlushTank2Llama a este método para vaciar el depósito 2
ns=2;s=Machine.ResetLlama a este método para reiniciar la simulación

Todos los métodos devuelven ` Good ` en caso de éxito y ` BadUserAccessDenied ` si la operación es ilegal (por ejemplo, intentar poner en marcha la bomba si el primer depósito está vacío).

Características del cliente

Este ejemplo utiliza lecturas, escrituras, llamadas a métodos y suscripciones a cambios de datos, y muestra cómo configurar controladores para las operaciones asíncronas que ofrecen QOpcUaClient y QOpcUaNode.

Implementación

Se utiliza una clase de backend para gestionar la comunicación con el servidor OPC UA y exponer el contenido de este servidor mediante propiedades y métodos de Q_INVOKABLE que envuelven las llamadas a métodos OPC UA.

Variables de miembro

Se requiere un puntero a ` QOpcUaClient ` para la gestión de la conexión. Se necesita un puntero adicional a un objeto ` QOpcUaNode ` para cada nodo OPC UA con el que interactúa la HMI. Para los valores de estos nodos, se añaden variables miembro que contienen el último valor notificado por el servidor.

    ...
    QScopedPointer<QOpcUaClient> m_client;
    QScopedPointer<QOpcUaNode> m_machineStateNode;
    QScopedPointer<QOpcUaNode> m_percentFilledTank1Node;
    QScopedPointer<QOpcUaNode> m_percentFilledTank2Node;
    QScopedPointer<QOpcUaNode> m_tank2TargetPercentNode;
    QScopedPointer<QOpcUaNode> m_tank2ValveStateNode;
    QScopedPointer<QOpcUaNode> m_machineNode;
    QScopedPointer<QOpcUaNode> m_machineDesignationNode;
    double m_percentFilledTank1;
    double m_percentFilledTank2;
    double m_tank2TargetPercent;
    bool m_tank2ValveState;
    MachineState m_machineState;
    QString m_machineDesignation;
    ...

Para cada valor utilizado en la HMI, se añaden un getter, una señal de cambio y una propiedad para permitir los enlaces de propiedades en QML

    ...
    Q_PROPERTY(double percentFilledTank1 READ percentFilledTank1 NOTIFY percentFilledTank1Changed)
    Q_PROPERTY(double percentFilledTank2 READ percentFilledTank2 NOTIFY percentFilledTank2Changed)
    Q_PROPERTY(double tank2TargetPercent READ tank2TargetPercent NOTIFY tank2TargetPercentChanged)
    Q_PROPERTY(OpcUaMachineBackend::MachineState machineState READ machineState NOTIFY machineStateChanged)
    Q_PROPERTY(bool tank2ValveState READ tank2ValveState NOTIFY tank2ValveStateChanged)
    Q_PROPERTY(bool connected READ connected NOTIFY connectedChanged)
    Q_PROPERTY(QString machineDesignation READ machineDesignation NOTIFY machineDesignationChanged)
    Q_PROPERTY(QString message READ message NOTIFY messageChanged)
    ...
Manejadores asíncronos

La API asíncrona de Qt OPC UA requiere controladores de señales para todas las operaciones.

Las suscripciones a cambios de datos notifican sus actualizaciones mediante QOpcUaNode::attributeUpdated. Un controlador conectado a esta señal obtiene el nuevo valor como QVariant y puede, por ejemplo, asignar ese valor a una variable o emitir una señal con el nuevo valor.

void OpcUaMachineBackend::percentFilledTank1Updated(QOpcUa::NodeAttribute attr, const QVariant &value)
{
    Q_UNUSED(attr);
    m_percentFilledTank1 = value.toDouble();
    emit percentFilledTank1Changed(m_percentFilledTank1);
}

Una operación de lectura emite la señal « QOpcUaNode::attributeRead » al completarse. El cliente debe comprobar el código de estado y, a continuación, obtener el resultado del nodo.

void OpcUaMachineBackend::machineDesignationRead(QOpcUa::NodeAttributes attr)
{
    if (attr & QOpcUa::NodeAttribute::Value) { // Make sure the value attribute has been read
        if (m_machineDesignationNode->attributeError(QOpcUa::NodeAttribute::Value) == QOpcUa::UaStatusCode::Good) { // Make sure there was no error
            m_machineDesignation = m_machineDesignationNode->attribute(QOpcUa::NodeAttribute::Value).toString(); // Get the attribute from the cache
            emit machineDesignationChanged(m_machineDesignation);
        }
    }
}
Interacción con el servidor

En el constructor, se crea un objeto ` QOpcUaProvider ` y se guardan los backends disponibles para proporcionar un modelo para el menú desplegable de selección de backend.

    ...
    QOpcUaProvider provider;
    setBackends(provider.availableBackends());
    ...

Antes de intentar establecer una conexión, se crea un objeto ` QOpcUaClient ` con el backend seleccionado. Su señal ` QOpcUaClient::endpointsRequestFinished ` se conecta a la ranura ` requestEndpointsFinished ` del backend. La señal ` QOpcUaClient::stateChanged ` debe conectarse a la ranura ` clientStateHandler ` del backend.

void OpcUaMachineBackend::connectToEndpoint(const QString&url, qint32 index)
{
    if (m_connected)
        return;

    QOpcUaProvider provider;

    if (index < 0|| index >= m_backends.size())
        return; // Índice no válido

    if (!m_client|| (m_client&& m_client->backend() != m_backends.at(index))) {
        m_client.reset(provider.createClient(m_backends.at(index)));
        if (m_client) {
            QObject::connect(m_client.data(),
                             &QOpcUaClient::endpointsRequestFinished,
                             this,
                             &OpcUaMachineBackend::requestEndpointsFinished);
            QObject::connect(m_client.data(),
                             &QOpcUaClient::stateChanged,
                             this,
                             &OpcUaMachineBackend::clientStateHandler);
        }
    }

    if (!m_client) {
        qWarning() << "Could not create client";
        m_successfullyCreated = false;
        return;
    }

    m_successfullyCreated = true;
    m_client->requestEndpoints(url);
}

La ranura OpcUaMachineBackend::requestEndpointsFinished recibe la lista de puntos finales disponibles en el servidor e inicia una conexión con la primera entrada de la lista. Si no hay puntos finales disponibles, se interrumpe el establecimiento de la conexión.

void OpcUaMachineBackend::requestEndpointsFinished(const QList<QOpcUaEndpointDescription> &endpoints)
{
    if (endpoints.isEmpty()) {
       qWarning() << "The server did not return any endpoints";
       clientStateHandler(QOpcUaClient::ClientState::Disconnected);
       return;
    }
    m_client->connectToEndpoint(endpoints.at(0));
}

clientStateHandler actúa cuando QOpcUaClient está conectado o desconectado. En caso de que la conexión se establezca correctamente, las variables miembro del nodo creadas anteriormente se rellenan con objetos de nodo.

    ...
    if (state == QOpcUaClient::ClientState::Connected) {
        setMessage(u"Connected"_s);
        // Create node objects for reading, writing and subscriptions
        m_machineNode.reset(m_client->node(u"ns=2;s=Machine"_s));
        m_machineStateNode.reset(m_client->node(u"ns=2;s=Machine.State"_s));
        m_percentFilledTank1Node.reset(m_client->node(u"ns=2;s=Machine.Tank1.PercentFilled"_s));
        m_percentFilledTank2Node.reset(m_client->node(u"ns=2;s=Machine.Tank2.PercentFilled"_s));
        m_tank2TargetPercentNode.reset(m_client->node(u"ns=2;s=Machine.Tank2.TargetPercent"_s));
        m_tank2ValveStateNode.reset(m_client->node(u"ns=2;s=Machine.Tank2.ValveState"_s));
        m_machineDesignationNode.reset(m_client->node(u"ns=2;s=Machine.Designation"_s));
    ...

Una vez creados todos los objetos de nodo, los controladores de cambios de datos se conectan a los objetos de nodo y se activa la supervisión.

    ...
        // Connect signal handlers for subscribed values
        QObject::connect(m_machineStateNode.data(),
                         &QOpcUaNode::dataChangeOccurred,
                         this,
                         &OpcUaMachineBackend::machineStateUpdated);
        QObject::connect(m_percentFilledTank1Node.data(),
                         &QOpcUaNode::dataChangeOccurred,
                         this,
                         &OpcUaMachineBackend::percentFilledTank1Updated);
        QObject::connect(m_percentFilledTank2Node.data(),
                         &QOpcUaNode::dataChangeOccurred,
                         this,
                         &OpcUaMachineBackend::percentFilledTank2Updated);
        QObject::connect(m_tank2TargetPercentNode.data(),
                         &QOpcUaNode::dataChangeOccurred,
                         this,
                         &OpcUaMachineBackend::tank2TargetPercentUpdated);
        QObject::connect(m_tank2ValveStateNode.data(),
                         &QOpcUaNode::dataChangeOccurred,
                         this,
                         &OpcUaMachineBackend::tank2ValveStateUpdated);

        // Subscribe to data changes
        m_machineStateNode->enableMonitoring(
                QOpcUa::NodeAttribute::Value, QOpcUaMonitoringParameters(100));
        m_percentFilledTank1Node->enableMonitoring(
                QOpcUa::NodeAttribute::Value, QOpcUaMonitoringParameters(100));
        m_percentFilledTank2Node->enableMonitoring(
                QOpcUa::NodeAttribute::Value, QOpcUaMonitoringParameters(100));
        m_tank2TargetPercentNode->enableMonitoring(
                QOpcUa::NodeAttribute::Value, QOpcUaMonitoringParameters(100));
        m_tank2ValveStateNode->enableMonitoring(
    ...

No está previsto que la designación de la máquina cambie y se leerá una sola vez al iniciar el sistema.

    ...
        // Connect the handler for async reading
        QObject::connect(m_machineDesignationNode.data(),
                         &QOpcUaNode::attributeRead,
                         this,
                         &OpcUaMachineBackend::machineDesignationRead);

        // Request the value attribute of the machine designation node
        m_machineDesignationNode->readAttributes(QOpcUa::NodeAttribute::Value);
    ...

Se ha añadido al backend un controlador para el valor de consigna.

void OpcUaMachineBackend::machineWriteTank2TargetPercent(double value)
{
    if (m_tank2TargetPercentNode)
        m_tank2TargetPercentNode->writeAttribute(QOpcUa::NodeAttribute::Value, value);
}

En cuanto a los métodos, se crean envoltorios que llaman al método del servidor OPC UA.

void OpcUaMachineBackend::startPump()
{
    m_machineNode->callMethod(u"ns=2;s=Machine.Start"_s);
}
La HMI

Se crea una instancia de backend y se pasa a la parte QML como una propiedad de contexto denominada « uaBackend ».

    ...
    OpcUaMachineBackend backend;

    QQmlApplicationEngine engine;
    engine.rootContext()->setContextProperty("uaBackend", &backend);
    ...

El código QML ya puede acceder a las propiedades, señales y métodos Q_INVOKABLE de uaBackend. Por ejemplo, el botón para vaciar el segundo depósito solo está habilitado si el backend está conectado al servidor, la máquina está inactiva y el nivel del depósito está por encima del punto de consigna. Al hacer clic, se llama al método flushTank2() en el servidor.

        Button {
            id: flushButton
            text: "Flush"
            enabled: uaBackend.connected
                     && uaBackend.machineState === OpcUaMachineBackend.MachineState.Idle
                     && uaBackend.percentFilledTank2 > uaBackend.tank2TargetPercent
            onClicked: {
                uaBackend.flushTank2()
            }
        }

Las señales del backend también se pueden utilizar directamente en el código QML.

    Connections {
        target: uaBackend

        function onPercentFilledTank2Changed(value) {
            if (uaBackend.machineState === OpcUaMachineBackend.MachineState.Pumping)
                rotation += 15
        }
    }

Uso

La aplicación HMI inicia el servidor automáticamente. Tras conectarse al servidor haciendo clic en el botón « Connect », arrastra el control deslizante para establecer un valor de consigna. A continuación, haz clic en « Start » para comenzar a bombear agua del primer depósito al segundo. Si estableces un valor de consigna inferior al valor actual del segundo depósito, al hacer clic en « Flush » se abrirá la válvula.

Si no queda agua, haz clic en « Reset simulation » para rellenar el primer depósito.

Proyecto de ejemplo en code.qt.io

Véase también «Qt Quick: bomba de agua».

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