#include "deviceservice.h" #include "../config/configmanager.h" #include "../modbus/modbustcpmanager.h" #include #include #include namespace { const int FeedbackPollIntervalMs = 50; } DeviceService &DeviceService::instance() { static DeviceService service; return service; } DeviceService::DeviceService(QObject *parent) : QObject(parent) , m_pollTimer(new QTimer(this)) { connect(m_pollTimer, &QTimer::timeout, this, &DeviceService::pollStatus); } void DeviceService::startPolling() { if (m_pollTimer->isActive()) { return; } const int interval = qMax(100, ModbusTcpManager::instance().config().pollIntervalMs); m_pollTimer->start(interval); pollStatus(); } void DeviceService::stopPolling() { m_pollTimer->stop(); } bool DeviceService::isPolling() const { return m_pollTimer->isActive(); } bool DeviceService::readStatus(DeviceStatus *status, QString *error) { if (!status) { if (error) { *error = "Device status pointer is null"; } return false; } if (ConfigManager::instance().simulationMode()) { *status = simulatedStatus(); return true; } QString configError; if (!ConfigManager::instance().validate(&configError)) { if (error) { *error = configError; } status->plcConnected = false; return false; } 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)); } if (!connectWithRetry(&lastError)) { continue; } if (readStatusOnce(status, &lastError)) { return true; } ModbusTcpManager::instance().disconnectDevice(); } status->plcConnected = false; if (error) { *error = lastError.isEmpty() ? "Failed to read PLC status" : lastError; } return false; } void DeviceService::pollStatus() { DeviceStatus status; QString error; if (readStatus(&status, &error)) { emit statusChanged(status); return; } status.plcConnected = false; emit statusChanged(status); if (!error.isEmpty()) { emit communicationError(error); } } DeviceStatus DeviceService::simulatedStatus() const { DeviceStatus status; status.plcConnected = true; status.plcReady = true; status.robotReady = true; status.safetyDoorClosed = true; status.emergencyStop = false; status.currentStep = 0; status.checkResult = 0; return status; } bool DeviceService::start(QString *error) { if (ConfigManager::instance().simulationMode()) { return true; } if (!ConfigManager::instance().productionEnabled()) { if (error) { *error = "Production control is disabled by configuration"; } return false; } const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; return executeCommand(addresses.startCommand, addresses.startFeedback, error); } bool DeviceService::pause(QString *error) { if (ConfigManager::instance().simulationMode()) { return true; } if (!ConfigManager::instance().productionEnabled()) { if (error) { *error = "Production control is disabled by configuration"; } return false; } const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; return executeCommand(addresses.pauseCommand, addresses.pauseFeedback, error); } bool DeviceService::reset(QString *error) { if (ConfigManager::instance().simulationMode()) { return true; } if (!ConfigManager::instance().productionEnabled()) { if (error) { *error = "Production control is disabled by configuration"; } return false; } const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; return executeCommand(addresses.resetCommand, addresses.resetFeedback, error); } bool DeviceService::clearAlarm(QString *error) { if (ConfigManager::instance().simulationMode()) { return true; } if (!ConfigManager::instance().productionEnabled()) { if (error) { *error = "Production control is disabled by configuration"; } return false; } const ModbusAddressMap &addresses = ModbusTcpManager::instance().config().addressMap; return executeCommand(addresses.clearAlarmCommand, addresses.clearAlarmFeedback, error); } bool DeviceService::connectWithRetry(QString *error) { 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 (modbus.connectDevice(&lastError)) { return true; } modbus.disconnectDevice(); } if (error) { *error = lastError.isEmpty() ? "Failed to connect to PLC" : lastError; } return false; } bool DeviceService::readStatusOnce(DeviceStatus *status, QString *error) { 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; } return true; } bool DeviceService::executeCommand(int commandAddress, int feedbackAddress, QString *error) { QString configError; if (!ConfigManager::instance().validate(&configError)) { if (error) { *error = configError; } return false; } 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; } QThread::msleep(qMax(1, config.commandPulseMs)); if (!modbus.writeCoil(commandAddress, false, &lastError)) { modbus.disconnectDevice(); continue; } if (waitForFeedback(feedbackAddress, &lastError)) { return true; } modbus.disconnectDevice(); } if (error) { *error = lastError.isEmpty() ? "PLC command failed" : lastError; } return false; } bool DeviceService::waitForFeedback(int address, QString *error) { ModbusTcpManager &modbus = ModbusTcpManager::instance(); const int timeoutMs = qMax(1, modbus.config().feedbackTimeoutMs); QElapsedTimer timer; timer.start(); while (timer.elapsed() < timeoutMs) { 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; }