diff --git a/.idea/.gitignore b/.idea/.gitignore index b6b1ecf..08a7be0 100644 --- a/.idea/.gitignore +++ b/.idea/.gitignore @@ -8,3 +8,5 @@ /dataSources.local.xml # 基于编辑器的 HTTP 客户端请求 /httpRequests/ +/go.imports.xml +/MarsCodeWorkspaceAppSettings.xml diff --git a/config.ini b/config.ini index 4c25f47..1ba68dd 100644 --- a/config.ini +++ b/config.ini @@ -66,7 +66,8 @@ timeoutWarningMs=8000 stateTimeoutMs=10000 maxRecoveryRetries=1 simulationStepMs=500 +usePlcErrorCode=false [system] -simulation=true -productionEnabled=false +simulation=false +productionEnabled=true diff --git a/config/configmanager.cpp b/config/configmanager.cpp index 6437df1..a58bc9b 100644 --- a/config/configmanager.cpp +++ b/config/configmanager.cpp @@ -129,6 +129,9 @@ bool ConfigManager::load(const QString &filePath) m_productionConfig.simulationStepMs = settings.value("production/simulationStepMs", m_productionConfig.simulationStepMs).toInt(); + m_productionConfig.usePlcErrorCode = + settings.value("production/usePlcErrorCode", + m_productionConfig.usePlcErrorCode).toBool(); m_simulationMode = settings.value("system/simulation", m_simulationMode).toBool(); m_productionEnabled = settings.value("system/productionEnabled", m_productionEnabled).toBool(); diff --git a/config/configmanager.h b/config/configmanager.h index cde86ca..8618f6e 100644 --- a/config/configmanager.h +++ b/config/configmanager.h @@ -21,6 +21,7 @@ struct ProductionConfig int stateTimeoutMs = 10000; int maxRecoveryRetries = 1; int simulationStepMs = 500; + bool usePlcErrorCode = false; }; class ConfigManager diff --git a/main.cpp b/main.cpp index 1a5f37c..6682a06 100644 --- a/main.cpp +++ b/main.cpp @@ -2,7 +2,6 @@ #include "config/configmanager.h" #include "db/databasemanager.h" -#include "modbus/modbustcpmanager.h" #include #include @@ -14,7 +13,6 @@ int main(int argc, char *argv[]) ConfigManager &configManager = ConfigManager::instance(); configManager.load(); DatabaseManager::instance().setConfig(configManager.databaseConfig()); - ModbusTcpManager::instance().setConfig(configManager.modbusConfig()); QString configError; if (!configManager.validate(&configError)) { diff --git a/modbus/modbustcpmanager.cpp b/modbus/modbustcpmanager.cpp index cf1cfa9..3c6e2cf 100644 --- a/modbus/modbustcpmanager.cpp +++ b/modbus/modbustcpmanager.cpp @@ -1,36 +1,31 @@ #include "modbustcpmanager.h" -#include #include #include #include #include #include -ModbusTcpManager &ModbusTcpManager::instance() -{ - static ModbusTcpManager manager; - return manager; -} - -ModbusTcpManager::ModbusTcpManager() - : m_config(ModbusConfig::defaultConfig()), - m_client(nullptr) +ModbusTcpManager::ModbusTcpManager(const ModbusConfig &config, + QObject *parent) + : QObject(parent) + , m_config(config) + , m_client(nullptr) + , m_reply(nullptr) + , m_connectTimer(new QTimer(this)) + , m_hasCurrentRequest(false) + , m_connecting(false) + , m_aborting(false) + , m_connectAttempts(0) { + m_connectTimer->setSingleShot(true); + connect(m_connectTimer, &QTimer::timeout, + this, &ModbusTcpManager::onConnectTimeout); } ModbusTcpManager::~ModbusTcpManager() { - disconnectDevice(); - delete m_client; -} - -void ModbusTcpManager::setConfig(const ModbusConfig &config) -{ - if (isConnected()) { - disconnectDevice(); - } - m_config = config; + abortAll("Modbus manager is shutting down"); } ModbusConfig ModbusTcpManager::config() const @@ -38,206 +33,245 @@ ModbusConfig ModbusTcpManager::config() const return m_config; } -bool ModbusTcpManager::connectDevice(QString *error) +void ModbusTcpManager::readCoil( + int address, + const std::function &callback) { - ensureClient(); - if (isConnected()) { - return true; + enqueue({QModbusDataUnit::Coils, address, 0, false, + [callback](bool success, quint16 value, const QString &error) { + if (callback) { + callback(success, value != 0, error); + } + }}); +} + +void ModbusTcpManager::readHoldingRegister( + int address, + const std::function &callback) +{ + enqueue({QModbusDataUnit::HoldingRegisters, address, 0, false, callback}); +} + +void ModbusTcpManager::writeCoil( + int address, bool value, + const std::function &callback) +{ + enqueue({QModbusDataUnit::Coils, address, + static_cast(value ? 1 : 0), true, + [callback](bool success, quint16, const QString &error) { + if (callback) { + callback(success, error); + } + }}); +} + +void ModbusTcpManager::writeHoldingRegister( + int address, quint16 value, + const std::function &callback) +{ + enqueue({QModbusDataUnit::HoldingRegisters, address, value, true, + [callback](bool success, quint16, const QString &error) { + if (callback) { + callback(success, error); + } + }}); +} + +void ModbusTcpManager::abortAll(const QString &reason) +{ + if (m_aborting) { + return; } - m_client->setConnectionParameter(QModbusDevice::NetworkAddressParameter, QVariant(m_config.host)); - m_client->setConnectionParameter(QModbusDevice::NetworkPortParameter, QVariant(m_config.port)); + const QString text = reason.isEmpty() + ? "Modbus request was canceled" : reason; + + m_aborting = true; + m_connectTimer->stop(); + m_connecting = false; + + if (m_reply) { + QModbusReply *reply = m_reply; + m_reply = nullptr; + reply->disconnect(this); + reply->deleteLater(); + } + + if (m_hasCurrentRequest) { + const Completion callback = m_currentRequest.callback; + m_currentRequest = Request(); + m_hasCurrentRequest = false; + setError(text); + if (callback) { + callback(false, 0, text); + } + } + + while (!m_requests.isEmpty()) { + Request request = m_requests.dequeue(); + if (request.callback) { + request.callback(false, 0, text); + } + } + + if (m_client + && m_client->state() != QModbusDevice::UnconnectedState) { + m_client->disconnectDevice(); + } + + m_aborting = false; +} + +bool ModbusTcpManager::isBusy() const +{ + return m_hasCurrentRequest || !m_requests.isEmpty() + || m_connecting || m_reply; +} + +void ModbusTcpManager::enqueue(const Request &request) +{ + if (m_aborting) { + if (request.callback) { + request.callback(false, 0, "Modbus request was canceled"); + } + return; + } + + if (request.address < 0) { + if (request.callback) { + request.callback(false, 0, + "Modbus address must be greater than or equal to 0"); + } + return; + } + + m_requests.enqueue(request); + startNext(); +} + +void ModbusTcpManager::startNext() +{ + if (m_aborting || m_hasCurrentRequest || m_requests.isEmpty()) { + return; + } + + m_currentRequest = m_requests.dequeue(); + m_hasCurrentRequest = true; + m_connectAttempts = 0; + ensureConnected(); +} + +void ModbusTcpManager::ensureConnected() +{ + if (m_aborting || !m_hasCurrentRequest) { + return; + } + + ensureClient(); + if (m_client->state() == QModbusDevice::ConnectedState) { + startCurrentRequest(); + return; + } + if (m_connecting) { + return; + } + + m_client->setConnectionParameter( + QModbusDevice::NetworkAddressParameter, + QVariant(m_config.host)); + m_client->setConnectionParameter( + QModbusDevice::NetworkPortParameter, + QVariant(m_config.port)); m_client->setTimeout(m_config.timeoutMs); m_client->setNumberOfRetries(m_config.retryCount); + ++m_connectAttempts; + m_connecting = true; if (!m_client->connectDevice()) { - setError(m_client->errorString(), error); - return false; + handleConnectionFailure(m_client->errorString()); + return; } - QEventLoop loop; - QTimer timer; - timer.setSingleShot(true); - - QObject::connect(m_client, &QModbusClient::stateChanged, &loop, [&](QModbusDevice::State state) { - if (state == QModbusDevice::ConnectedState || state == QModbusDevice::UnconnectedState) { - loop.quit(); - } - }); - QObject::connect(m_client, &QModbusClient::errorOccurred, &loop, [&](QModbusDevice::Error) { - loop.quit(); - }); - QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit); - - timer.start(m_config.timeoutMs); - loop.exec(); - - if (!isConnected()) { - QString text = m_client->errorString(); - if (text.isEmpty()) { - text = "Modbus TCP connect timeout"; - } - setError(text, error); - return false; - } - - m_lastErrorText.clear(); - return true; + m_connectTimer->start(qMax(1, m_config.timeoutMs)); } -void ModbusTcpManager::disconnectDevice() +void ModbusTcpManager::startCurrentRequest() { - if (m_client) { + if (m_aborting || !m_hasCurrentRequest || m_connecting || m_reply) { + return; + } + + QModbusDataUnit unit( + static_cast( + m_currentRequest.registerType), + m_currentRequest.address, 1); + if (m_currentRequest.write) { + unit.setValue(0, m_currentRequest.value); + m_reply = m_client->sendWriteRequest(unit, m_config.serverAddress); + } else { + m_reply = m_client->sendReadRequest(unit, m_config.serverAddress); + } + + if (!m_reply) { + finishCurrent(false, 0, + m_client->errorString().isEmpty() + ? "Failed to create Modbus request" + : m_client->errorString()); + return; + } + + connect(m_reply, &QModbusReply::finished, + this, &ModbusTcpManager::onReplyFinished); +} + +void ModbusTcpManager::finishCurrent(bool success, quint16 value, + const QString &error) +{ + if (!m_hasCurrentRequest) { + return; + } + + const Completion callback = m_currentRequest.callback; + m_currentRequest = Request(); + m_hasCurrentRequest = false; + if (!success) { + setError(error); + } else { + m_lastErrorText.clear(); + } + + if (callback) { + callback(success, value, error); + } + if (!m_aborting) { + startNext(); + } +} + +void ModbusTcpManager::handleConnectionFailure(const QString &error) +{ + if (m_aborting) { + return; + } + + m_connectTimer->stop(); + m_connecting = false; + + if (m_client + && m_client->state() != QModbusDevice::UnconnectedState) { m_client->disconnectDevice(); } -} -bool ModbusTcpManager::isConnected() const -{ - return m_client && m_client->state() == QModbusDevice::ConnectedState; -} - -bool ModbusTcpManager::readCoil(int address, bool *value, QString *error) -{ - if (!value) { - setError("Output value pointer is null", error); - return false; + const int attempts = qMax(1, m_config.reconnectAttempts + 1); + if (m_connectAttempts < attempts) { + QTimer::singleShot( + qMax(0, m_config.reconnectDelayMs), + this, &ModbusTcpManager::ensureConnected); + return; } - quint16 rawValue = 0; - if (!readSingleValue(QModbusDataUnit::Coils, address, &rawValue, error)) { - return false; - } - - *value = rawValue != 0; - return true; -} - -bool ModbusTcpManager::readHoldingRegister(int address, quint16 *value, QString *error) -{ - if (!value) { - setError("Output value pointer is null", error); - return false; - } - - return readSingleValue(QModbusDataUnit::HoldingRegisters, address, value, error); -} - -bool ModbusTcpManager::writeCoil(int address, bool value, QString *error) -{ - return writeSingleValue(QModbusDataUnit::Coils, address, value ? 1 : 0, error); -} - -bool ModbusTcpManager::writeHoldingRegister(int address, quint16 value, QString *error) -{ - return writeSingleValue(QModbusDataUnit::HoldingRegisters, address, value, error); -} - -QString ModbusTcpManager::lastErrorText() const -{ - return m_lastErrorText; -} - -bool ModbusTcpManager::readSingleValue(int registerType, int address, quint16 *value, QString *error) -{ - if (address < 0) { - setError("Modbus address must be greater than or equal to 0", error); - return false; - } - - if (!connectDevice(error)) { - return false; - } - - QModbusDataUnit unit(static_cast(registerType), address, 1); - QModbusReply *reply = m_client->sendReadRequest(unit, m_config.serverAddress); - if (!reply) { - setError(m_client->errorString(), error); - return false; - } - - QEventLoop loop; - QTimer timer; - timer.setSingleShot(true); - - QObject::connect(reply, &QModbusReply::finished, &loop, &QEventLoop::quit); - QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit); - - timer.start(m_config.timeoutMs); - loop.exec(); - - if (!reply->isFinished()) { - reply->deleteLater(); - setError("Modbus TCP read timeout", error); - return false; - } - - if (reply->error() != QModbusDevice::NoError) { - const QString text = reply->errorString(); - reply->deleteLater(); - setError(text, error); - return false; - } - - const QModbusDataUnit result = reply->result(); - if (result.valueCount() < 1) { - reply->deleteLater(); - setError("Modbus TCP read returned empty result", error); - return false; - } - - *value = result.value(0); - reply->deleteLater(); - m_lastErrorText.clear(); - return true; -} - -bool ModbusTcpManager::writeSingleValue(int registerType, int address, quint16 value, QString *error) -{ - if (address < 0) { - setError("Modbus address must be greater than or equal to 0", error); - return false; - } - - if (!connectDevice(error)) { - return false; - } - - QModbusDataUnit unit(static_cast(registerType), address, 1); - unit.setValue(0, value); - - QModbusReply *reply = m_client->sendWriteRequest(unit, m_config.serverAddress); - if (!reply) { - setError(m_client->errorString(), error); - return false; - } - - QEventLoop loop; - QTimer timer; - timer.setSingleShot(true); - - QObject::connect(reply, &QModbusReply::finished, &loop, &QEventLoop::quit); - QObject::connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit); - - timer.start(m_config.timeoutMs); - loop.exec(); - - if (!reply->isFinished()) { - reply->deleteLater(); - setError("Modbus TCP write timeout", error); - return false; - } - - if (reply->error() != QModbusDevice::NoError) { - const QString text = reply->errorString(); - reply->deleteLater(); - setError(text, error); - return false; - } - - reply->deleteLater(); - m_lastErrorText.clear(); - return true; + finishCurrent(false, 0, + error.isEmpty() ? "Failed to connect to PLC" : error); } void ModbusTcpManager::ensureClient() @@ -246,13 +280,85 @@ void ModbusTcpManager::ensureClient() return; } - m_client = new QModbusTcpClient(); + m_client = new QModbusTcpClient(this); + connect(m_client, &QModbusClient::stateChanged, + this, &ModbusTcpManager::onStateChanged); + connect(m_client, &QModbusClient::errorOccurred, + this, &ModbusTcpManager::onErrorOccurred); } -void ModbusTcpManager::setError(const QString &text, QString *error) +void ModbusTcpManager::setError(const QString &text) { m_lastErrorText = text; - if (error) { - *error = m_lastErrorText; +} + +void ModbusTcpManager::onStateChanged(QModbusDevice::State state) +{ + if (m_aborting) { + return; + } + + if (state == QModbusDevice::ConnectedState) { + m_connectTimer->stop(); + m_connecting = false; + startCurrentRequest(); + return; + } + + if (state == QModbusDevice::UnconnectedState && m_connecting) { + handleConnectionFailure(m_client ? m_client->errorString() + : QString()); } } + +void ModbusTcpManager::onErrorOccurred(QModbusDevice::Error error) +{ + Q_UNUSED(error) + if (m_aborting) { + return; + } + + if (m_connecting) { + handleConnectionFailure(m_client ? m_client->errorString() + : QString()); + } +} + +void ModbusTcpManager::onReplyFinished() +{ + QModbusReply *reply = qobject_cast(sender()); + if (!reply || reply != m_reply) { + if (reply) { + reply->deleteLater(); + } + return; + } + + m_reply = nullptr; + const bool success = reply->error() == QModbusDevice::NoError; + quint16 value = 0; + QString error; + if (!success) { + error = reply->errorString(); + } else if (!m_currentRequest.write) { + const QModbusDataUnit result = reply->result(); + if (result.valueCount() < 1) { + error = "Modbus read returned an empty result"; + } else { + value = result.value(0); + } + } + + reply->deleteLater(); + if (!error.isEmpty()) { + finishCurrent(false, 0, error); + return; + } + + finishCurrent(true, value, QString()); +} + +void ModbusTcpManager::onConnectTimeout() +{ + handleConnectionFailure("Modbus TCP connect timeout"); +} diff --git a/modbus/modbustcpmanager.h b/modbus/modbustcpmanager.h index 95a4760..ef686e9 100644 --- a/modbus/modbustcpmanager.h +++ b/modbus/modbustcpmanager.h @@ -3,43 +3,96 @@ #include "modbusconfig.h" +#include +#include +#include #include #include +#include class QModbusTcpClient; +class QModbusReply; +class QTimer; -class ModbusTcpManager +class ModbusTcpManager : public QObject { -public: - static ModbusTcpManager &instance(); - ~ModbusTcpManager(); + Q_OBJECT + +public: + using Completion = std::function; + + explicit ModbusTcpManager(const ModbusConfig &config, + QObject *parent = nullptr); + ~ModbusTcpManager() override; - void setConfig(const ModbusConfig &config); ModbusConfig config() const; - bool connectDevice(QString *error = nullptr); - void disconnectDevice(); - bool isConnected() const; - - bool readCoil(int address, bool *value, QString *error = nullptr); - bool readHoldingRegister(int address, quint16 *value, QString *error = nullptr); - bool writeCoil(int address, bool value, QString *error = nullptr); - bool writeHoldingRegister(int address, quint16 value, QString *error = nullptr); - - QString lastErrorText() const; + void readCoil(int address, + const std::function &callback); + void readHoldingRegister( + int address, + const std::function &callback); + void writeCoil(int address, bool value, + const std::function &callback); + void writeHoldingRegister( + int address, quint16 value, + const std::function &callback); + void abortAll(const QString &reason); + bool isBusy() const; private: - ModbusTcpManager(); - ModbusTcpManager(const ModbusTcpManager &) = delete; - ModbusTcpManager &operator=(const ModbusTcpManager &) = delete; + struct Request + { + Request() + : registerType(0) + , address(-1) + , value(0) + , write(false) + { + } + Request(int type, int requestAddress, quint16 requestValue, + bool requestWrite, const Completion &requestCallback) + : registerType(type) + , address(requestAddress) + , value(requestValue) + , write(requestWrite) + , callback(requestCallback) + { + } - bool readSingleValue(int registerType, int address, quint16 *value, QString *error); - bool writeSingleValue(int registerType, int address, quint16 value, QString *error); + int registerType; + int address; + quint16 value; + bool write; + Completion callback; + }; + + void enqueue(const Request &request); + void startNext(); + void ensureConnected(); + void startCurrentRequest(); + void finishCurrent(bool success, quint16 value, const QString &error); + void handleConnectionFailure(const QString &error); void ensureClient(); - void setError(const QString &text, QString *error); + void setError(const QString &text); +private slots: + void onStateChanged(QModbusDevice::State state); + void onErrorOccurred(QModbusDevice::Error error); + void onReplyFinished(); + void onConnectTimeout(); + +private: ModbusConfig m_config; QModbusTcpClient *m_client; + QModbusReply *m_reply; + QTimer *m_connectTimer; + QQueue m_requests; + Request m_currentRequest; + bool m_hasCurrentRequest; + bool m_connecting; + bool m_aborting; + int m_connectAttempts; QString m_lastErrorText; }; diff --git a/pages/dashboardpage.cpp b/pages/dashboardpage.cpp index 2cd4bee..28b4830 100644 --- a/pages/dashboardpage.cpp +++ b/pages/dashboardpage.cpp @@ -35,7 +35,7 @@ DashboardPage::DashboardPage(QWidget *parent) , recoverButton(new QPushButton("Recover", this)) , retryButton(new QPushButton("Retry", this)) , markNgButton(new QPushButton("Mark NG", this)) - , stopButton(new QPushButton("Stop", this)) + , stopButton(new QPushButton("Terminate", this)) , processBox(new QGroupBox("Process timing", this)) , currentProcessLabel(new QLabel("-", processBox)) , processElapsedLabel(new QLabel("00:00:00.000", processBox)) @@ -54,6 +54,8 @@ DashboardPage::DashboardPage(QWidget *parent) productionWorker->moveToThread(productionThread); connect(productionThread, &QThread::finished, productionWorker, &QObject::deleteLater); + connect(productionWorker, &ProductionWorker::shutdownReady, + productionThread, &QThread::quit, Qt::DirectConnection); const QList values = QList() << ui->planValue << ui->pendingValue << ui->frontValue @@ -184,15 +186,18 @@ DashboardPage::DashboardPage(QWidget *parent) this, &DashboardPage::onTimeoutRecoveryRequired); connect(productionWorker, &ProductionWorker::recoveryCompleted, this, &DashboardPage::onRecoveryCompleted); - connect(&DeviceService::instance(), &DeviceService::statusChanged, + connect(productionWorker, &ProductionWorker::deviceStatusChanged, this, &DashboardPage::onDeviceStatusChanged); + connect(productionWorker, &ProductionWorker::deviceCommunicationError, + this, [this](const QString &error) { + emit deviceCommunicationError(error); + }); productionThread->start(); QMetaObject::invokeMethod(productionWorker, "requestRestore", Qt::QueuedConnection); loadOrderOptions(); - DeviceService::instance().startPolling(); processRefreshTimer->setInterval(1000); connect(processRefreshTimer, &QTimer::timeout, this, &DashboardPage::refreshProcessRecords); @@ -203,7 +208,9 @@ DashboardPage::DashboardPage(QWidget *parent) DashboardPage::~DashboardPage() { if (productionThread->isRunning()) { - productionThread->quit(); + productionWorker->requestStopImmediate(); + QMetaObject::invokeMethod(productionWorker, "requestShutdown", + Qt::QueuedConnection); productionThread->wait(); } delete ui; @@ -285,6 +292,7 @@ void DashboardPage::pauseProduction() void DashboardPage::stopProduction() { + productionWorker->requestStopImmediate(); QMetaObject::invokeMethod(productionWorker, "requestStop", Qt::QueuedConnection); } @@ -297,22 +305,10 @@ void DashboardPage::resetProduction() void DashboardPage::clearAlarm() { - QString error; - if (!DeviceService::instance().clearAlarm(&error)) { - QMessageBox::warning(this, "Clear alarm failed", error); - emit logRequested("Alarm log", "Dashboard", "Clear alarm", - error, "Failed"); - return; - } - if (!ProductionRepository().clearActiveAlarms( - QString(), "OPERATOR", &error)) { - QMessageBox::warning(this, "Clear alarm failed", error); - emit logRequested("Alarm log", "Dashboard", "Clear alarm", - error, "Failed"); - return; - } + QMetaObject::invokeMethod(productionWorker, "requestClearAlarm", + Qt::QueuedConnection); emit logRequested("Alarm log", "Dashboard", "Clear alarm", - "PLC alarm clear command completed", "Success"); + "PLC alarm clear command requested", "Pending"); } void DashboardPage::onOrderChanged(int) @@ -446,11 +442,14 @@ void DashboardPage::updateRecoveryButtons() || state == ProductionService::ManualConfirm; const bool running = state != ProductionService::Idle && state != ProductionService::Completed; + const bool terminating = state == ProductionService::Terminating; recoverButton->setVisible(recoveryRequired); retryButton->setVisible(recoveryRequired); markNgButton->setVisible(recoveryRequired && productionWorkpiece.id > 0); stopButton->setVisible(running); + stopButton->setEnabled(!terminating); + stopButton->setText(terminating ? "Terminating..." : "Terminate"); recoverButton->setText(state == ProductionService::ManualConfirm ? "Continue" : "Recover"); } @@ -553,6 +552,7 @@ void DashboardPage::updateCurrentProcessDuration(int elapsedMs) void DashboardPage::onDeviceStatusChanged(const DeviceStatus &status) { + emit deviceStatusChanged(status); deviceStatusLabel->setText( QString("PLC: %1 | Robot: %2 | Safety door: %3 | E-stop: %4") .arg(status.plcConnected ? "ONLINE" : "OFFLINE") diff --git a/pages/dashboardpage.h b/pages/dashboardpage.h index 40f8c2a..d01fbc2 100644 --- a/pages/dashboardpage.h +++ b/pages/dashboardpage.h @@ -30,6 +30,8 @@ public: signals: void systemStateChanged(const QString &state); void currentStepChanged(const QString &step); + void deviceStatusChanged(const DeviceStatus &status); + void deviceCommunicationError(const QString &error); void logRequested(const QString &type, const QString &module, const QString &action, const QString &content, const QString &status); diff --git a/pages/devicepage.cpp b/pages/devicepage.cpp index ed1eaa9..5859a82 100644 --- a/pages/devicepage.cpp +++ b/pages/devicepage.cpp @@ -1,8 +1,6 @@ #include "devicepage.h" #include "ui_devicepage.h" -#include "../services/deviceservice.h" - #include #include #include @@ -17,11 +15,6 @@ DevicePage::DevicePage(QWidget *parent) ui->setupUi(this); setupTable(); - connect(&DeviceService::instance(), &DeviceService::statusChanged, - this, &DevicePage::updateStatus); - connect(&DeviceService::instance(), &DeviceService::communicationError, - this, &DevicePage::handleCommunicationError); - DeviceService::instance().startPolling(); } void DevicePage::setupTable() @@ -100,6 +93,5 @@ void DevicePage::handleCommunicationError(const QString &error) DevicePage::~DevicePage() { - DeviceService::instance().stopPolling(); delete ui; } diff --git a/pages/devicepage.h b/pages/devicepage.h index 122a470..227457d 100644 --- a/pages/devicepage.h +++ b/pages/devicepage.h @@ -15,7 +15,7 @@ public: explicit DevicePage(QWidget *parent = nullptr); ~DevicePage(); -private slots: +public slots: void updateStatus(const DeviceStatus &status); void handleCommunicationError(const QString &error); diff --git a/services/deviceservice.cpp b/services/deviceservice.cpp index 7ec989f..682c72c 100644 --- a/services/deviceservice.cpp +++ b/services/deviceservice.cpp @@ -3,8 +3,6 @@ #include "../config/configmanager.h" #include "../modbus/modbustcpmanager.h" -#include -#include #include namespace { @@ -58,26 +56,37 @@ bool actionAddresses(DeviceService::ProductionAction action, } -DeviceService &DeviceService::instance() -{ - static DeviceService service; - return service; -} - DeviceService::DeviceService(QObject *parent) : QObject(parent) , m_pollTimer(new QTimer(this)) + , m_modbus(new ModbusTcpManager( + ConfigManager::instance().modbusConfig(), this)) + , m_statusRequestPending(false) + , m_controlRequestPending(false) + , m_productionActionActive(false) + , m_productionActionBusy(false) + , m_productionCommandAddress(-1) + , m_productionFeedbackAddress(-1) + , m_terminationActive(false) + , m_terminationSignalIndex(0) + , m_controlCommandAddress(-1) + , m_controlFeedbackAddress(-1) { - connect(m_pollTimer, &QTimer::timeout, this, &DeviceService::pollStatus); + connect(m_pollTimer, &QTimer::timeout, + this, &DeviceService::pollStatus); } void DeviceService::startPolling() { + if (m_terminationActive) { + return; + } + if (m_pollTimer->isActive()) { return; } - const int interval = qMax(100, ModbusTcpManager::instance().config().pollIntervalMs); + const int interval = qMax(100, m_modbus->config().pollIntervalMs); m_pollTimer->start(interval); pollStatus(); } @@ -92,68 +101,150 @@ bool DeviceService::isPolling() const return m_pollTimer->isActive(); } -bool DeviceService::readStatus(DeviceStatus *status, QString *error) +void DeviceService::requestStatus(const StatusCallback &callback) { - if (!status) { - if (error) { - *error = "Device status pointer is null"; + if (m_terminationActive) { + if (callback) { + DeviceStatus status; + callback(false, status, "PLC termination is in progress"); } - return false; + return; } if (ConfigManager::instance().simulationMode()) { - *status = simulatedStatus(); - return true; + const DeviceStatus status = simulatedStatus(); + emit statusChanged(status); + if (callback) { + callback(true, status, QString()); + } + return; } - QString configError; - if (!ConfigManager::instance().validate(&configError)) { - if (error) { - *error = configError; + if (m_statusRequestPending) { + if (callback) { + m_statusCallbacks.append(callback); } - status->plcConnected = false; - return false; + return; } - const int attempts = qMax(1, ModbusTcpManager::instance().config().reconnectAttempts + 1); - QString lastError; - for (int attempt = 0; attempt < attempts; ++attempt) { - if (attempt > 0) { - QThread::msleep(qMax(0, ModbusTcpManager::instance().config().reconnectDelayMs)); - } + m_statusRequestPending = true; + m_statusCallbacks.clear(); + if (callback) { + m_statusCallbacks.append(callback); + } + DeviceStatus status; + status.plcConnected = true; + readStatusStep(0, status); +} - if (!connectWithRetry(&lastError)) { - continue; +void DeviceService::finishStatusRequest(bool success, + const DeviceStatus &status, + const QString &error) +{ + m_statusRequestPending = false; + const QList callbacks = m_statusCallbacks; + m_statusCallbacks.clear(); + emit statusChanged(status); + if (!success && !error.isEmpty()) { + emit communicationError(error); + } + for (const StatusCallback &callback : callbacks) { + if (callback) { + callback(success, status, error); } + } +} - if (readStatusOnce(status, &lastError)) { - return true; - } - - ModbusTcpManager::instance().disconnectDevice(); +void DeviceService::readStatusStep(int index, const DeviceStatus &status) +{ + const bool useErrorCode = + ConfigManager::instance().productionConfig().usePlcErrorCode; + if (index >= (useErrorCode ? 7 : 6)) { + finishStatusRequest(true, status, QString()); + return; } - status->plcConnected = false; - if (error) { - *error = lastError.isEmpty() ? "Failed to read PLC status" : lastError; + auto failed = [this](const QString &error) { + DeviceStatus status; + status.plcConnected = false; + finishStatusRequest( + false, status, + error.isEmpty() ? "Failed to read PLC status" : error); + }; + + auto next = [this, index, status, failed]( + bool success, quint16 value, const QString &error) { + if (!success) { + failed(error); + return; + } + + DeviceStatus nextStatus = status; + switch (index) { + case 0: nextStatus.plcReady = value != 0; break; + case 1: nextStatus.robotReady = value != 0; break; + case 2: nextStatus.safetyDoorClosed = value != 0; break; + case 3: nextStatus.emergencyStop = value != 0; break; + case 4: nextStatus.currentStep = value; break; + case 5: nextStatus.checkResult = value; break; + case 6: nextStatus.errorCode = value; break; + default: break; + } + readStatusStep(index + 1, nextStatus); + }; + + const ModbusAddressMap &addresses = m_modbus->config().addressMap; + switch (index) { + case 0: + m_modbus->readCoil(addresses.plcReady, + [next](bool ok, bool value, const QString &error) { + next(ok, value ? 1 : 0, error); + }); + break; + case 1: + m_modbus->readCoil(addresses.robotReady, + [next](bool ok, bool value, const QString &error) { + next(ok, value ? 1 : 0, error); + }); + break; + case 2: + m_modbus->readCoil(addresses.safetyDoorClosed, + [next](bool ok, bool value, const QString &error) { + next(ok, value ? 1 : 0, error); + }); + break; + case 3: + m_modbus->readCoil(addresses.emergencyStop, + [next](bool ok, bool value, const QString &error) { + next(ok, value ? 1 : 0, error); + }); + break; + case 4: + m_modbus->readHoldingRegister(addresses.currentStep, next); + break; + case 5: + m_modbus->readHoldingRegister(addresses.checkResult, next); + break; + case 6: + if (useErrorCode) { + m_modbus->readHoldingRegister(addresses.errorCode, next); + } + break; } - return false; } void DeviceService::pollStatus() { - DeviceStatus status; - QString error; - if (readStatus(&status, &error)) { - emit statusChanged(status); + if (m_terminationActive || m_statusRequestPending || m_controlRequestPending + || m_productionActionBusy) { return; } - status.plcConnected = false; - emit statusChanged(status); - if (!error.isEmpty()) { - emit communicationError(error); - } + requestStatus([this](bool success, const DeviceStatus &, const QString &error) { + if (!success && !error.isEmpty()) { + emit communicationError(error); + } + }); } DeviceStatus DeviceService::simulatedStatus() const @@ -169,256 +260,619 @@ DeviceStatus DeviceService::simulatedStatus() const return status; } -bool DeviceService::start(QString *error) +void DeviceService::start(const OperationCallback &callback) { + if (m_terminationActive) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; + } + if (ConfigManager::instance().simulationMode()) { - return true; + if (callback) { + callback(true, QString()); + } + return; } if (!ConfigManager::instance().productionEnabled()) { - if (error) { - *error = "Production control is disabled by configuration"; + if (callback) { + callback(false, "Production control is disabled by configuration"); } - return false; + return; } - const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; - return executeCommand(addresses.startCommand, addresses.startFeedback, error); + const ModbusAddressMap &addresses = m_modbus->config().addressMap; + executeCommand(addresses.startCommand, addresses.startFeedback, callback); } -bool DeviceService::pause(QString *error) +void DeviceService::pause(const OperationCallback &callback) { + if (m_terminationActive) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; + } + if (ConfigManager::instance().simulationMode()) { - return true; + if (callback) { + callback(true, QString()); + } + return; } if (!ConfigManager::instance().productionEnabled()) { - if (error) { - *error = "Production control is disabled by configuration"; + if (callback) { + callback(false, "Production control is disabled by configuration"); } - return false; + return; } - const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; - return executeCommand(addresses.pauseCommand, addresses.pauseFeedback, error); + const ModbusAddressMap &addresses = m_modbus->config().addressMap; + executeCommand(addresses.pauseCommand, addresses.pauseFeedback, callback); } -bool DeviceService::reset(QString *error) +void DeviceService::reset(const OperationCallback &callback) { + if (m_terminationActive) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; + } + if (ConfigManager::instance().simulationMode()) { - return true; + if (callback) { + callback(true, QString()); + } + return; } if (!ConfigManager::instance().productionEnabled()) { - if (error) { - *error = "Production control is disabled by configuration"; + if (callback) { + callback(false, "Production control is disabled by configuration"); } - return false; + return; } - const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; - return executeCommand(addresses.resetCommand, addresses.resetFeedback, error); + const ModbusAddressMap &addresses = m_modbus->config().addressMap; + executeCommand(addresses.resetCommand, addresses.resetFeedback, callback); } -bool DeviceService::clearAlarm(QString *error) +void DeviceService::clearAlarm(const OperationCallback &callback) { + if (m_terminationActive) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; + } + if (ConfigManager::instance().simulationMode()) { - return true; + if (callback) { + callback(true, QString()); + } + return; } if (!ConfigManager::instance().productionEnabled()) { - if (error) { - *error = "Production control is disabled by configuration"; + if (callback) { + callback(false, "Production control is disabled by configuration"); } - return false; + return; } - const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; - return executeCommand(addresses.clearAlarmCommand, addresses.clearAlarmFeedback, error); + const ModbusAddressMap &addresses = m_modbus->config().addressMap; + executeCommand(addresses.clearAlarmCommand, + addresses.clearAlarmFeedback, callback); } -bool DeviceService::setInspectionMode(const QString &mode, QString *error) +void DeviceService::setInspectionMode(const QString &mode, + const OperationCallback &callback) { if (mode != "BEFORE_PLATING" && mode != "AFTER_PLATING") { - if (error) { - *error = "Inspection mode must be BEFORE_PLATING or AFTER_PLATING"; + if (callback) { + callback(false, + "Inspection mode must be BEFORE_PLATING or AFTER_PLATING"); } - return false; + return; + } + if (m_terminationActive) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; } if (ConfigManager::instance().simulationMode()) { - return true; + if (callback) { + callback(true, QString()); + } + return; } if (!ConfigManager::instance().productionEnabled()) { - if (error) { - *error = "Production control is disabled by configuration"; + if (callback) { + callback(false, "Production control is disabled by configuration"); } - return false; + return; + } + if (m_controlRequestPending || m_productionActionBusy) { + if (callback) { + callback(false, "Another PLC operation is already active"); + } + return; } + m_controlRequestPending = true; const bool afterPlating = mode == "AFTER_PLATING"; - const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; - if (!ModbusTcpManager::instance().writeCoil( - addresses.inspectionMode, afterPlating, error)) { - return false; - } - return true; + m_modbus->writeCoil( + m_modbus->config().addressMap.inspectionMode, afterPlating, + [this, callback](bool success, const QString &error) { + m_controlRequestPending = false; + if (callback) { + callback(success, error); + } + }); } -bool DeviceService::executeProductionAction(ProductionAction action, - int trayNo, int slotNo, - QString *error) +void DeviceService::terminate(const OperationCallback &callback) { + if (m_terminationActive) { + if (callback) { + callback(false, "PLC termination is already in progress"); + } + return; + } + + m_terminationActive = true; + m_terminationCallback = callback; + m_terminationSignals.clear(); + m_terminationSignalIndex = 0; + m_pollTimer->stop(); + + const QList> currentSignals = QList>() + << qMakePair(m_controlCommandAddress, m_controlFeedbackAddress) + << qMakePair(m_productionCommandAddress, + m_productionFeedbackAddress); + for (const QPair &signalPair : currentSignals) { + if (signalPair.first >= 0 && signalPair.second >= 0 + && !m_terminationSignals.contains(signalPair)) { + m_terminationSignals.append(signalPair); + } + } + + m_modbus->abortAll("PLC termination requested"); + m_statusRequestPending = false; + m_controlRequestPending = false; + m_productionActionActive = false; + m_productionActionBusy = false; + if (ConfigManager::instance().simulationMode() + || !ConfigManager::instance().productionEnabled()) { + finishTermination(true, QString()); + return; + } + clearNextTerminationSignal(); +} + +void DeviceService::clearNextTerminationSignal() +{ + if (!m_terminationActive) { + return; + } + if (m_terminationSignalIndex >= m_terminationSignals.size()) { + const ModbusAddressMap &addresses = m_modbus->config().addressMap; + executeCommand( + addresses.pauseCommand, addresses.pauseFeedback, + [this](bool success, const QString &error) { + if (!success) { + finishTermination(false, error); + return; + } + finishTermination(true, QString()); + }, true); + return; + } + + const QPair signalPair = + m_terminationSignals.at(m_terminationSignalIndex++); + clearSignals( + signalPair.first, signalPair.second, + [this](bool success, const QString &error) { + if (!success) { + finishTermination(false, error); + return; + } + clearNextTerminationSignal(); + }); +} + +void DeviceService::finishTermination(bool success, const QString &error) +{ + if (!m_terminationActive) { + return; + } + + const OperationCallback callback = m_terminationCallback; + m_terminationCallback = OperationCallback(); + m_terminationActive = false; + m_terminationSignals.clear(); + m_terminationSignalIndex = 0; + m_controlRequestPending = false; + m_productionActionActive = false; + m_productionActionBusy = false; + if (success) { + m_controlCommandAddress = -1; + m_controlFeedbackAddress = -1; + m_productionCommandAddress = -1; + m_productionFeedbackAddress = -1; + } + if (callback) { + callback(success, error); + } +} + +void DeviceService::executeCommand(int commandAddress, int feedbackAddress, + const OperationCallback &callback, + bool allowDuringTermination) +{ + if (m_terminationActive && !allowDuringTermination) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; + } + if (m_controlRequestPending || m_productionActionBusy) { + if (callback) { + callback(false, "Another PLC operation is already active"); + } + return; + } + + m_controlRequestPending = true; + m_controlCommandAddress = commandAddress; + m_controlFeedbackAddress = feedbackAddress; + writeCommandAndWaitFeedback(commandAddress, feedbackAddress, + [this, commandAddress, feedbackAddress, + callback](bool success, + const QString &error) { + m_controlRequestPending = false; + if (success + && m_controlCommandAddress + == commandAddress + && m_controlFeedbackAddress + == feedbackAddress) { + m_controlCommandAddress = -1; + m_controlFeedbackAddress = -1; + } + if (callback) { + callback(success, error); + } + }, allowDuringTermination); +} + +void DeviceService::writeCommandAndWaitFeedback( + int commandAddress, int feedbackAddress, + const OperationCallback &callback, bool allowDuringTermination) +{ + if (m_terminationActive && !allowDuringTermination) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; + } + m_modbus->writeCoil( + commandAddress, true, + [this, commandAddress, feedbackAddress, callback, + allowDuringTermination](bool success, + const QString &error) { + if (!success) { + if (callback) { + callback(false, error); + } + return; + } + pollFeedback(commandAddress, feedbackAddress, callback, + allowDuringTermination); + }); +} + +void DeviceService::pollFeedback(int commandAddress, int feedbackAddress, + const OperationCallback &callback, + bool allowDuringTermination) +{ + if (m_terminationActive && !allowDuringTermination) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; + } + m_modbus->readCoil( + feedbackAddress, + [this, commandAddress, feedbackAddress, callback, + allowDuringTermination]( + bool success, bool feedback, + const QString &error) { + if (!success) { + if (callback) { + callback(false, error); + } + return; + } + if (!feedback) { + QTimer::singleShot( + FeedbackPollIntervalMs, this, + [this, commandAddress, feedbackAddress, callback, + allowDuringTermination]() { + pollFeedback(commandAddress, feedbackAddress, callback, + allowDuringTermination); + }); + return; + } + + clearSignals(commandAddress, feedbackAddress, + [callback](bool cleared, const QString &clearError) { + if (callback) { + callback(cleared, clearError); + } + }); + }); +} + +void DeviceService::beginProductionAction( + ProductionAction action, int trayNo, int slotNo, + const OperationCallback &callback) +{ + if (m_terminationActive) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; + } if (ConfigManager::instance().simulationMode()) { - return true; + if (callback) { + callback(true, QString()); + } + return; } if (!ConfigManager::instance().productionEnabled()) { - if (error) { - *error = "Production control is disabled by configuration"; + if (callback) { + callback(false, "Production control is disabled by configuration"); } - return false; + return; + } + if (m_productionActionActive || m_productionActionBusy) { + if (callback) { + callback(false, "A PLC production action is already active"); + } + return; } if (trayNo <= 0 || slotNo < 1 || slotNo > 49) { - if (error) { - *error = "PLC tray or slot position is invalid"; + if (callback) { + callback(false, "PLC tray or slot position is invalid"); } - return false; + return; } - const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; - if (action == RackPick || action == RackPlace) { - ModbusTcpManager &modbus = ModbusTcpManager::instance(); - if (!modbus.writeHoldingRegister( - addresses.trayNumber, static_cast(trayNo), error) - || !modbus.writeHoldingRegister( - addresses.slotNumber, static_cast(slotNo), error)) { - return false; + const ModbusAddressMap &addresses = m_modbus->config().addressMap; + if (!actionAddresses(action, addresses, + &m_productionCommandAddress, + &m_productionFeedbackAddress)) { + if (callback) { + callback(false, "Unknown PLC production action"); } + return; } - int commandAddress = -1; - int feedbackAddress = -1; - if (!actionAddresses(action, addresses, &commandAddress, &feedbackAddress)) { - if (error) { - *error = "Unknown PLC production action"; - } - return false; - } - return executeCommand(commandAddress, feedbackAddress, error); + m_productionActionBusy = true; + m_modbus->readCoil( + m_productionFeedbackAddress, + [this, action, trayNo, slotNo, addresses, callback]( + bool success, bool feedback, const QString &error) { + if (!success) { + m_productionActionBusy = false; + if (callback) { + callback(false, error); + } + return; + } + if (feedback) { + m_productionActionBusy = false; + if (callback) { + callback(false, + "PLC feedback is still active before a new action"); + } + return; + } + + auto sendCommand = + [this, callback](bool success, const QString &error) { + if (!success) { + m_productionActionBusy = false; + if (callback) { + callback(false, error); + } + return; + } + + m_productionActionActive = true; + m_productionActionBusy = false; + if (callback) { + callback(true, QString()); + } + }; + + auto writeCommand = [this, sendCommand](bool success, + const QString &error) { + if (!success) { + sendCommand(false, error); + return; + } + m_modbus->writeCoil( + m_productionCommandAddress, true, sendCommand); + }; + + if (action == RackPick || action == RackPlace) { + m_modbus->writeHoldingRegister( + addresses.trayNumber, + static_cast(trayNo), + [this, addresses, slotNo, writeCommand]( + bool traySuccess, const QString &trayError) { + if (!traySuccess) { + writeCommand(false, trayError); + return; + } + m_modbus->writeHoldingRegister( + addresses.slotNumber, + static_cast(slotNo), + writeCommand); + }); + return; + } + + writeCommand(true, QString()); + }); } -bool DeviceService::connectWithRetry(QString *error) +void DeviceService::pollProductionAction(const ActionCallback &callback) { - ModbusTcpManager &modbus = ModbusTcpManager::instance(); - const ModbusConfig config = modbus.config(); - const int attempts = qMax(1, config.reconnectAttempts + 1); - QString lastError; - - for (int attempt = 0; attempt < attempts; ++attempt) { - if (attempt > 0) { - QThread::msleep(qMax(0, config.reconnectDelayMs)); + if (m_terminationActive) { + if (callback) { + callback(false, false, "PLC termination is in progress"); } - - if (modbus.connectDevice(&lastError)) { - return true; + return; + } + if (ConfigManager::instance().simulationMode()) { + if (callback) { + callback(true, true, QString()); } - modbus.disconnectDevice(); + return; + } + if (m_productionActionBusy) { + if (callback) { + callback(true, false, QString()); + } + return; + } + if (!m_productionActionActive) { + if (callback) { + callback(false, false, "No PLC production action is active"); + } + return; } - if (error) { - *error = lastError.isEmpty() ? "Failed to connect to PLC" : lastError; - } - return false; + m_productionActionBusy = true; + m_modbus->readCoil( + m_productionFeedbackAddress, + [this, callback](bool success, bool feedback, + const QString &error) { + if (!success) { + m_productionActionBusy = false; + if (callback) { + callback(false, false, error); + } + return; + } + if (!feedback) { + m_productionActionBusy = false; + if (callback) { + callback(true, false, QString()); + } + return; + } + + clearActionSignals( + [this, callback](bool cleared, const QString &clearError) { + m_productionActionBusy = false; + if (cleared) { + m_productionActionActive = false; + m_productionCommandAddress = -1; + m_productionFeedbackAddress = -1; + if (callback) { + callback(true, true, QString()); + } + } else if (callback) { + callback(false, false, clearError); + } + }); + }); } -bool DeviceService::readStatusOnce(DeviceStatus *status, QString *error) +void DeviceService::cancelProductionAction(const OperationCallback &callback) { - ModbusTcpManager &modbus = ModbusTcpManager::instance(); - const ModbusAddressMap &addresses = modbus.config().addressMap; - - status->plcConnected = true; - if (!modbus.readCoil(addresses.plcReady, &status->plcReady, error) - || !modbus.readCoil(addresses.robotReady, &status->robotReady, error) - || !modbus.readCoil(addresses.safetyDoorClosed, &status->safetyDoorClosed, error) - || !modbus.readCoil(addresses.emergencyStop, &status->emergencyStop, error) - || !modbus.readHoldingRegister(addresses.currentStep, &status->currentStep, error) - || !modbus.readHoldingRegister(addresses.checkResult, &status->checkResult, error) - || !modbus.readHoldingRegister(addresses.errorCode, &status->errorCode, error)) { - return false; + if (m_terminationActive) { + if (callback) { + callback(false, "PLC termination is in progress"); + } + return; + } + if (ConfigManager::instance().simulationMode() + || (!m_productionActionActive && !m_productionActionBusy)) { + m_productionActionActive = false; + m_productionActionBusy = false; + if (callback) { + callback(true, QString()); + } + return; + } + if (m_productionActionBusy) { + if (callback) { + callback(false, "PLC production action is busy"); + } + return; } - return true; + m_productionActionBusy = true; + clearActionSignals( + [this, callback](bool cleared, const QString &error) { + m_productionActionBusy = false; + if (cleared) { + m_productionActionActive = false; + m_productionCommandAddress = -1; + m_productionFeedbackAddress = -1; + } + if (callback) { + callback(cleared, error); + } + }); } -bool DeviceService::executeCommand(int commandAddress, int feedbackAddress, QString *error) +void DeviceService::clearActionSignals(const OperationCallback &callback) { - QString configError; - if (!ConfigManager::instance().validate(&configError)) { - if (error) { - *error = configError; + if (m_productionCommandAddress < 0 + || m_productionFeedbackAddress < 0) { + if (callback) { + callback(false, "PLC production action addresses are invalid"); } - return false; + return; } - const ModbusConfig config = ModbusTcpManager::instance().config(); - const int attempts = qMax(1, config.reconnectAttempts + 1); - QString lastError; - - for (int attempt = 0; attempt < attempts; ++attempt) { - if (attempt > 0) { - QThread::msleep(qMax(0, config.reconnectDelayMs)); - } - - if (!connectWithRetry(&lastError)) { - continue; - } - - ModbusTcpManager &modbus = ModbusTcpManager::instance(); - if (!modbus.writeCoil(commandAddress, true, &lastError)) { - modbus.disconnectDevice(); - continue; - } - - if (!waitForFeedback(feedbackAddress, &lastError)) { - modbus.writeCoil(commandAddress, false); - modbus.disconnectDevice(); - continue; - } - - if (!modbus.writeCoil(commandAddress, false, &lastError)) { - modbus.disconnectDevice(); - continue; - } - if (!modbus.writeCoil(feedbackAddress, false, &lastError)) { - modbus.disconnectDevice(); - continue; - } - - return true; - } - - if (error) { - *error = lastError.isEmpty() ? "PLC command failed" : lastError; - } - return false; + clearSignals(m_productionCommandAddress, m_productionFeedbackAddress, + callback); } -bool DeviceService::waitForFeedback(int address, QString *error) +void DeviceService::clearSignals(int commandAddress, int feedbackAddress, + const OperationCallback &callback) { - ModbusTcpManager &modbus = ModbusTcpManager::instance(); -// const int timeoutMs = qMax(1, modbus.config().feedbackTimeoutMs); -// QElapsedTimer timer; -// timer.start(); - - //while (timer.elapsed() < timeoutMs) { - while (true) { - bool feedback = false; - if (!modbus.readCoil(address, &feedback, error)) { - return false; - } - if (feedback) { - return true; - } - QThread::msleep(FeedbackPollIntervalMs); - } - - if (error) { - *error = QString("PLC feedback timeout at address %1").arg(address); - } - return false; + m_modbus->writeCoil( + commandAddress, false, + [this, feedbackAddress, callback](bool commandCleared, + const QString &commandError) { + m_modbus->writeCoil( + feedbackAddress, false, + [callback, commandCleared, commandError]( + bool feedbackCleared, const QString &feedbackError) { + if (callback) { + callback(commandCleared && feedbackCleared, + commandCleared ? feedbackError + : commandError); + } + }); + }); +} + +bool DeviceService::productionActionActive() const +{ + return m_productionActionActive; +} + +bool DeviceService::productionActionBusy() const +{ + return m_productionActionBusy || m_modbus->isBusy(); } diff --git a/services/deviceservice.h b/services/deviceservice.h index d9a706c..a2961e3 100644 --- a/services/deviceservice.h +++ b/services/deviceservice.h @@ -3,7 +3,10 @@ #include #include +#include #include +#include +#include struct DeviceStatus { @@ -26,6 +29,12 @@ class DeviceService : public QObject Q_OBJECT public: + using OperationCallback = std::function; + using StatusCallback = + std::function; + using ActionCallback = + std::function; + enum ProductionAction { RackPick, @@ -38,38 +47,68 @@ public: RackPlace }; - static DeviceService &instance(); + explicit DeviceService(QObject *parent = nullptr); void startPolling(); void stopPolling(); bool isPolling() const; - bool readStatus(DeviceStatus *status, QString *error = nullptr); - bool start(QString *error = nullptr); - bool pause(QString *error = nullptr); - bool reset(QString *error = nullptr); - bool clearAlarm(QString *error = nullptr); - bool setInspectionMode(const QString &mode, QString *error = nullptr); - bool executeProductionAction(ProductionAction action, int trayNo, - int slotNo, QString *error = nullptr); + void requestStatus(const StatusCallback &callback); + void start(const OperationCallback &callback); + void pause(const OperationCallback &callback); + void reset(const OperationCallback &callback); + void clearAlarm(const OperationCallback &callback); + void setInspectionMode(const QString &mode, + const OperationCallback &callback); + void terminate(const OperationCallback &callback); + void beginProductionAction(ProductionAction action, int trayNo, + int slotNo, const OperationCallback &callback); + void pollProductionAction(const ActionCallback &callback); + void cancelProductionAction(const OperationCallback &callback); + bool productionActionActive() const; + bool productionActionBusy() const; signals: void statusChanged(const DeviceStatus &status); void communicationError(const QString &error); private: - explicit DeviceService(QObject *parent = nullptr); - DeviceService(const DeviceService &) = delete; - DeviceService &operator=(const DeviceService &) = delete; - void pollStatus(); DeviceStatus simulatedStatus() const; - bool connectWithRetry(QString *error); - bool readStatusOnce(DeviceStatus *status, QString *error); - bool executeCommand(int commandAddress, int feedbackAddress, QString *error); - bool waitForFeedback(int address, QString *error); + void readStatusStep(int index, const DeviceStatus &status); + void finishStatusRequest(bool success, const DeviceStatus &status, + const QString &error); + void executeCommand(int commandAddress, int feedbackAddress, + const OperationCallback &callback, + bool allowDuringTermination = false); + void writeCommandAndWaitFeedback(int commandAddress, int feedbackAddress, + const OperationCallback &callback, + bool allowDuringTermination = false); + void pollFeedback(int commandAddress, int feedbackAddress, + const OperationCallback &callback, + bool allowDuringTermination = false); + void clearSignals(int commandAddress, int feedbackAddress, + const OperationCallback &callback); + void clearActionSignals(const OperationCallback &callback); + void clearNextTerminationSignal(); + void finishTermination(bool success, const QString &error); + void finishActionPoll(bool completed, const ActionCallback &callback); QTimer *m_pollTimer; + class ModbusTcpManager *m_modbus; + bool m_statusRequestPending; + QList m_statusCallbacks; + bool m_controlRequestPending; + bool m_productionActionActive; + bool m_productionActionBusy; + int m_productionCommandAddress; + int m_productionFeedbackAddress; + bool m_terminationActive; + QList> m_terminationSignals; + int m_terminationSignalIndex; + OperationCallback m_terminationCallback; + int m_controlCommandAddress; + int m_controlFeedbackAddress; }; #endif // DEVICESERVICE_H diff --git a/services/productionservice.cpp b/services/productionservice.cpp index 898ce20..63fa567 100644 --- a/services/productionservice.cpp +++ b/services/productionservice.cpp @@ -7,8 +7,15 @@ #include "workpieceservice.h" #include +#include #include +namespace { + +const int ProductionTickIntervalMs = 50; + +} + ProductionService &ProductionService::instance() { static ProductionService service; @@ -18,6 +25,7 @@ ProductionService &ProductionService::instance() ProductionService::ProductionService(QObject *parent) : QObject(parent) , m_timer(new QTimer(this)) + , m_deviceService(new DeviceService(this)) , m_state(Idle) , m_timeoutState(Idle) , m_runId(0) @@ -28,12 +36,27 @@ ProductionService::ProductionService(QObject *parent) , m_currentTrayNo(0) , m_currentSlotNo(0) , m_frontRawResult(0) + , m_actionPending(false) + , m_actionStarting(false) + , m_actionPollPending(false) + , m_actionCompleted(false) + , m_actionCancelRequested(false) + , m_inspectionStatusPending(false) + , m_inspectionStatusReady(false) + , m_starting(false) + , m_plcStarted(false) + , m_tickRunning(false) + , m_pendingAction(DeviceService::RackPick) + , m_stopRequested(false) + , m_externalStopRequested(nullptr) + , m_shutdownRequested(false) { connect(m_timer, &QTimer::timeout, this, &ProductionService::tick); - connect(&DeviceService::instance(), &DeviceService::statusChanged, + connect(m_deviceService, &DeviceService::statusChanged, this, &ProductionService::onDeviceStatusChanged); - connect(&DeviceService::instance(), &DeviceService::communicationError, + connect(m_deviceService, &DeviceService::communicationError, this, &ProductionService::onCommunicationError); + m_deviceService->startPolling(); } ProductionService::State ProductionService::state() const @@ -72,6 +95,7 @@ QString ProductionService::stateNameForState(State state) const case RecoveryChecking: return "RECOVERY_CHECKING"; case ManualConfirm: return "MANUAL_CONFIRM"; case Retrying: return "RETRYING"; + case Terminating: return "TERMINATING"; } return "UNKNOWN"; } @@ -101,6 +125,16 @@ Workpiece ProductionService::currentWorkpiece() const return m_currentWorkpiece; } +void ProductionService::setExternalStopFlag(std::atomic_bool *flag) +{ + m_externalStopRequested = flag; +} + +void ProductionService::requestStopImmediate() +{ + m_stopRequested.store(true); +} + bool ProductionService::start(int orderId, QString *error) { if (orderId <= 0) { @@ -131,15 +165,15 @@ bool ProductionService::start(int orderId, QString *error) m_currentTrayNo = 0; m_currentSlotNo = 0; m_frontRawResult = 0; + m_actionPending = false; + m_actionStarting = false; + m_actionPollPending = false; + m_actionCompleted = false; + m_actionError.clear(); m_frontResultState.clear(); - - if (!DeviceService::instance().setInspectionMode( - m_inspectionMode, error)) { - return false; - } - if (!DeviceService::instance().start(error) - || !OrderService::instance().startOrder(orderId, error)) { - return false; + m_stopRequested.store(false); + if (m_externalStopRequested) { + m_externalStopRequested->store(false); } m_orderId = orderId; @@ -148,6 +182,8 @@ bool ProductionService::start(int orderId, QString *error) m_deviceStatusValid = false; m_recoveryRetryCount = 0; m_lastError.clear(); + m_starting = true; + m_plcStarted = false; QString persistenceError; m_runId = ProductionRepository().createRun( @@ -155,9 +191,8 @@ bool ProductionService::start(int orderId, QString *error) order.startTrayNo, order.startSlotNo, order.planNum, &persistenceError); if (m_runId <= 0) { - DeviceService::instance().pause(); - OrderService::instance().pauseOrder(m_orderId); m_orderId = 0; + m_starting = false; if (error) { *error = "Failed to create production run: " + persistenceError; } @@ -166,12 +201,64 @@ bool ProductionService::start(int orderId, QString *error) setState(Preparing); - DeviceService::instance().startPolling(); - const int interval = qMax(100, ConfigManager::instance() - .modbusConfig().pollIntervalMs); + m_deviceService->startPolling(); + const int interval = ProductionTickIntervalMs; m_heartbeatTimer.restart(); m_timer->start(interval); - tick(); + + m_deviceService->requestStatus( + [this](bool success, const DeviceStatus &, const QString &statusError) { + if (!success) { + fail(statusError); + return; + } + if (stopRequested()) { + return; + } + + QString safetyError; + if (!checkRecoverySafety(&safetyError)) { + fail(safetyError); + return; + } + + m_deviceService->setInspectionMode( + m_inspectionMode, + [this](bool modeSuccess, const QString &modeError) { + if (!modeSuccess) { + fail(modeError); + return; + } + if (stopRequested()) { + return; + } + + m_deviceService->start( + [this](bool startSuccess, + const QString &startError) { + if (!startSuccess) { + fail(startError); + return; + } + if (stopRequested()) { + return; + } + + m_plcStarted = true; + QString orderError; + if (!OrderService::instance().startOrder( + m_orderId, &orderError)) { + m_deviceService->pause( + [](bool, const QString &) {}); + fail(orderError); + return; + } + + m_starting = false; + tick(); + }); + }); + }); return true; } @@ -184,15 +271,33 @@ bool ProductionService::pause(QString *error) return false; } - if (!DeviceService::instance().pause(error) - || !OrderService::instance().pauseOrder(m_orderId, error)) { - return false; - } + cancelPendingProductionAction( + [this](bool canceled, const QString &cancelError) { + if (!canceled) { + emit productionError(cancelError); + return; + } - pauseProcessTimer(); - m_timer->stop(); - setState(Paused); - emitProcessElapsed(); + m_deviceService->pause( + [this](bool paused, const QString &pauseError) { + if (!paused) { + emit productionError(pauseError); + return; + } + + QString orderError; + if (!OrderService::instance().pauseOrder( + m_orderId, &orderError)) { + emit productionError(orderError); + return; + } + + pauseProcessTimer(); + m_timer->stop(); + setState(Paused); + emitProcessElapsed(); + }); + }); return true; } @@ -205,24 +310,53 @@ bool ProductionService::resume(QString *error) return false; } - if (!checkRecoverySafety(error) - || !DeviceService::instance().setInspectionMode( - m_inspectionMode, error) - || !DeviceService::instance().start(error) - || !OrderService::instance().resumeOrder(m_orderId, error)) { + if (!checkRecoverySafety(error)) { return false; } - resumeProcessTimer(); - setState(m_currentWorkpiece.id > 0 ? WaitingDeviceReady : Preparing); - const int interval = qMax(100, ConfigManager::instance() - .modbusConfig().pollIntervalMs); - m_timer->start(interval); + m_deviceService->setInspectionMode( + m_inspectionMode, + [this](bool modeSuccess, const QString &modeError) { + if (!modeSuccess) { + emit productionError(modeError); + return; + } + + m_deviceService->start( + [this](bool startSuccess, const QString &startError) { + if (!startSuccess) { + emit productionError(startError); + return; + } + + QString orderError; + if (!OrderService::instance().resumeOrder( + m_orderId, &orderError)) { + emit productionError(orderError); + return; + } + + resumeProcessTimer(); + State resumeState = Preparing; + if (m_currentWorkpiece.id > 0) { + resumeState = stateForProcessStep( + m_currentWorkpiece.processStep); + if (resumeState == Idle) { + resumeState = WaitingDeviceReady; + } + } + setState(resumeState); + m_timer->start(ProductionTickIntervalMs); + }); + }); return true; } bool ProductionService::stop(QString *error) { + if (m_state == Terminating) { + return true; + } if (m_state == Idle || m_state == Completed) { if (error) { *error = "Production service is not running"; @@ -230,54 +364,103 @@ bool ProductionService::stop(QString *error) return false; } - QString operationError; - if (m_state != Paused && m_state != TimeoutPaused - && m_state != ManualConfirm - && !DeviceService::instance().pause(&operationError)) { - if (error) { - *error = operationError; - } - return false; - } - - Order order; - if (!OrderService::instance().findOrder(m_orderId, &order, &operationError)) { - if (error) { - *error = operationError; - } - return false; - } - if (order.status == "RUNNING" - && !OrderService::instance().pauseOrder(m_orderId, &operationError)) { - if (error) { - *error = operationError; - } - return false; - } - m_lastError = "Production stopped by operator"; m_timer->stop(); - setState(Idle); + setState(Terminating); - QString persistenceError; - if (m_runId > 0 - && !ProductionRepository().finishRun( - m_runId, "STOPPED", m_lastError, &persistenceError)) { - if (error) { - *error = persistenceError; + auto failTermination = [this](const QString &terminationError) { + m_lastError = terminationError.isEmpty() + ? "PLC termination cleanup failed" : terminationError; + m_stopRequested.store(false); + if (m_externalStopRequested) { + m_externalStopRequested->store(false); } - return false; + setState(Error); + persistAlarm("TERMINATION_FAILED", m_lastError); + emit productionError(m_lastError); + emit alarmRaised("TERMINATION_FAILED", m_lastError); + finishShutdown(false, m_lastError); + }; + + m_deviceService->terminate( + [this, failTermination](bool cleaned, const QString &cleanupError) { + if (!cleaned) { + failTermination(cleanupError); + return; + } + + QString orderError; + Order order; + if (!OrderService::instance().findOrder( + m_orderId, &order, &orderError)) { + failTermination(orderError); + return; + } + if (order.status == "RUNNING" + && !OrderService::instance().pauseOrder( + m_orderId, &orderError)) { + failTermination(orderError); + return; + } + + QString persistenceError; + if (m_runId > 0 + && !ProductionRepository().finishRun( + m_runId, "STOPPED", m_lastError, + &persistenceError)) { + failTermination(persistenceError); + return; + } + + persistRecoveryAction("STOP", m_lastError); + setState(Idle); + m_runId = 0; + m_orderId = 0; + m_currentWorkpiece = Workpiece(); + m_starting = false; + m_plcStarted = false; + clearProcessTimer(); + emit currentWorkpieceChanged(0, QString()); + emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); + emit currentPositionChanged(0, 0); + m_stopRequested.store(false); + if (m_externalStopRequested) { + m_externalStopRequested->store(false); + } + finishShutdown(true, QString()); + }); + return true; +} + +void ProductionService::shutdown(const DeviceService::OperationCallback &callback) +{ + if (m_shutdownRequested) { + if (callback) { + callback(false, "Production shutdown is already in progress"); + } + return; } - persistRecoveryAction("STOP", m_lastError); - m_runId = 0; - m_orderId = 0; - m_currentWorkpiece = Workpiece(); - clearProcessTimer(); - emit currentWorkpieceChanged(0, QString()); - emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); - emit currentPositionChanged(0, 0); - return true; + m_shutdownRequested = true; + m_shutdownCallback = callback; + if (m_state != Idle && m_state != Completed) { + QString stopError; + if (!stop(&stopError)) { + finishShutdown(false, stopError); + } + return; + } + + m_timer->stop(); + m_deviceService->terminate( + [this](bool cleaned, const QString &cleanupError) { + if (!cleaned) { + finishShutdown(false, cleanupError); + return; + } + setState(Idle); + finishShutdown(true, QString()); + }); } bool ProductionService::reset(QString *error) @@ -289,34 +472,74 @@ bool ProductionService::reset(QString *error) return false; } - if (!DeviceService::instance().reset(error) - || !DeviceService::instance().clearAlarm(error)) { - return false; - } + cancelPendingProductionAction( + [this](bool canceled, const QString &cancelError) { + if (!canceled) { + emit productionError(cancelError); + return; + } - QString persistenceError; - if (!ProductionRepository().clearActiveAlarms( - QString(), "SYSTEM", &persistenceError)) { - if (error) { - *error = persistenceError; - } - return false; - } + m_deviceService->reset( + [this](bool resetSuccess, const QString &resetError) { + if (!resetSuccess) { + emit productionError(resetError); + return; + } - if (m_currentWorkpiece.id > 0 - && !WorkpieceService::instance().updateState( - m_currentWorkpiece.id, "PENDING", "RECOVERY", error)) { - return false; - } + m_deviceService->clearAlarm( + [this](bool alarmCleared, + const QString &alarmError) { + if (!alarmCleared) { + emit productionError(alarmError); + return; + } - m_currentWorkpiece = Workpiece(); - clearProcessTimer(); - m_lastError.clear(); - setState(Preparing); - const int interval = qMax(100, ConfigManager::instance() - .modbusConfig().pollIntervalMs); - m_heartbeatTimer.restart(); - m_timer->start(interval); + QString persistenceError; + if (!ProductionRepository().clearActiveAlarms( + QString(), "SYSTEM", + &persistenceError)) { + emit productionError(persistenceError); + return; + } + + QString workpieceError; + if (m_currentWorkpiece.id > 0 + && !WorkpieceService::instance().updateState( + m_currentWorkpiece.id, "PENDING", + "RECOVERY", &workpieceError)) { + emit productionError(workpieceError); + return; + } + + m_currentWorkpiece = Workpiece(); + clearProcessTimer(); + m_lastError.clear(); + setState(Preparing); + m_heartbeatTimer.restart(); + m_timer->start(ProductionTickIntervalMs); + }); + }); + }); + return true; +} + +bool ProductionService::clearAlarm(QString *error) +{ + Q_UNUSED(error) + m_deviceService->clearAlarm( + [this](bool success, const QString &operationError) { + if (!success) { + emit productionError(operationError); + return; + } + + QString persistenceError; + if (!ProductionRepository().clearActiveAlarms( + QString(), "OPERATOR", &persistenceError)) { + emit productionError(persistenceError); + return; + } + }); return true; } @@ -395,25 +618,36 @@ bool ProductionService::recover(QString *error) } QString operationError; - if (!ensureOrderRunning(&operationError) - || !DeviceService::instance().setInspectionMode( - m_inspectionMode, &operationError) - || !DeviceService::instance().start(&operationError)) { + if (!ensureOrderRunning(&operationError)) { if (error) { *error = operationError; } return false; } - persistRecoveryAction("CONTINUE", - QString("Continue recovery from %1").arg(stateName())); - setState(RecoveryChecking); - const int interval = qMax(100, ConfigManager::instance() - .modbusConfig().pollIntervalMs); - m_heartbeatTimer.restart(); - m_timer->start(interval); - tick(); - return m_state != Error; + m_deviceService->setInspectionMode( + m_inspectionMode, + [this](bool modeSuccess, const QString &modeError) { + if (!modeSuccess) { + emit productionError(modeError); + return; + } + m_deviceService->start( + [this](bool startSuccess, const QString &startError) { + if (!startSuccess) { + emit productionError(startError); + return; + } + persistRecoveryAction( + "CONTINUE", + QString("Continue recovery from %1").arg(stateName())); + setState(RecoveryChecking); + m_heartbeatTimer.restart(); + m_timer->start(ProductionTickIntervalMs); + tick(); + }); + }); + return true; } bool ProductionService::retry(QString *error) @@ -438,10 +672,7 @@ bool ProductionService::retry(QString *error) } QString operationError; - if (!ensureOrderRunning(&operationError) - || !DeviceService::instance().setInspectionMode( - m_inspectionMode, &operationError) - || !DeviceService::instance().start(&operationError)) { + if (!ensureOrderRunning(&operationError)) { if (error) { *error = operationError; } @@ -454,21 +685,38 @@ bool ProductionService::retry(QString *error) } return false; } - if (!updateCurrentProcessStep(processStep, &operationError, true)) { - if (error) { - *error = operationError; - } - return false; - } + m_deviceService->setInspectionMode( + m_inspectionMode, + [this, processStep](bool modeSuccess, const QString &modeError) { + if (!modeSuccess) { + emit productionError(modeError); + return; + } - ++m_recoveryRetryCount; - persistRecoveryAction("RETRY", - QString("Retry production step %1").arg(processStep)); - setState(Retrying); - const int interval = qMax(100, ConfigManager::instance() - .modbusConfig().pollIntervalMs); - m_heartbeatTimer.restart(); - m_timer->start(interval); + m_deviceService->start( + [this, processStep](bool startSuccess, + const QString &startError) { + if (!startSuccess) { + emit productionError(startError); + return; + } + + QString operationError; + if (!updateCurrentProcessStep( + processStep, &operationError, true)) { + emit productionError(operationError); + return; + } + + ++m_recoveryRetryCount; + persistRecoveryAction( + "RETRY", + QString("Retry production step %1").arg(processStep)); + setState(Retrying); + m_heartbeatTimer.restart(); + m_timer->start(ProductionTickIntervalMs); + }); + }); return true; } @@ -491,43 +739,48 @@ bool ProductionService::markCurrentWorkpieceNg(QString *error) } QString operationError; - if (!ensureOrderRunning(&operationError) - || !DeviceService::instance().start(&operationError)) { + if (!ensureOrderRunning(&operationError)) { if (error) { *error = operationError; } return false; } - const int durationMs = currentProcessElapsedMs(); - const QString previousProcessStep = m_currentWorkpiece.processStep; - if (!WorkpieceService::instance().completeWithInspection( - m_currentWorkpiece.id, "NG", "COMPLETE", previousProcessStep, - durationMs, -1, "NG", m_deviceStatus.currentStep, - m_inspectionMode, "MANUAL", - &operationError)) { - if (error) { - *error = operationError; - } - return false; - } + m_deviceService->start( + [this](bool startSuccess, const QString &startError) { + if (!startSuccess) { + emit productionError(startError); + return; + } - persistRecoveryAction( - "MARK_NG", - QString("Current workpiece %1 was manually marked as NG") - .arg(m_currentWorkpiece.barcode)); - m_currentWorkpiece = Workpiece(); - clearProcessTimer(); - m_recoveryRetryCount = 0; - m_lastError.clear(); - emit currentWorkpieceChanged(0, QString()); - emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); - emit currentPositionChanged(0, 0); - setState(Preparing); - const int interval = qMax(100, ConfigManager::instance() - .modbusConfig().pollIntervalMs); - m_heartbeatTimer.restart(); - m_timer->start(interval); + const int durationMs = currentProcessElapsedMs(); + const QString previousProcessStep = + m_currentWorkpiece.processStep; + QString operationError; + if (!WorkpieceService::instance().completeWithInspection( + m_currentWorkpiece.id, "NG", "COMPLETE", + previousProcessStep, durationMs, -1, "NG", + m_deviceStatus.currentStep, m_inspectionMode, "MANUAL", + &operationError)) { + emit productionError(operationError); + return; + } + + persistRecoveryAction( + "MARK_NG", + QString("Current workpiece %1 was manually marked as NG") + .arg(m_currentWorkpiece.barcode)); + m_currentWorkpiece = Workpiece(); + clearProcessTimer(); + m_recoveryRetryCount = 0; + m_lastError.clear(); + emit currentWorkpieceChanged(0, QString()); + emit currentWorkpieceSnapshotChanged(m_currentWorkpiece); + emit currentPositionChanged(0, 0); + setState(Preparing); + m_heartbeatTimer.restart(); + m_timer->start(ProductionTickIntervalMs); + }); return true; } @@ -648,6 +901,145 @@ bool ProductionService::updateCurrentProcessStep(const QString &processStep, return true; } +bool ProductionService::processProductionAction( + DeviceService::ProductionAction action, bool *completed, QString *error) +{ + if (!completed) { + if (error) { + *error = "Action completion pointer is null"; + } + return false; + } + *completed = false; + + if (ConfigManager::instance().simulationMode()) { + *completed = true; + return true; + } + + if (!m_actionPending) { + m_pendingAction = action; + m_actionPending = true; + m_actionStarting = true; + m_actionPollPending = false; + m_actionCompleted = false; + m_actionError.clear(); + m_deviceService->beginProductionAction( + action, m_currentTrayNo, m_currentSlotNo, + [this](bool success, const QString &actionError) { + m_actionStarting = false; + if (!success) { + m_actionError = actionError; + } + tryDeferredActionCancel(); + }); + return true; + } + + if (m_pendingAction != action) { + if (error) { + *error = "PLC production action does not match current state"; + } + return false; + } + + if (!m_actionError.isEmpty()) { + if (error) { + *error = m_actionError; + } + return false; + } + + if (m_actionStarting || m_actionPollPending) { + return true; + } + + if (m_actionCompleted) { + *completed = true; + m_actionPending = false; + m_actionCompleted = false; + return true; + } + + m_actionPollPending = true; + m_deviceService->pollProductionAction( + [this](bool success, bool completed, + const QString &actionError) { + m_actionPollPending = false; + if (!success) { + m_actionError = actionError; + return; + } + if (completed) { + m_actionCompleted = true; + } + tryDeferredActionCancel(); + }); + return true; +} + +void ProductionService::cancelPendingProductionAction( + const DeviceService::OperationCallback &callback) +{ + if (!m_actionPending) { + if (callback) { + callback(true, QString()); + } + return; + } + + if (m_actionStarting || m_actionPollPending) { + m_actionCancelRequested = true; + m_deferredCancelCallback = callback; + return; + } + + m_deviceService->cancelProductionAction( + [this, callback](bool success, const QString &error) { + if (success) { + m_actionPending = false; + m_actionCompleted = false; + m_actionError.clear(); + m_actionCancelRequested = false; + } + if (callback) { + callback(success, error); + } + }); +} + +void ProductionService::tryDeferredActionCancel() +{ + if (!m_actionCancelRequested + || m_actionStarting || m_actionPollPending) { + return; + } + + m_actionCancelRequested = false; + const DeviceService::OperationCallback callback = + m_deferredCancelCallback; + m_deferredCancelCallback = DeviceService::OperationCallback(); + + if (!m_actionPending) { + if (callback) { + callback(true, QString()); + } + return; + } + + m_deviceService->cancelProductionAction( + [this, callback](bool success, const QString &error) { + if (success) { + m_actionPending = false; + m_actionCompleted = false; + m_actionError.clear(); + } + if (callback) { + callback(success, error); + } + }); +} + bool ProductionService::executeCurrentAction( DeviceService::ProductionAction action, const QString &nextProcessStep, State nextState, QString *error) @@ -659,8 +1051,11 @@ bool ProductionService::executeCurrentAction( return false; } - if (!DeviceService::instance().executeProductionAction( - action, m_currentTrayNo, m_currentSlotNo, error)) { + bool completed = false; + if (!processProductionAction(action, &completed, error)) { + return false; + } + if (!completed) { return false; } if (!updateCurrentProcessStep(nextProcessStep, error)) { @@ -803,7 +1198,8 @@ bool ProductionService::checkRecoverySafety(QString *error) const } return false; } - if (m_deviceStatus.errorCode > 0) { + if (ConfigManager::instance().productionConfig().usePlcErrorCode + && m_deviceStatus.errorCode > 0) { if (error) { *error = QString("PLC error code: %1").arg(m_deviceStatus.errorCode); } @@ -918,10 +1314,29 @@ bool ProductionService::finishOrder(QString *error) void ProductionService::tick() { + if (m_state == Terminating) { + return; + } + if (m_tickRunning) { + return; + } + QScopedValueRollback tickGuard(m_tickRunning, true); + + if (stopRequested() + && m_state != Idle && m_state != Completed) { + QString stopError; + stop(&stopError); + return; + } + if (!isActive()) { return; } + if (m_starting) { + return; + } + if (!m_deviceStatusValid) { return; } @@ -953,7 +1368,8 @@ void ProductionService::tick() fail("Safety door is open"); return; } - if (m_deviceStatus.errorCode > 0) { + if (ConfigManager::instance().productionConfig().usePlcErrorCode + && m_deviceStatus.errorCode > 0) { fail(QString("PLC error code: %1").arg(m_deviceStatus.errorCode)); return; } @@ -970,10 +1386,17 @@ void ProductionService::tick() if (m_state == WaitingDeviceReady) { if (m_deviceStatus.plcReady && m_deviceStatus.robotReady) { QString error; - if (!updateCurrentProcessStep("RACK_PICKING", &error)) { - fail(error); - } else { - setState(RackPicking); + State nextState = stateForProcessStep( + m_currentWorkpiece.processStep); + if (nextState == Idle || nextState == WaitingDeviceReady) { + if (!updateCurrentProcessStep("RACK_PICKING", &error)) { + fail(error); + return; + } + nextState = RackPicking; + } + if (error.isEmpty()) { + setState(nextState); } } emitProcessElapsed(); @@ -1036,16 +1459,36 @@ bool ProductionService::processProductionStep(State state, QString *error) return executeCurrentAction(DeviceService::FrontLoad, "FRONT_CHECKING", FrontChecking, error); case FrontChecking: { - if (!DeviceService::instance().executeProductionAction( - DeviceService::Inspect, m_currentTrayNo, m_currentSlotNo, error)) { + bool completed = false; + if (!processProductionAction( + DeviceService::Inspect, &completed, error)) { + return false; + } + if (!completed) { return false; } if (!ConfigManager::instance().simulationMode()) { - DeviceStatus status; - if (!DeviceService::instance().readStatus(&status, error)) { - return false; + if (!m_inspectionStatusReady) { + if (!m_inspectionStatusPending) { + m_inspectionStatusPending = true; + m_deviceService->requestStatus( + [this](bool success, const DeviceStatus &, + const QString &statusError) { + m_inspectionStatusPending = false; + m_inspectionStatusReady = success; + m_inspectionStatusError = statusError; + }); + } + if (m_inspectionStatusPending) { + return true; + } + if (!m_inspectionStatusReady) { + if (error) { + *error = m_inspectionStatusError; + } + return false; + } } - onDeviceStatusChanged(status); } const int frontRawResult = ConfigManager::instance().simulationMode() ? ConfigManager::instance().productionConfig().simulationResult @@ -1063,6 +1506,8 @@ bool ProductionService::processProductionStep(State state, QString *error) frontResultState, error)) { return false; } + m_inspectionStatusReady = false; + m_inspectionStatusError.clear(); m_frontRawResult = frontRawResult; m_frontResultState = frontResultState; if (!updateCurrentProcessStep("FRONT_UNLOADING", error)) { @@ -1084,16 +1529,36 @@ bool ProductionService::processProductionStep(State state, QString *error) return executeCurrentAction(DeviceService::BackLoad, "BACK_CHECKING", BackChecking, error); case BackChecking: { - if (!DeviceService::instance().executeProductionAction( - DeviceService::Inspect, m_currentTrayNo, m_currentSlotNo, error)) { + bool completed = false; + if (!processProductionAction( + DeviceService::Inspect, &completed, error)) { + return false; + } + if (!completed) { return false; } if (!ConfigManager::instance().simulationMode()) { - DeviceStatus status; - if (!DeviceService::instance().readStatus(&status, error)) { - return false; + if (!m_inspectionStatusReady) { + if (!m_inspectionStatusPending) { + m_inspectionStatusPending = true; + m_deviceService->requestStatus( + [this](bool success, const DeviceStatus &, + const QString &statusError) { + m_inspectionStatusPending = false; + m_inspectionStatusReady = success; + m_inspectionStatusError = statusError; + }); + } + if (m_inspectionStatusPending) { + return true; + } + if (!m_inspectionStatusReady) { + if (error) { + *error = m_inspectionStatusError; + } + return false; + } } - onDeviceStatusChanged(status); } const int backRawResult = ConfigManager::instance().simulationMode() ? ConfigManager::instance().productionConfig().simulationResult @@ -1111,6 +1576,8 @@ bool ProductionService::processProductionStep(State state, QString *error) backResultState, error)) { return false; } + m_inspectionStatusReady = false; + m_inspectionStatusError.clear(); const QString finalState = m_frontResultState == "OK" && backResultState == "OK" ? "OK" : "NG"; @@ -1125,9 +1592,12 @@ bool ProductionService::processProductionStep(State state, QString *error) return executeCurrentAction(DeviceService::BackUnload, "RACK_PLACING", RackPlacing, error); case RackPlacing: { - if (!DeviceService::instance().executeProductionAction( - DeviceService::RackPlace, m_currentTrayNo, m_currentSlotNo, - error)) { + bool completed = false; + if (!processProductionAction( + DeviceService::RackPlace, &completed, error)) { + return false; + } + if (!completed) { return false; } QString finalState = m_frontResultState; @@ -1235,6 +1705,25 @@ QString ProductionService::processStepForState(State state) const } } +ProductionService::State ProductionService::stateForProcessStep( + const QString &processStep) const +{ + if (processStep == "PREPARING") return Preparing; + if (processStep == "WAITING_DEVICE_READY") return WaitingDeviceReady; + if (processStep == "RACK_PICKING") return RackPicking; + if (processStep == "FRONT_LOADING") return FrontLoading; + if (processStep == "LOADING") return Loading; + if (processStep == "FRONT_CHECKING") return FrontChecking; + if (processStep == "FRONT_UNLOADING") return FrontUnloading; + if (processStep == "FLIPPING") return Flipping; + if (processStep == "BACK_LOADING") return BackLoading; + if (processStep == "BACK_CHECKING") return BackChecking; + if (processStep == "BACK_UNLOADING") return BackUnloading; + if (processStep == "RACK_PLACING") return RackPlacing; + if (processStep == "JUDGING") return Judging; + return Idle; +} + QString ProductionService::runStateForState(State state) const { switch (state) { @@ -1249,6 +1738,8 @@ QString ProductionService::runStateForState(State state) const case ManualConfirm: case Retrying: return "RECOVERY"; + case Terminating: + return "STOPPING"; case Idle: return "STOPPED"; default: @@ -1280,6 +1771,7 @@ ProductionService::State ProductionService::stateFromName(const QString &name) c if (name == "RECOVERY_CHECKING") return RecoveryChecking; if (name == "MANUAL_CONFIRM") return ManualConfirm; if (name == "RETRYING") return Retrying; + if (name == "TERMINATING") return Terminating; return Idle; } @@ -1319,11 +1811,20 @@ void ProductionService::persistDeviceStatus(const DeviceStatus &status) void ProductionService::fail(const QString &error) { + if (m_state == Terminating) { + return; + } if (m_state == Error) { return; } m_lastError = error.isEmpty() ? "Production failed" : error; + cancelPendingProductionAction( + [this](bool success, const QString &cleanupError) { + if (!success && !cleanupError.isEmpty()) { + qWarning() << "PLC action cleanup failed:" << cleanupError; + } + }); m_timer->stop(); setState(Error); QString alarmCode = "PRODUCTION"; @@ -1341,11 +1842,33 @@ void ProductionService::fail(const QString &error) emit alarmRaised(alarmCode, m_lastError); } +void ProductionService::finishShutdown(bool success, const QString &error) +{ + if (!m_shutdownRequested) { + return; + } + + const DeviceService::OperationCallback callback = m_shutdownCallback; + m_shutdownCallback = DeviceService::OperationCallback(); + m_shutdownRequested = false; + if (callback) { + callback(success, error); + } +} + bool ProductionService::isActive() const { return m_state != Idle && m_state != Error && m_state != Completed && m_state != Paused - && m_state != TimeoutPaused && m_state != ManualConfirm; + && m_state != TimeoutPaused && m_state != ManualConfirm + && m_state != Terminating; +} + +bool ProductionService::stopRequested() const +{ + return m_stopRequested.load() + || (m_externalStopRequested + && m_externalStopRequested->load()); } void ProductionService::onDeviceStatusChanged(const DeviceStatus &status) @@ -1361,6 +1884,7 @@ void ProductionService::onDeviceStatusChanged(const DeviceStatus &status) || status.errorCode != m_deviceStatus.errorCode; m_deviceStatus = status; m_deviceStatusValid = true; + emit deviceStatusChanged(status); if (changed) { persistDeviceStatus(status); } @@ -1368,7 +1892,8 @@ void ProductionService::onDeviceStatusChanged(const DeviceStatus &status) void ProductionService::onCommunicationError(const QString &error) { - if (m_state == RecoveryChecking) { + emit deviceCommunicationError(error); + if (m_state == RecoveryChecking || m_state == Terminating) { m_lastError = error; return; } diff --git a/services/productionservice.h b/services/productionservice.h index d8914ca..75b1b67 100644 --- a/services/productionservice.h +++ b/services/productionservice.h @@ -7,6 +7,7 @@ #include #include +#include class QTimer; @@ -39,7 +40,8 @@ public: TimeoutPaused, RecoveryChecking, ManualConfirm, - Retrying + Retrying, + Terminating }; Q_ENUM(State) @@ -58,13 +60,19 @@ public: bool resume(QString *error = nullptr); bool stop(QString *error = nullptr); bool reset(QString *error = nullptr); + bool clearAlarm(QString *error = nullptr); bool recover(QString *error = nullptr); bool retry(QString *error = nullptr); bool markCurrentWorkpieceNg(QString *error = nullptr); bool restoreActiveRun(QString *error = nullptr); + void shutdown(const DeviceService::OperationCallback &callback); + void setExternalStopFlag(std::atomic_bool *flag); + void requestStopImmediate(); signals: void stateChanged(ProductionService::State state, const QString &name); + void deviceStatusChanged(const DeviceStatus &status); + void deviceCommunicationError(const QString &error); void currentWorkpieceChanged(int workpieceId, const QString &barcode); void currentWorkpieceSnapshotChanged(const Workpiece &workpiece); void currentPositionChanged(int trayNo, int slotNo); @@ -99,6 +107,11 @@ private: void tickProduction(); bool processProductionStep(State state, QString *error); bool recoverFromPlcStep(QString *error); + bool processProductionAction(DeviceService::ProductionAction action, + bool *completed, QString *error); + void cancelPendingProductionAction( + const DeviceService::OperationCallback &callback); + void tryDeferredActionCancel(); bool executeCurrentAction(DeviceService::ProductionAction action, const QString &nextProcessStep, State nextState, QString *error); @@ -118,14 +131,18 @@ private: bool isTimedState(State state) const; QString stateNameForState(State state) const; QString processStepForState(State state) const; + State stateForProcessStep(const QString &processStep) const; QString runStateForState(State state) const; State stateFromName(const QString &name) const; void persistAlarm(const QString &code, const QString &message); void persistDeviceStatus(const DeviceStatus &status); void fail(const QString &error); + void finishShutdown(bool success, const QString &error); bool isActive() const; + bool stopRequested() const; QTimer *m_timer; + DeviceService *m_deviceService; QElapsedTimer m_stateTimer; QElapsedTimer m_processTimer; QElapsedTimer m_heartbeatTimer; @@ -141,10 +158,28 @@ private: int m_currentTrayNo; int m_currentSlotNo; int m_frontRawResult; + bool m_actionPending; + bool m_actionStarting; + bool m_actionPollPending; + bool m_actionCompleted; + QString m_actionError; + bool m_actionCancelRequested; + DeviceService::OperationCallback m_deferredCancelCallback; + bool m_inspectionStatusPending; + bool m_inspectionStatusReady; + QString m_inspectionStatusError; + bool m_starting; + bool m_plcStarted; + bool m_tickRunning; + DeviceService::ProductionAction m_pendingAction; QString m_inspectionMode; QString m_frontResultState; QString m_currentProcessStep; QString m_lastError; + std::atomic_bool m_stopRequested; + std::atomic_bool *m_externalStopRequested; + bool m_shutdownRequested; + DeviceService::OperationCallback m_shutdownCallback; }; Q_DECLARE_METATYPE(ProductionService::State) diff --git a/services/productionworker.cpp b/services/productionworker.cpp index 64c9216..ce41dca 100644 --- a/services/productionworker.cpp +++ b/services/productionworker.cpp @@ -3,6 +3,7 @@ ProductionWorker::ProductionWorker(QObject *parent) : QObject(parent) , m_service(nullptr) + , m_stopRequested(false) { } @@ -13,8 +14,13 @@ void ProductionWorker::ensureService() } m_service = new ProductionService(this); + m_service->setExternalStopFlag(&m_stopRequested); connect(m_service, &ProductionService::stateChanged, this, &ProductionWorker::stateChanged); + connect(m_service, &ProductionService::deviceStatusChanged, + this, &ProductionWorker::deviceStatusChanged); + connect(m_service, &ProductionService::deviceCommunicationError, + this, &ProductionWorker::deviceCommunicationError); connect(m_service, &ProductionService::currentWorkpieceChanged, this, &ProductionWorker::currentWorkpieceChanged); connect(m_service, &ProductionService::currentWorkpieceSnapshotChanged, @@ -37,6 +43,11 @@ void ProductionWorker::ensureService() this, &ProductionWorker::recoveryCompleted); } +void ProductionWorker::requestStopImmediate() +{ + m_stopRequested.store(true); +} + void ProductionWorker::reportFailure(bool success, const QString &error) { if (!success && !error.isEmpty()) { @@ -79,6 +90,13 @@ void ProductionWorker::requestReset() reportFailure(m_service->reset(&error), error); } +void ProductionWorker::requestClearAlarm() +{ + ensureService(); + QString error; + reportFailure(m_service->clearAlarm(&error), error); +} + void ProductionWorker::requestRecover() { ensureService(); @@ -106,3 +124,16 @@ void ProductionWorker::requestRestore() QString error; reportFailure(m_service->restoreActiveRun(&error), error); } + +void ProductionWorker::requestShutdown() +{ + ensureService(); + m_service->shutdown( + [this](bool success, const QString &error) { + if (!success) { + reportFailure(false, error); + return; + } + emit shutdownReady(); + }); +} diff --git a/services/productionworker.h b/services/productionworker.h index d1d67d8..219e3e3 100644 --- a/services/productionworker.h +++ b/services/productionworker.h @@ -4,6 +4,7 @@ #include "productionservice.h" #include +#include class ProductionWorker : public QObject { @@ -11,6 +12,7 @@ class ProductionWorker : public QObject public: explicit ProductionWorker(QObject *parent = nullptr); + void requestStopImmediate(); public slots: void requestStart(int orderId); @@ -18,13 +20,17 @@ public slots: void requestResume(); void requestStop(); void requestReset(); + void requestClearAlarm(); void requestRecover(); void requestRetry(); void requestMarkNg(); void requestRestore(); + void requestShutdown(); signals: void stateChanged(ProductionService::State state, const QString &name); + void deviceStatusChanged(const DeviceStatus &status); + void deviceCommunicationError(const QString &error); void currentWorkpieceChanged(int workpieceId, const QString &barcode); void currentWorkpieceSnapshotChanged(const Workpiece &workpiece); void currentPositionChanged(int trayNo, int slotNo); @@ -35,12 +41,14 @@ signals: void timeoutWarning(const QString &state, int elapsedMs, int timeoutMs); void timeoutRecoveryRequired(const QString &state, const QString &message); void recoveryCompleted(const QString &mode); + void shutdownReady(); private: void ensureService(); void reportFailure(bool success, const QString &error); ProductionService *m_service; + std::atomic_bool m_stopRequested; }; #endif // PRODUCTIONWORKER_H diff --git a/ssp.pro.user b/ssp.pro.user index db5027c..cb5648e 100644 --- a/ssp.pro.user +++ b/ssp.pro.user @@ -1,6 +1,6 @@ - + EnvironmentId diff --git a/widget.cpp b/widget.cpp index 9000ec8..8ab9433 100644 --- a/widget.cpp +++ b/widget.cpp @@ -131,6 +131,10 @@ void Widget::setupMainArea(QVBoxLayout *rootLayout) connect(dashboardPage, &DashboardPage::currentStepChanged, this, [this](const QString &step) { currentStepLabel->setText("工序:" + step); }); + connect(dashboardPage, &DashboardPage::deviceStatusChanged, + devicePage, &DevicePage::updateStatus); + connect(dashboardPage, &DashboardPage::deviceCommunicationError, + devicePage, &DevicePage::handleCommunicationError); connect(dashboardPage, &DashboardPage::logRequested, this, &Widget::appendLog); connect(orderPage, &OrderPage::logRequested, this, &Widget::appendLog); connect(rackPage, &RackPage::logRequested, this, &Widget::appendLog);