Revision control
++ // Copyright (C) 2018 basysKom GmbH, opensource@basyskom.com
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
++
++ #include "opcuamachinebackend.h"
++
++ #include <QOpcUaProvider>
++ #include <QQmlEngine>
++
++ using namespace Qt::Literals::StringLiterals;
++
++ OpcUaMachineBackend::OpcUaMachineBackend(QObject *parent)
++ : QObject(parent)
++ , m_percentFilledTank1(0)
++ , m_percentFilledTank2(0)
++ , m_tank2TargetPercent(0)
++ , m_tank2ValveState(false)
++ , m_machineState(MachineState::Idle)
++ , m_connected(false)
++ , m_message(u"Ready to connect"_s)
++ , m_successfullyCreated(false)
++ {
++ qRegisterMetaType<OpcUaMachineBackend::MachineState>();
++ qmlRegisterType<OpcUaMachineBackend>("OpcUaMachineBackend", 1, 0, "OpcUaMachineBackend");
++
++ QOpcUaProvider provider;
++ setBackends(provider.availableBackends());
++ }
++
++ OpcUaMachineBackend::~OpcUaMachineBackend()
++ {
++ if (m_client && m_client->state() == QOpcUaClient::Connected)
++ m_client->disconnectFromEndpoint();
++ }
++
++ void OpcUaMachineBackend::clientStateHandler(QOpcUaClient::ClientState state)
++ {
++ m_connected = (state == QOpcUaClient::ClientState::Connected);
++
++ emit connectedChanged(m_connected);
++
++ 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));
++
++ // 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(
++ QOpcUa::NodeAttribute::Value, QOpcUaMonitoringParameters(100));
++
++ // 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);
++
++ // Add handlers for write and call results
++ QObject::connect(m_tank2TargetPercentNode.data(),
++ &QOpcUaNode::attributeWritten,
++ this,
++ &OpcUaMachineBackend::setpointWritten);
++ QObject::connect(m_machineNode.data(),
++ &QOpcUaNode::methodCallFinished,
++ this,
++ &OpcUaMachineBackend::handleMethodResult);
++
++ // Add handlers for enableMonitoring results
++ QObject::connect(m_machineStateNode.data(),
++ &QOpcUaNode::enableMonitoringFinished,
++ this,
++ &OpcUaMachineBackend::enableMonitoringFinished);
++ QObject::connect(m_percentFilledTank1Node.data(),
++ &QOpcUaNode::enableMonitoringFinished,
++ this,
++ &OpcUaMachineBackend::enableMonitoringFinished);
++ QObject::connect(m_percentFilledTank2Node.data(),
++ &QOpcUaNode::enableMonitoringFinished,
++ this,
++ &OpcUaMachineBackend::enableMonitoringFinished);
++ QObject::connect(m_tank2TargetPercentNode.data(),
++ &QOpcUaNode::enableMonitoringFinished,
++ this,
++ &OpcUaMachineBackend::enableMonitoringFinished);
++ QObject::connect(m_tank2ValveStateNode.data(),
++ &QOpcUaNode::enableMonitoringFinished,
++ this,
++ &OpcUaMachineBackend::enableMonitoringFinished);
++ }
++
++ if (state == QOpcUaClient::ClientState::Connecting)
++ setMessage(u"Connecting"_s);
++
++ if (state == QOpcUaClient::ClientState::Disconnected) {
++ setMessage(u"Disconnected: %1"_s
++ .arg(QMetaEnum::fromType<QOpcUaClient::ClientError>().valueToKey(
++ static_cast<int>(m_client->error()))));
++ }
++ }
++
++ void OpcUaMachineBackend::machineStateUpdated(QOpcUa::NodeAttribute attr, const QVariant &value)
++ {
++ Q_UNUSED(attr);
++ MachineState newState = static_cast<MachineState>(value.toUInt());
++ if (newState != m_machineState) {
++ m_machineState = newState;
++ emit machineStateChanged(m_machineState);
++ }
++ }
++
++ void OpcUaMachineBackend::percentFilledTank1Updated(QOpcUa::NodeAttribute attr, const QVariant &value)
++ {
++ Q_UNUSED(attr);
++ m_percentFilledTank1 = value.toDouble();
++ emit percentFilledTank1Changed(m_percentFilledTank1);
++ }
++
++ void OpcUaMachineBackend::percentFilledTank2Updated(QOpcUa::NodeAttribute attr, const QVariant &value)
++ {
++ Q_UNUSED(attr);
++ m_percentFilledTank2 = value.toDouble();
++ emit percentFilledTank2Changed(m_percentFilledTank2);
++ }
++
++ void OpcUaMachineBackend::tank2TargetPercentUpdated(QOpcUa::NodeAttribute attr, const QVariant &value)
++ {
++ Q_UNUSED(attr);
++ m_tank2TargetPercent = value.toDouble();
++ emit tank2TargetPercentChanged(m_tank2TargetPercent);
++ }
++
++ void OpcUaMachineBackend::tank2ValveStateUpdated(QOpcUa::NodeAttribute attr, const QVariant &value)
++ {
++ Q_UNUSED(attr);
++ m_tank2ValveState = value.toBool();
++ emit tank2ValveStateChanged(m_tank2ValveState);
++ }
++
++ 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);
++ }
++ }
++ }
++
++ void OpcUaMachineBackend::setpointWritten(QOpcUa::NodeAttribute attr, QOpcUa::UaStatusCode status)
++ {
++ if (attr == QOpcUa::NodeAttribute::Value && status == QOpcUa::UaStatusCode::Good)
++ setMessage(u"Setpoint successfully set"_s);
++ else if (attr == QOpcUa::NodeAttribute::Value && status != QOpcUa::UaStatusCode::Good)
++ setMessage(u"Failed to set setpoint"_s);
++ }
++
++ void OpcUaMachineBackend::handleMethodResult(QString methodNodeId,
++ const QVariant &result,
++ QOpcUa::UaStatusCode statusCode)
++ {
++ Q_UNUSED(result);
++
++ if (methodNodeId == u"ns=2;s=Machine.Start"_s) {
++ if (statusCode == QOpcUa::UaStatusCode::Good)
++ setMessage(u"Pump successfully started"_s);
++ else
++ setMessage(u"Unable to start pump"_s);
++ } else if (methodNodeId == u"ns=2;s=Machine.Stop"_s) {
++ if (statusCode == QOpcUa::UaStatusCode::Good)
++ setMessage(u"Pump successfully stopped"_s);
++ else
++ setMessage(u"Unable to stop pump"_s);
++ } else if (methodNodeId == u"ns=2;s=Machine.FlushTank2"_s) {
++ if (statusCode == QOpcUa::UaStatusCode::Good)
++ setMessage(u"Flushing tank 2 successfully started"_s);
++ else
++ setMessage(u"Unable to flush tank 2"_s);
++ } else if (methodNodeId == u"ns=2;s=Machine.Reset"_s) {
++ if (statusCode == QOpcUa::UaStatusCode::Good)
++ setMessage(u"Simulation successfully reset"_s);
++ else
++ setMessage(u"Unable to reset simulation"_s);
++ }
++ }
++
++ void OpcUaMachineBackend::enableMonitoringFinished(QOpcUa::NodeAttribute attr,
++ QOpcUa::UaStatusCode status)
++ {
++ Q_UNUSED(attr);
++ if (!sender())
++ return;
++ if (status == QOpcUa::UaStatusCode::Good) {
++ qDebug() << "Monitoring successfully enabled for"
++ << qobject_cast<QOpcUaNode *>(sender())->nodeId();
++ } else {
++ qDebug() << "Failed to enable monitoring for"
++ << qobject_cast<QOpcUaNode *>(sender())->nodeId() << ":" << status;
++ setMessage(u"Failed to enable monitoring"_s);
++ }
++ }
++
++ void OpcUaMachineBackend::setBackends(const QStringList &backends)
++ {
++ if (m_backends != backends) {
++ m_backends = backends;
++ emit backendsChanged(m_backends);
++ }
++ }
++
++ QStringList OpcUaMachineBackend::backends() const
++ {
++ return m_backends;
++ }
++
++ double OpcUaMachineBackend::percentFilledTank1() const
++ {
++ return m_percentFilledTank1;
++ }
++
++ double OpcUaMachineBackend::percentFilledTank2() const
++ {
++ return m_percentFilledTank2;
++ }
++
++ OpcUaMachineBackend::MachineState OpcUaMachineBackend::machineState() const
++ {
++ return m_machineState;
++ }
++
++ void OpcUaMachineBackend::machineWriteTank2TargetPercent(double value)
++ {
++ if (m_tank2TargetPercentNode)
++ m_tank2TargetPercentNode->writeAttribute(QOpcUa::NodeAttribute::Value, value);
++ }
++
++ void OpcUaMachineBackend::startPump()
++ {
++ m_machineNode->callMethod(u"ns=2;s=Machine.Start"_s);
++ }
++
++ void OpcUaMachineBackend::stopPump()
++ {
++ if (m_machineNode)
++ m_machineNode->callMethod(u"ns=2;s=Machine.Stop"_s);
++ }
++
++ void OpcUaMachineBackend::flushTank2()
++ {
++ if (m_machineNode)
++ m_machineNode->callMethod(u"ns=2;s=Machine.FlushTank2"_s);
++ }
++
++ void OpcUaMachineBackend::resetSimulation()
++ {
++ if (m_machineNode)
++ m_machineNode->callMethod(u"ns=2;s=Machine.Reset"_s);
++ }
++
++ 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));
++ }
++
++ void OpcUaMachineBackend::setMessage(const QString &message)
++ {
++ if (message != m_message) {
++ m_message = message;
++ emit messageChanged(m_message);
++ }
++ }
++
++ bool OpcUaMachineBackend::successfullyCreated() const
++ {
++ return m_successfullyCreated;
++ }
++
++ QString OpcUaMachineBackend::message() const
++ {
++ return m_message;
++ }
++
++ QString OpcUaMachineBackend::machineDesignation() const
++ {
++ return m_machineDesignation;
++ }
++
++ bool OpcUaMachineBackend::connected() const
++ {
++ return m_connected;
++ }
++
++ void OpcUaMachineBackend::connectToEndpoint(const QString &url, qint32 index)
++ {
++ if (m_connected)
++ return;
++
++ QOpcUaProvider provider;
++
++ if (index < 0 || index >= m_backends.size())
++ return; // Invalid index
++
++ 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);
++ }
++
++ void OpcUaMachineBackend::disconnectFromEndpoint()
++ {
++ if (m_connected)
++ m_client->disconnectFromEndpoint();
++ }
++
++ bool OpcUaMachineBackend::tank2ValveState() const
++ {
++ return m_tank2ValveState;
++ }
++
++ double OpcUaMachineBackend::tank2TargetPercent() const
++ {
++ return m_tank2TargetPercent;
++ }