#include "deviceservice.h" #include "../config/configmanager.h" #include "../modbus/modbustcpmanager.h" #include #include namespace { bool actionAddresses(DeviceService::ProductionAction action, const ModbusAddressMap &addresses, const VisionConfig &vision, int *commandAddress, int *feedbackAddress) { if (!commandAddress || !feedbackAddress) { return false; } switch (action) { case DeviceService::PhotoMoveAction: *commandAddress = vision.photoMoveCoil; *feedbackAddress = vision.photoMoveCoilFeedback; return true; case DeviceService::RackPick: *commandAddress = addresses.rackPickCommand; *feedbackAddress = addresses.rackPickFeedback; return true; case DeviceService::FrontLoad: *commandAddress = addresses.frontLoadCommand; *feedbackAddress = addresses.frontLoadFeedback; return true; case DeviceService::Inspect: *commandAddress = addresses.inspectionCommand; *feedbackAddress = addresses.inspectionFeedback; return true; case DeviceService::FrontUnload: *commandAddress = addresses.frontUnloadCommand; *feedbackAddress = addresses.frontUnloadFeedback; return true; case DeviceService::Flip: *commandAddress = addresses.flipCommand; *feedbackAddress = addresses.flipFeedback; return true; case DeviceService::ReverseFlip: *commandAddress = addresses.flipCommand2; *feedbackAddress = addresses.flipFeedback2; return true; case DeviceService::BackLoad: *commandAddress = addresses.backLoadCommand; *feedbackAddress = addresses.backLoadFeedback; return true; case DeviceService::BackUnload: *commandAddress = addresses.backUnloadCommand; *feedbackAddress = addresses.backUnloadFeedback; return true; case DeviceService::RackPlace: *commandAddress = addresses.rackPlaceCommand; *feedbackAddress = addresses.rackPlaceFeedback; return true; } return false; } } 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) { 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, m_modbus->config().pollIntervalMs); m_pollTimer->start(interval); pollStatus(); } DeviceService::~DeviceService() { m_pollTimer->stop(); ++m_resetGeneration; m_terminationActive = true; m_terminationCallback = OperationCallback(); ++m_visionGeneration; // Modbus abort invokes pending callbacks; keep our state alive until they drain. m_modbus->abortAll("Device service is shutting down"); delete m_modbus; m_modbus = nullptr; } void DeviceService::stopPolling() { m_pollTimer->stop(); } bool DeviceService::isPolling() const { return m_pollTimer->isActive(); } void DeviceService::requestStatus(const StatusCallback &callback) { if (m_terminationActive) { if (callback) { DeviceStatus status; callback(false, status, "PLC termination is in progress"); } return; } if (ConfigManager::instance().simulationMode()) { const DeviceStatus status = simulatedStatus(); emit statusChanged(status); if (callback) { callback(true, status, QString()); } return; } if (m_statusRequestPending) { if (callback) { m_statusCallbacks.append(callback); } return; } m_statusRequestPending = true; m_statusCallbacks.clear(); if (callback) { m_statusCallbacks.append(callback); } DeviceStatus status; status.plcConnected = true; readStatusStep(1, status); } void DeviceService::finishStatusRequest(bool success, const DeviceStatus &status, const QString &error) { DeviceStatus finalStatus = status; finalStatus.statusValid = success; finalStatus.plcConnected = success; m_statusRequestPending = false; const QList callbacks = m_statusCallbacks; m_statusCallbacks.clear(); emit statusChanged(finalStatus); if (!success && !error.isEmpty()) { emit communicationError(error); } for (const StatusCallback &callback : callbacks) { if (callback) { callback(success, finalStatus, error); } } } void DeviceService::readStatusStep(int index, const DeviceStatus &status) { const bool useErrorCode = ConfigManager::instance().productionConfig().usePlcErrorCode; if (index >= (useErrorCode ? 19 : 18)) { finishStatusRequest(true, status, QString()); return; } 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 1: nextStatus.plcRunning = value != 0; break; case 2: nextStatus.safetyDoorClosed = value != 0; break; case 3: nextStatus.safetyDoor1Closed = value != 0; break; case 4: nextStatus.safetyDoor2Closed = value != 0; break; case 5: nextStatus.safetyDoor3Closed = value != 0; break; case 6: nextStatus.emergencyStop = value != 0; break; case 7: nextStatus.robotIdle = value != 0; break; case 8: nextStatus.robotRunning = value != 0; break; case 9: nextStatus.robotAlarm = value != 0; break; case 10: nextStatus.plcReady = value != 0; break; case 11: nextStatus.inspectionMachineReady = value != 0; break; case 12: nextStatus.visionReady = value != 0; break; case 13: nextStatus.robotControlCabinetReady = value != 0; break; case 14: nextStatus.mainControlCabinetReady = value != 0; break; case 15: nextStatus.activeAlarm = value != 0; break; case 16: nextStatus.currentStep = value; break; case 17: nextStatus.checkResult = value; break; case 18: nextStatus.errorCode = value; break; default: break; } readStatusStep(index + 1, nextStatus); }; const ModbusAddressMap &addresses = m_modbus->config().addressMap; switch (index) { case 1: m_modbus->readCoil(addresses.plcRunning, [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.safetyDoor1Closed, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 4: m_modbus->readCoil(addresses.safetyDoor2Closed, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 5: m_modbus->readCoil(addresses.safetyDoor3Closed, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 6: m_modbus->readCoil(addresses.emergencyStop, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 7: m_modbus->readCoil(addresses.robotIdle, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 8: m_modbus->readCoil(addresses.robotRunning, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 9: m_modbus->readCoil(addresses.robotAlarm, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 10: m_modbus->readCoil(addresses.plcReady, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 11: m_modbus->readCoil(addresses.inspectionMachineReady, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 12: m_modbus->readCoil(addresses.visionReady, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 13: m_modbus->readCoil(addresses.robotControlCabinetReady, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 14: m_modbus->readCoil(addresses.mainControlCabinetReady, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 15: m_modbus->readCoil(addresses.activeAlarm, [next](bool ok, bool value, const QString &error) { next(ok, value ? 1 : 0, error); }); break; case 16: m_modbus->readHoldingRegister(addresses.currentStep, next); break; case 17: m_modbus->readHoldingRegister(addresses.checkResult, next); break; case 18: m_modbus->readHoldingRegister(addresses.errorCode, next); break; } } void DeviceService::pollStatus() { if (m_terminationActive || m_statusRequestPending || m_controlRequestPending || m_productionActionBusy) { return; } requestStatus([this](bool success, const DeviceStatus &, const QString &error) { if (!success && !error.isEmpty()) { emit communicationError(error); } }); } DeviceStatus DeviceService::simulatedStatus() const { DeviceStatus status; status.statusValid = true; status.plcConnected = true; status.plcReady = true; status.plcRunning = false; status.robotIdle = true; status.robotRunning = false; status.robotAlarm = false; status.safetyDoorClosed = true; status.emergencyStop = false; status.inspectionMachineReady = true; status.visionReady = true; status.robotControlCabinetReady = true; status.mainControlCabinetReady = true; status.safetyDoor1Closed = true; status.safetyDoor2Closed = true; status.safetyDoor3Closed = true; status.activeAlarm = false; status.currentStep = 0; status.checkResult = 0; return status; } void DeviceService::clearAlarm(const OperationCallback &callback) { if (m_terminationActive) { if (callback) { callback(false, "PLC termination is in progress"); } return; } if (ConfigManager::instance().simulationMode()) { if (callback) { callback(true, QString()); } return; } if (!ConfigManager::instance().productionEnabled()) { if (callback) { callback(false, "Production control is disabled by configuration"); } return; } if (m_controlRequestPending || m_productionActionBusy) { if (callback) { callback(false, "Another PLC operation is already active"); } return; } m_controlRequestPending = true; m_modbus->writeCoil( m_modbus->config().addressMap.clearAlarmCommand, true, [this, callback](bool success, const QString &error) { m_controlRequestPending = false; if (callback) { callback(success, error); } }); } void DeviceService::setInspectionMode(const QString &mode, const OperationCallback &callback) { if (mode != "BEFORE_PLATING" && mode != "AFTER_PLATING") { if (callback) { callback(false, "Inspection mode must be BEFORE_PLATING or AFTER_PLATING"); } return; } if (m_terminationActive) { if (callback) { callback(false, "PLC termination is in progress"); } return; } if (ConfigManager::instance().simulationMode()) { if (callback) { callback(true, QString()); } return; } if (!ConfigManager::instance().productionEnabled()) { if (callback) { callback(false, "Production control is disabled by configuration"); } 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"; m_modbus->writeCoil( m_modbus->config().addressMap.inspectionMode, afterPlating, [this, callback](bool success, const QString &error) { m_controlRequestPending = false; if (callback) { callback(success, 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_resetGeneration; m_terminationCallback = callback; m_terminationSignals.clear(); m_terminationSignalIndex = 0; m_pollTimer->stop(); const VisionConfig vision = ConfigManager::instance().visionConfig(); const ModbusAddressMap &addresses = m_modbus->config().addressMap; const QList> currentSignals = QList>() << qMakePair(m_productionCommandAddress, m_productionFeedbackAddress) << qMakePair(vision.photoMoveCoil, vision.photoMoveCoilFeedback) << qMakePair(addresses.rackPickCommand, addresses.rackPickFeedback); 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::resetProductionSignals(const OperationCallback &callback) { if (m_terminationActive) { if (callback) callback(false, "PLC termination or reset is already in progress"); return; } const bool simulation = ConfigManager::instance().simulationMode(); if (!simulation && !ConfigManager::instance().productionEnabled()) { if (callback) callback(false, "Production control is disabled by configuration"); return; } const ModbusAddressMap addresses = m_modbus->config().addressMap; const VisionConfig vision = ConfigManager::instance().visionConfig(); if (addresses.clearAlarmCommand < 0 || addresses.clearAlarmCommand > 65535) { if (callback) callback(false, "Invalid clear-alarm coil address"); return; } QList resetSignals; const ProductionAction actions[] = {PhotoMoveAction, RackPick, FrontLoad, Inspect, FrontUnload, Flip, ReverseFlip, BackLoad, BackUnload, RackPlace}; for (const ProductionAction action : actions) { int command = -1; int feedback = -1; actionAddresses(action, addresses, vision, &command, &feedback); for (const int address : {command, feedback}) { if (!resetSignals.contains(address)) resetSignals.append(address); } } if (!resetSignals.contains(vision.comparisonPickCoil)) resetSignals.append(vision.comparisonPickCoil); for (const int address : resetSignals) { if (address < 0 || address > 65535 || address == addresses.clearAlarmCommand) { if (callback) callback(false, QString("Invalid production reset coil M%1").arg(address)); return; } } m_terminationActive = true; m_terminationCallback = callback; const quint64 generation = ++m_resetGeneration; ++m_visionGeneration; m_pollTimer->stop(); m_resetSignals = resetSignals; m_resetSignalIndex = 0; m_modbus->abortAll("PLC production reset requested"); m_statusRequestPending = false; m_controlRequestPending = false; m_productionActionActive = false; m_productionActionBusy = false; if (simulation) { finishTermination(true, QString()); return; } m_modbus->writeCoil(addresses.clearAlarmCommand, true, [this, generation, addresses](bool success, const QString &error) { if (generation != m_resetGeneration || !m_terminationActive) return; if (!success) { finishTermination(false, QString("Clear alarm M%1 failed: %2") .arg(addresses.clearAlarmCommand).arg(error)); return; } clearNextResetSignal(generation); }); } void DeviceService::clearNextResetSignal(quint64 generation) { if (generation != m_resetGeneration || !m_terminationActive) return; if (m_resetSignalIndex >= m_resetSignals.size()) { finishTermination(true, QString()); return; } const int address = m_resetSignals.at(m_resetSignalIndex++); m_modbus->writeCoil(address, false, [this, generation, address](bool written, const QString &error) { if (generation != m_resetGeneration || !m_terminationActive) return; if (!written) { finishTermination(false, QString("Reset M%1 failed: %2").arg(address).arg(error)); return; } m_modbus->readCoil(address, [this, generation, address](bool read, bool value, const QString &readError) { if (generation != m_resetGeneration || !m_terminationActive) return; if (!read || value) { finishTermination(false, QString("Reset M%1 not confirmed: %2") .arg(address).arg(read ? "coil remains set" : readError)); return; } clearNextResetSignal(generation); }); }); } void DeviceService::clearNextTerminationSignal() { if (!m_terminationActive) { return; } if (m_terminationSignalIndex >= m_terminationSignals.size()) { const int address = ConfigManager::instance().visionConfig().comparisonPickCoil; m_modbus->writeCoil(address, false, [this, address](bool written, const QString &error) { if (!written) { finishTermination(false, error); return; } m_modbus->readCoil(address, [this](bool read, bool value, const QString &readError) { finishTermination(read && !value, !read ? readError : value ? "M852 未复位,不能完成终止" : QString()); }); }); 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_resetGeneration; m_terminationCallback = OperationCallback(); m_terminationActive = false; m_terminationSignals.clear(); m_terminationSignalIndex = 0; m_resetSignals.clear(); m_resetSignalIndex = 0; m_controlRequestPending = false; m_productionActionActive = false; m_productionActionBusy = false; if (success) { m_productionCommandAddress = -1; m_productionFeedbackAddress = -1; } if (callback) { callback(success, error); } } void DeviceService::beginProductionAction( ProductionAction action, int trayNo, int slotNo, const VisionWriteCallback &callback, const std::function &beforeSend) { if (m_terminationActive) { if (callback) { callback(VisionWriteOutcome::NotSent, "PLC termination is in progress"); } return; } if (ConfigManager::instance().simulationMode()) { const bool permitted = !beforeSend || beforeSend(); if (callback) { callback(permitted ? VisionWriteOutcome::Confirmed : VisionWriteOutcome::NotSent, permitted ? QString() : "Production action invalidated before transmission"); } return; } if (!ConfigManager::instance().productionEnabled()) { if (callback) { callback(VisionWriteOutcome::NotSent, "Production control is disabled by configuration"); } return; } if (m_productionActionActive || m_productionActionBusy) { if (callback) { callback(VisionWriteOutcome::NotSent, "A PLC production action is already active"); } return; } if (trayNo <= 0 || trayNo > 65535 || slotNo < 1 || slotNo > 49) { if (callback) { callback(VisionWriteOutcome::NotSent, "PLC tray or slot position is invalid"); } return; } const ModbusAddressMap &addresses = m_modbus->config().addressMap; const VisionConfig vision = ConfigManager::instance().visionConfig(); if (!actionAddresses(action, addresses, vision, &m_productionCommandAddress, &m_productionFeedbackAddress)) { if (callback) { callback(VisionWriteOutcome::NotSent, "Unknown PLC production action"); } return; } m_productionActionBusy = true; auto sendCommand = [this, callback](VisionWriteOutcome outcome, const QString &error) { // An unacknowledged command may already be running. Do not // permit another action until it has been reconciled. m_productionActionActive = outcome != VisionWriteOutcome::NotSent; m_productionActionBusy = false; if (callback) { callback(outcome, error); } }; auto writeCommand = [this, sendCommand, beforeSend](bool success, const QString &error) { if (!success) { sendCommand(VisionWriteOutcome::NotSent, error); return; } // Action commands must never use the legacy automatic retry // path, even when no persistence hook is supplied. m_modbus->writeVisionCoil(m_productionCommandAddress, true, sendCommand, beforeSend); }; if (action == PhotoMoveAction || 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), [this, addresses, slotNo, writeCommand]( bool slotSuccess, const QString &slotError) { if (!slotSuccess) { writeCommand(false, slotError); return; } m_modbus->writeHoldingRegister( addresses.slotRowNumber, static_cast((slotNo - 1) / 7 + 1), [this, addresses, slotNo, writeCommand]( bool rowSuccess, const QString &rowError) { if (!rowSuccess) { writeCommand(false, rowError); return; } m_modbus->writeHoldingRegister( addresses.slotColumNumber, static_cast((slotNo - 1) % 7 + 1), writeCommand); }); }); }); return; } writeCommand(true, QString()); } void DeviceService::inspectProductionAction( ProductionAction action, const ActionStatusCallback &callback) { ProductionActionStatus emptyStatus; if (m_terminationActive) { if (callback) callback(false, emptyStatus, "PLC termination is in progress"); return; } if (ConfigManager::instance().simulationMode()) { if (callback) callback(true, emptyStatus, QString()); return; } int commandAddress = -1; int feedbackAddress = -1; if (!actionAddresses(action, m_modbus->config().addressMap, ConfigManager::instance().visionConfig(), &commandAddress, &feedbackAddress)) { if (callback) callback(false, emptyStatus, "Unknown PLC production action"); return; } m_modbus->readCoil( commandAddress, [this, feedbackAddress, callback](bool commandRead, bool command, const QString &commandError) { if (!commandRead) { if (callback) callback(false, ProductionActionStatus(), commandError); return; } m_modbus->readCoil( feedbackAddress, [callback, command](bool feedbackRead, bool feedback, const QString &feedbackError) { ProductionActionStatus status; status.command = command; status.feedback = feedback; if (callback) callback(feedbackRead, status, feedbackError); }); }); } void DeviceService::adoptProductionAction(ProductionAction action) { int commandAddress = -1; int feedbackAddress = -1; if (m_productionActionBusy || !actionAddresses(action, m_modbus->config().addressMap, ConfigManager::instance().visionConfig(), &commandAddress, &feedbackAddress)) { return; } m_productionCommandAddress = commandAddress; m_productionFeedbackAddress = feedbackAddress; m_productionActionActive = true; } void DeviceService::pollProductionAction( const ActionCallback &callback, const std::function &beforeClear) { if (m_terminationActive) { if (callback) { callback(false, false, "PLC termination is in progress"); } return; } if (ConfigManager::instance().simulationMode()) { finishProductionAction([callback](bool success, const QString &error) { if (callback) callback(success, success, error); }, beforeClear); 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; } m_productionActionBusy = true; m_modbus->readCoil( m_productionFeedbackAddress, [this, callback, beforeClear](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; } QString checkpointError; const bool saved = beforeClear && beforeClear(&checkpointError); m_productionActionBusy = false; if (!saved) { if (!beforeClear) checkpointError = "Action completion checkpoint hook is missing"; // An empty error explicitly defers completion while the // caller gathers asynchronous inspection data. if (callback) callback(checkpointError.isEmpty(), false, checkpointError); return; } finishProductionAction( [callback](bool cleared, const QString &clearError) { if (callback) callback(cleared, cleared, clearError); }, [](QString *) { return true; }); }); } void DeviceService::finishProductionAction( const OperationCallback &callback, const std::function &beforeClear) { if (m_terminationActive || m_productionActionBusy) { if (callback) callback(false, "PLC production action is busy or terminating"); return; } const bool simulation = ConfigManager::instance().simulationMode(); if (!simulation && !m_productionActionActive) { if (callback) callback(false, "No PLC production action is active"); return; } m_productionActionBusy = true; QString checkpointError; if (!beforeClear || !beforeClear(&checkpointError)) { m_productionActionBusy = false; if (callback) callback(false, checkpointError.isEmpty() ? "Action completion checkpoint was not saved" : checkpointError); return; } auto finish = [this, callback](bool success, const QString &error) { m_productionActionBusy = false; if (success) { m_productionActionActive = false; m_productionCommandAddress = -1; m_productionFeedbackAddress = -1; } if (callback) callback(success, error); }; if (simulation) { finish(true, QString()); return; } clearActionSignals(finish); } void DeviceService::cancelProductionAction(const OperationCallback &callback) { 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; } 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); } }); } void DeviceService::clearActionSignals(const OperationCallback &callback) { if (m_productionCommandAddress < 0 || m_productionFeedbackAddress < 0) { if (callback) { callback(false, "PLC production action addresses are invalid"); } return; } clearSignals(m_productionCommandAddress, m_productionFeedbackAddress, callback); } void DeviceService::clearSignals(int commandAddress, int feedbackAddress, const OperationCallback &callback) { m_modbus->writeCoil( commandAddress, false, [this, feedbackAddress, callback](bool commandCleared, const QString &commandError) { if (!commandCleared) { if (callback) callback(false, commandError); return; } m_modbus->writeCoil( feedbackAddress, false, [callback]( bool feedbackCleared, const QString &feedbackError) { if (callback) { callback(feedbackCleared, feedbackError); } }); }); } bool DeviceService::productionActionActive() const { return m_productionActionActive; } bool DeviceService::productionActionBusy() const { return m_productionActionBusy || m_modbus->isBusy(); } bool DeviceService::checkVisionAccess(QString *error) const { if (m_terminationActive || ConfigManager::instance().simulationMode() || !ConfigManager::instance().productionEnabled()) { if (error) *error = "Vision PLC access is disabled during termination or simulation"; return false; } if (m_modbus->config().serverAddress == 0) { if (error) *error = "Vision PLC writes require an addressed response, not broadcast"; return false; } return ConfigManager::instance().visionConfig().isValid(error); } void DeviceService::moveToPhotoPosition(int trayNo, int slotNo, const VisionWriteCallback &callback, const std::function &beforeSend) { QString error; if (!checkVisionAccess(&error) || trayNo < 1 || trayNo > 65535 || slotNo < 1 || slotNo > 49) { if (callback) callback(VisionWriteOutcome::NotSent, error.isEmpty() ? "Invalid photo-position tray/slot" : error); return; } const ModbusAddressMap addresses = m_modbus->config().addressMap; m_modbus->writeVisionHoldingRegister(addresses.trayNumber, quint16(trayNo), [this, addresses, slotNo, callback, beforeSend](VisionWriteOutcome outcome, const QString &error) { if (outcome != VisionWriteOutcome::Confirmed) { if (callback) callback(outcome, error); return; } m_modbus->writeVisionHoldingRegister(addresses.slotNumber, quint16(slotNo), [this, addresses, slotNo, callback, beforeSend](VisionWriteOutcome outcome, const QString &error) { if (outcome != VisionWriteOutcome::Confirmed) { if (callback) callback(outcome, error); return; } m_modbus->writeVisionHoldingRegister(addresses.slotRowNumber, quint16((slotNo - 1) / 7 + 1), [this, addresses, slotNo, callback, beforeSend](VisionWriteOutcome outcome, const QString &error) { if (outcome != VisionWriteOutcome::Confirmed) { if (callback) callback(outcome, error); return; } m_modbus->writeVisionHoldingRegister(addresses.slotColumNumber, quint16((slotNo - 1) % 7 + 1), [this, callback, beforeSend](VisionWriteOutcome outcome, const QString &error) { if (outcome != VisionWriteOutcome::Confirmed) { if (callback) callback(outcome, error); return; } writeVisionSignal(PhotoMove, true, callback, beforeSend); }, beforeSend); }, beforeSend); }, beforeSend); }, beforeSend); } void DeviceService::readRobotPhotoPose(const PoseCallback &callback) { QString error; if (!checkVisionAccess(&error)) { if (callback) callback(false, RobotPose(), error); return; } const VisionConfig config = ConfigManager::instance().visionConfig(); const quint64 generation = m_visionGeneration; if (!m_modbus->readRReals(config.photoPoseR, 6, [this, callback, generation](bool success, const QVector &values, const QString &text) { RobotPose pose; pose.xyzabc = values; if (callback) { callback(success && generation == m_visionGeneration && pose.isValid(), pose, generation == m_visionGeneration ? text : "Vision pose read canceled"); } }, config.lowWordFirst)) { if (callback) callback(false, RobotPose(), "Invalid R40 read request"); } } void DeviceService::writeRobotGraspPose(const RobotPose &pose, const VisionWriteCallback &callback, const std::function &beforeSend) { QString error; if (!checkVisionAccess(&error) || !pose.isValid()) { if (callback) callback(VisionWriteOutcome::NotSent, error.isEmpty() ? "Invalid robot grasp pose" : error); return; } const VisionConfig config = ConfigManager::instance().visionConfig(); if (!m_modbus->writeRReals(config.graspPoseR, pose.xyzabc, callback, config.lowWordFirst, beforeSend)) { if (callback) callback(VisionWriteOutcome::NotSent, "Invalid or overflowing R60 REAL request"); return; } for (int axis = 0; axis < pose.xyzabc.size(); ++axis) { const double rounded = double(float(pose.xyzabc.at(axis))); if (rounded != pose.xyzabc.at(axis)) { qInfo().nospace() << "Vision R60 axis " << axis << " REAL rounding: " << QString::number(pose.xyzabc.at(axis), 'g', 17) << " -> " << QString::number(rounded, 'g', 17); } } } void DeviceService::readVisionHandshake(const HandshakeCallback &callback) { QString error; if (!checkVisionAccess(&error)) { if (callback) callback(false, VisionHandshake(), error); return; } const VisionConfig config = ConfigManager::instance().visionConfig(); if (config.photoMoveCoilFeedback == config.photoMoveCoil + 1 && config.comparisonPickCoil == config.photoMoveCoil + 2) { const quint64 generation = m_visionGeneration; m_modbus->readCoils(config.photoMoveCoil, 3, [this, callback, generation](bool success, const QVector &values, const QString &text) { VisionHandshake state; if (success && values.size() == 3 && generation == m_visionGeneration) { state.photoMove = values.at(0); state.photoMoveFeedback = values.at(1); state.comparisonPick = values.at(2); if (callback) callback(true, state, QString()); } else if (callback) { callback(false, state, text.isEmpty() ? "Vision handshake read canceled or incomplete" : text); } }, true); return; } readVisionHandshakeStep(0, VisionHandshake(), m_visionGeneration, callback); } void DeviceService::readVisionHandshakeStep(int index, const VisionHandshake &state, quint64 generation, const HandshakeCallback &callback) { if (generation != m_visionGeneration) { if (callback) callback(false, VisionHandshake(), "Vision handshake read canceled"); return; } if (index == 3) { if (callback) callback(true, state, QString()); return; } const VisionConfig config = ConfigManager::instance().visionConfig(); const int addresses[] = {config.photoMoveCoil, config.photoMoveCoilFeedback, config.comparisonPickCoil}; m_modbus->readVisionCoil(addresses[index], [this, index, state, generation, callback](bool success, bool value, const QString &error) { if (!success) { if (callback) callback(false, VisionHandshake(), error); return; } VisionHandshake next = state; switch (index) { case 0: next.photoMove = value; break; case 1: next.photoMoveFeedback = value; break; case 2: next.comparisonPick = value; break; } readVisionHandshakeStep(index + 1, next, generation, callback); }); } void DeviceService::writeVisionSignal(VisionSignal signal, bool value, const VisionWriteCallback &callback, const std::function &beforeSend) { QString error; if (!checkVisionAccess(&error)) { if (callback) callback(VisionWriteOutcome::NotSent, error); return; } const VisionConfig config = ConfigManager::instance().visionConfig(); int address = -1; switch (signal) { case PhotoMove: address = config.photoMoveCoil; break; case PhotoMoveFeedback: if (!value) address = config.photoMoveCoilFeedback; // Only PLC may publish arrival. break; case ComparisonPick: address = config.comparisonPickCoil; break; default: break; } if (address < 0) { if (callback) callback(VisionWriteOutcome::NotSent, "Unsupported photo-position output"); return; } m_modbus->writeVisionCoil(address, value, callback, beforeSend); } void DeviceService::cancelVisionRequests(const QString &reason) { ++m_visionGeneration; m_modbus->cancelVisionRequests(reason); }