package com.mes.interaction.workstation.scanner.handler;
|
|
import com.mes.device.entity.DeviceConfig;
|
import com.mes.device.entity.GlassInfo;
|
import com.mes.device.service.DevicePlcOperationService;
|
import com.mes.device.service.GlassInfoService;
|
import com.mes.device.vo.DevicePlcVO;
|
import com.mes.interaction.workstation.base.WorkstationBaseHandler;
|
import com.mes.interaction.workstation.config.WorkstationLogicConfig;
|
import com.mes.s7.enhanced.EnhancedS7Serializer;
|
import com.mes.s7.provider.S7SerializerProvider;
|
import com.mes.service.PlcDynamicDataService;
|
import com.mes.task.model.TaskExecutionContext;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Component;
|
import org.springframework.util.StringUtils;
|
|
import java.time.LocalDateTime;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* 卧转立扫码设备逻辑处理器
|
* 负责从MES写区读取玻璃尺寸，并落库 glass_info
|
*/
|
@Slf4j
|
@Component
|
public class HorizontalScannerLogicHandler extends WorkstationBaseHandler {
|
|
private static final List<String> MES_FIELDS = Arrays.asList("mesSend", "mesGlassId", "mesWidth", "mesHeight", "workLine");
|
|
private final PlcDynamicDataService plcDynamicDataService;
|
private final GlassInfoService glassInfoService;
|
private final S7SerializerProvider s7SerializerProvider;
|
|
public HorizontalScannerLogicHandler(DevicePlcOperationService devicePlcOperationService,
|
PlcDynamicDataService plcDynamicDataService,
|
GlassInfoService glassInfoService,
|
S7SerializerProvider s7SerializerProvider) {
|
super(devicePlcOperationService);
|
this.plcDynamicDataService = plcDynamicDataService;
|
this.glassInfoService = glassInfoService;
|
this.s7SerializerProvider = s7SerializerProvider;
|
}
|
|
@Override
|
public String getDeviceType() {
|
return DeviceConfig.DeviceType.WORKSTATION_SCANNER;
|
}
|
|
@Override
|
protected DevicePlcVO.OperationResult doExecute(DeviceConfig deviceConfig,
|
String operation,
|
Map<String, Object> params,
|
Map<String, Object> logicParams) {
|
EnhancedS7Serializer serializer = s7SerializerProvider.getSerializer(deviceConfig);
|
if (serializer == null) {
|
return buildResult(deviceConfig, operation, false, "获取PLC序列化器失败", null);
|
}
|
|
if ("clearPlc".equalsIgnoreCase(operation) || "reset".equalsIgnoreCase(operation)) {
|
return clearPlc(deviceConfig, serializer);
|
}
|
|
WorkstationLogicConfig config = parseWorkstationConfig(logicParams);
|
return executeScan(deviceConfig, config, serializer, params);
|
}
|
|
private DevicePlcVO.OperationResult executeScan(DeviceConfig deviceConfig,
|
WorkstationLogicConfig config,
|
EnhancedS7Serializer serializer,
|
Map<String, Object> params) {
|
try {
|
// 从参数中获取玻璃ID（定时器每次只处理一个）
|
String inputGlassId = null;
|
if (params != null) {
|
Object glassIdObj = params.get("glassId");
|
if (glassIdObj != null) {
|
inputGlassId = String.valueOf(glassIdObj).trim();
|
}
|
}
|
|
// 执行单次扫描（定时器会循环调用此方法）
|
return executeSingleScan(deviceConfig, config, serializer, inputGlassId, params);
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
log.warn("卧转立扫码等待MES数据被中断, deviceId={}", deviceConfig.getId(), e);
|
return buildResult(deviceConfig, "scanOnce", false, "等待MES数据被中断", null);
|
} catch (Exception e) {
|
log.error("卧转立扫码处理异常, deviceId={}", deviceConfig.getId(), e);
|
return buildResult(deviceConfig, "scanOnce", false, "处理异常: " + e.getMessage(), null);
|
}
|
}
|
|
/**
|
* 执行单次扫描
|
*/
|
private DevicePlcVO.OperationResult executeSingleScan(DeviceConfig deviceConfig,
|
WorkstationLogicConfig config,
|
EnhancedS7Serializer serializer,
|
String inputGlassId,
|
Map<String, Object> params) throws InterruptedException {
|
// 1. 写入plcRequest=1和plcGlassId（如果提供了玻璃ID）
|
triggerScanRequest(deviceConfig, serializer, inputGlassId);
|
|
// 2. 等待MES回写mesSend=1以及玻璃信息
|
Map<String, Object> mesData = waitForMesData(deviceConfig, serializer, config);
|
if (mesData == null || mesData.isEmpty()) {
|
log.error("等待MES写入玻璃信息超时: deviceId={}, timeout={}ms",
|
deviceConfig.getId(), config.getScanIntervalMs());
|
return buildResult(deviceConfig, "scanOnce", false,
|
String.format("等待MES写入玻璃信息超时(%dms)", config.getScanIntervalMs()), null);
|
}
|
|
// 3. 读取MES回写的玻璃信息
|
String glassId = parseString(mesData.get("mesGlassId"));
|
if (!StringUtils.hasText(glassId)) {
|
return buildResult(deviceConfig, "scanOnce", false, "MES写区未提供玻璃ID", null);
|
}
|
// 读取MES尺寸数据：mesWidth=表宽，mesHeight=长
|
Integer rawWidth = parseInteger(mesData.get("mesWidth"));
|
Integer rawHeight = parseInteger(mesData.get("mesHeight"));
|
Integer workLine = parseInteger(mesData.get("workLine"));
|
|
// 4. 清空plcRequest和plcGlassId（只清除PLC字段）
|
clearPlcRequestFields(deviceConfig, serializer);
|
|
|
// 5. 保存玻璃信息到数据库
|
GlassInfo glassInfo = buildGlassInfo(glassId, rawWidth, rawHeight, workLine);
|
boolean saved = glassInfoService.saveOrUpdateGlassInfo(glassInfo);
|
if (!saved) {
|
return buildResult(deviceConfig, "scanOnce", false, "保存玻璃信息失败: " + glassId, null);
|
}
|
|
// 6. 将扫描到的玻璃ID保存到共享数据中（供大车设备定时器读取）
|
saveScannedGlassId(params, glassId);
|
|
String msg = String.format("玻璃[%s] 尺寸[表宽:%s x 长:%s] 已接收并入库，workLine=%s",
|
glassId,
|
rawWidth != null ? rawWidth + "mm" : "-",
|
rawHeight != null ? rawHeight + "mm" : "-",
|
workLine != null ? workLine : "-");
|
Map<String, Object> resultData = new HashMap<>();
|
resultData.put("glassIds", Collections.singletonList(glassId));
|
if (workLine != null) {
|
resultData.put("workLine", workLine);
|
}
|
return buildResult(deviceConfig, "scanOnce", true, msg, resultData);
|
}
|
|
/**
|
* 设置暂停标志（供大车设备调用）
|
*/
|
public static void setPauseFlag(TaskExecutionContext context, boolean pause) {
|
if (context != null) {
|
context.getSharedData().put("scannerPause", pause);
|
}
|
}
|
|
/**
|
* 保存扫描到的玻璃ID到共享数据中
|
*/
|
@SuppressWarnings("unchecked")
|
private void saveScannedGlassId(Map<String, Object> params, String glassId) {
|
if (params == null || !StringUtils.hasText(glassId)) {
|
return;
|
}
|
|
Object contextObj = params.get("_taskContext");
|
if (contextObj instanceof TaskExecutionContext) {
|
TaskExecutionContext context = (TaskExecutionContext) contextObj;
|
List<String> scannedGlassIds = (List<String>) context.getSharedData()
|
.computeIfAbsent("scannedGlassIds", k -> new java.util.ArrayList<>());
|
if (!scannedGlassIds.contains(glassId)) {
|
scannedGlassIds.add(glassId);
|
log.debug("已保存扫描到的玻璃ID到共享数据: glassId={}", glassId);
|
}
|
}
|
}
|
|
private DevicePlcVO.OperationResult clearPlc(DeviceConfig deviceConfig,
|
EnhancedS7Serializer serializer) {
|
try {
|
// 只清空PLC操作区字段（plcRequest、plcGlassId），不清空MES写区字段
|
Map<String, Object> resetFields = new HashMap<>();
|
resetFields.put("plcRequest", 0);
|
resetFields.put("plcGlassId", "");
|
plcDynamicDataService.writePlcData(deviceConfig, resetFields, serializer);
|
return buildResult(deviceConfig, "clearPlc", true, "已清空PLC操作区字段（保留MES写区字段）", null);
|
} catch (Exception e) {
|
log.error("卧转立扫码清空PLC失败, deviceId={}", deviceConfig.getId(), e);
|
return buildResult(deviceConfig, "clearPlc", false, "清空PLC失败: " + e.getMessage(), null);
|
}
|
}
|
|
/**
|
* 触发MES请求：写入plcRequest=1和plcGlassId（如果提供了玻璃ID）
|
*/
|
private void triggerScanRequest(DeviceConfig deviceConfig, EnhancedS7Serializer serializer, String glassId) {
|
Map<String, Object> writeFields = new HashMap<>();
|
writeFields.put("plcRequest", 1);
|
|
if (StringUtils.hasText(glassId)) {
|
writeFields.put("plcGlassId", glassId);
|
}
|
|
plcDynamicDataService.writePlcData(deviceConfig, writeFields, serializer);
|
}
|
|
/**
|
* 清空PLC请求字段：只清除plcRequest和plcGlassId（不清除MES写区字段）
|
*/
|
private void clearPlcRequestFields(DeviceConfig deviceConfig, EnhancedS7Serializer serializer) {
|
try {
|
Map<String, Object> clearFields = new HashMap<>();
|
clearFields.put("plcRequest", 0);
|
clearFields.put("plcGlassId", "");
|
plcDynamicDataService.writePlcData(deviceConfig, clearFields, serializer);
|
} catch (Exception e) {
|
log.error("清空PLC请求字段失败: deviceId={}", deviceConfig.getId(), e);
|
// 不清空不影响主流程，只记录错误
|
}
|
}
|
|
private Map<String, Object> waitForMesData(DeviceConfig deviceConfig,
|
EnhancedS7Serializer serializer,
|
WorkstationLogicConfig config) throws InterruptedException {
|
long timeoutMs = Math.max(config.getScanIntervalMs(), 3_000);
|
long deadline = System.currentTimeMillis() + timeoutMs;
|
int pollInterval = Math.max(200, Math.min(config.getScanIntervalMs() / 5, 1_000));
|
|
while (System.currentTimeMillis() < deadline) {
|
Map<String, Object> mesData = plcDynamicDataService.readPlcData(deviceConfig, MES_FIELDS, serializer);
|
|
if (mesData != null && !mesData.isEmpty()) {
|
Integer mesSend = parseInteger(mesData.get("mesSend"));
|
if (mesSend != null && mesSend == 1) {
|
log.info("检测到MES已写入数据: deviceId={}, mesSend=1, mesGlassId={}, mesWidth={}, mesHeight={}, workLine={}",
|
deviceConfig.getId(),
|
mesData.get("mesGlassId"),
|
mesData.get("mesWidth"),
|
mesData.get("mesHeight"),
|
mesData.get("workLine"));
|
return mesData;
|
}
|
}
|
|
Thread.sleep(pollInterval);
|
}
|
|
// 超时前最后一次尝试读取
|
log.warn("等待MES数据超时: deviceId={}, timeout={}ms", deviceConfig.getId(), timeoutMs);
|
Map<String, Object> lastMesData = plcDynamicDataService.readPlcData(deviceConfig, MES_FIELDS, serializer);
|
if (lastMesData != null && !lastMesData.isEmpty()) {
|
log.warn("超时前最后一次读取到的数据: deviceId={}, mesData={}",
|
deviceConfig.getId(), lastMesData);
|
}
|
|
return Collections.emptyMap();
|
}
|
|
private GlassInfo buildGlassInfo(String glassId, Integer width, Integer height, Integer workLine) {
|
GlassInfo glassInfo = new GlassInfo();
|
glassInfo.setGlassId(glassId.trim());
|
// mesWidth=表宽 -> glassWidth, mesHeight=长 -> glassLength
|
if (width != null) {
|
glassInfo.setGlassWidth(width); // 表宽
|
}
|
if (height != null) {
|
glassInfo.setGlassLength(height); // 长
|
}
|
glassInfo.setStatus(GlassInfo.Status.PENDING);
|
if (workLine != null) {
|
glassInfo.setDescription("workLine=" + workLine);
|
}
|
Date now = new Date();
|
glassInfo.setCreatedTime(now);
|
glassInfo.setUpdatedTime(now);
|
glassInfo.setCreatedBy("system");
|
glassInfo.setUpdatedBy("system");
|
return glassInfo;
|
}
|
|
private Integer parseInteger(Object value) {
|
if (value instanceof Number) {
|
return ((Number) value).intValue();
|
}
|
if (value == null) {
|
return null;
|
}
|
try {
|
return Integer.parseInt(String.valueOf(value));
|
} catch (NumberFormatException e) {
|
return null;
|
}
|
}
|
|
private String parseString(Object value) {
|
return value == null ? null : String.valueOf(value).trim();
|
}
|
|
private DevicePlcVO.OperationResult buildResult(DeviceConfig deviceConfig,
|
String operation,
|
boolean success,
|
String message,
|
Map<String, Object> data) {
|
return DevicePlcVO.OperationResult.builder()
|
.deviceId(deviceConfig.getId())
|
.deviceName(deviceConfig.getDeviceName())
|
.deviceCode(deviceConfig.getDeviceCode())
|
.projectId(deviceConfig.getProjectId() != null ? String.valueOf(deviceConfig.getProjectId()) : null)
|
.operation(operation)
|
.success(success)
|
.message(message)
|
.timestamp(LocalDateTime.now())
|
.data(data)
|
.build();
|
}
|
}
|
