Files
ssp/services/deviceservice.cpp
T
lidg a8b2b31ce7 fix(dashboard): 显示问题修改
-PLC-未采集、机器人-未采集、安全回路-未采集 问题修改
-生成工件,成功后添加弹出提示生成成功
2026-11-09 17:25:14 +08:00

1210 lines
43 KiB
C++

#include "deviceservice.h"
#include "../config/configmanager.h"
#include "../modbus/modbustcpmanager.h"
#include <QTimer>
#include <QDebug>
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<StatusCallback> 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<QPair<int, int>> currentSignals = QList<QPair<int, int>>()
<< qMakePair(m_productionCommandAddress,
m_productionFeedbackAddress)
<< qMakePair(vision.photoMoveCoil, vision.photoMoveCoilFeedback)
<< qMakePair(addresses.rackPickCommand, addresses.rackPickFeedback);
for (const QPair<int, int> &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<int> 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<int, int> 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<bool()> &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<quint16>(trayNo),
[this, addresses, slotNo, writeCommand](
bool traySuccess, const QString &trayError) {
if (!traySuccess) {
writeCommand(false, trayError);
return;
}
m_modbus->writeHoldingRegister(
addresses.slotNumber,
static_cast<quint16>(slotNo),
[this, addresses, slotNo, writeCommand](
bool slotSuccess, const QString &slotError) {
if (!slotSuccess) {
writeCommand(false, slotError);
return;
}
m_modbus->writeHoldingRegister(
addresses.slotRowNumber,
static_cast<quint16>((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<quint16>((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<bool(QString *)> &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<bool(QString *)> &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<bool()> &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<double> &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<bool()> &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<bool> &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<bool()> &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);
}