package com.zy.core.utils.station;
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.core.common.Cools;
|
import com.zy.asrs.entity.BasDevp;
|
import com.zy.asrs.entity.BasStation;
|
import com.zy.asrs.entity.WrkMast;
|
import com.zy.asrs.service.BasDevpService;
|
import com.zy.asrs.service.BasStationService;
|
import com.zy.asrs.service.WrkMastService;
|
import com.zy.common.model.NavigateNode;
|
import com.zy.common.utils.NavigateUtils;
|
import com.zy.core.News;
|
import com.zy.core.cache.SlaveConnection;
|
import com.zy.core.enums.SlaveType;
|
import com.zy.core.enums.StationCommandType;
|
import com.zy.core.enums.WrkIoType;
|
import com.zy.core.enums.WrkStsType;
|
import com.zy.core.model.command.StationCommand;
|
import com.zy.core.model.protocol.StationProtocol;
|
import com.zy.core.move.StationMoveCoordinator;
|
import com.zy.core.move.StationMoveDispatchMode;
|
import com.zy.core.move.StationMoveSession;
|
import com.zy.core.service.StationTaskLoopService;
|
import com.zy.core.thread.StationThread;
|
import com.zy.core.utils.station.model.CircleTargetCandidate;
|
import com.zy.core.utils.station.model.OutOrderDispatchDecision;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
|
@Component
|
public class StationOutboundDecisionSupport {
|
|
@Autowired
|
private WrkMastService wrkMastService;
|
@Autowired
|
private BasDevpService basDevpService;
|
@Autowired
|
private BasStationService basStationService;
|
@Autowired
|
private NavigateUtils navigateUtils;
|
@Autowired
|
private StationTaskLoopService stationTaskLoopService;
|
@Autowired
|
private StationMoveCoordinator stationMoveCoordinator;
|
@Autowired
|
private StationDispatchRuntimeStateSupport stationDispatchRuntimeStateSupport;
|
|
public StationCommand buildOutboundMoveCommand(StationThread stationThread,
|
WrkMast wrkMast,
|
Integer stationId,
|
Integer targetStationId,
|
Double pathLenFactor) {
|
if (stationThread == null || wrkMast == null) {
|
return null;
|
}
|
return stationThread.getCommand(
|
StationCommandType.MOVE,
|
wrkMast.getWrkNo(),
|
stationId,
|
targetStationId,
|
0,
|
normalizePathLenFactor(pathLenFactor)
|
);
|
}
|
|
public Double resolveOutboundPathLenFactor(WrkMast wrkMast) {
|
if (!isBatchOutboundTaskWithSeq(wrkMast)) {
|
return 0.0d;
|
}
|
List<WrkMast> activeBatchTaskList = loadActiveBatchTaskList(wrkMast.getBatch());
|
if (activeBatchTaskList.size() <= 1) {
|
return 0.0d;
|
}
|
|
int activeTaskCount = 0;
|
int predecessorCount = 0;
|
for (WrkMast item : activeBatchTaskList) {
|
if (!isFactorCandidateTask(item)) {
|
continue;
|
}
|
activeTaskCount++;
|
if (item.getBatchSeq() < wrkMast.getBatchSeq()) {
|
predecessorCount++;
|
}
|
}
|
if (activeTaskCount <= 1 || predecessorCount <= 0) {
|
return 0.0d;
|
}
|
return normalizePathLenFactor((double) predecessorCount / (double) (activeTaskCount - 1));
|
}
|
|
public List<Integer> getAllOutOrderList() {
|
List<Integer> list = new ArrayList<>();
|
List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
|
for (BasDevp basDevp : basDevps) {
|
List<Integer> orderList = basDevp.getOutOrderIntList();
|
list.addAll(orderList);
|
}
|
return list;
|
}
|
|
public OutOrderDispatchDecision resolveOutboundDispatchDecision(Integer currentStationId,
|
WrkMast wrkMast,
|
List<Integer> outOrderStationIds,
|
Double pathLenFactor) {
|
if (wrkMast == null || wrkMast.getStaNo() == null) {
|
return null;
|
}
|
if (!shouldApplyOutOrder(wrkMast, outOrderStationIds)) {
|
return OutOrderDispatchDecision.direct(wrkMast.getStaNo());
|
}
|
Integer dispatchStationId = resolveDispatchOutOrderTarget(
|
wrkMast,
|
wrkMast.getSourceStaNo(),
|
wrkMast.getStaNo(),
|
outOrderStationIds,
|
pathLenFactor
|
);
|
if (dispatchStationId == null) {
|
return null;
|
}
|
if (isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds, pathLenFactor)) {
|
return resolveCurrentOutOrderDispatchDecision(currentStationId, wrkMast, outOrderStationIds, pathLenFactor);
|
}
|
if (!Objects.equals(dispatchStationId, wrkMast.getStaNo())
|
&& isCurrentOutOrderStation(currentStationId, outOrderStationIds)
|
&& isWatchingCircleArrival(wrkMast.getWrkNo(), currentStationId)) {
|
return OutOrderDispatchDecision.circle(dispatchStationId, null, false);
|
}
|
return OutOrderDispatchDecision.direct(dispatchStationId);
|
}
|
|
public void syncOutOrderWatchState(WrkMast wrkMast,
|
Integer currentStationId,
|
List<Integer> outOrderStationIds,
|
OutOrderDispatchDecision dispatchDecision,
|
StationCommand command) {
|
if (dispatchDecision == null || command == null || !shouldApplyOutOrder(wrkMast, outOrderStationIds)) {
|
return;
|
}
|
if (dispatchDecision.isCircle()) {
|
stationDispatchRuntimeStateSupport.saveWatchCircleCommand(wrkMast.getWrkNo(), command);
|
if (dispatchDecision.shouldCountLoopIssue()
|
&& stationTaskLoopService != null
|
&& dispatchDecision.getLoopEvaluation() != null) {
|
stationTaskLoopService.recordLoopIssue(dispatchDecision.getLoopEvaluation(), "OUT_ORDER_CIRCLE");
|
}
|
} else {
|
stationDispatchRuntimeStateSupport.clearWatchCircleCommand(wrkMast.getWrkNo());
|
}
|
}
|
|
public boolean shouldSkipOutOrderDispatchForExistingRoute(Integer wrkNo, Integer stationId) {
|
if (stationMoveCoordinator == null || wrkNo == null || wrkNo <= 0 || stationId == null) {
|
return false;
|
}
|
StationMoveSession session = stationMoveCoordinator.loadSession(wrkNo);
|
if (session == null) {
|
return false;
|
}
|
if (!session.isActive() || !session.containsStation(stationId)) {
|
return false;
|
}
|
if (StationMoveDispatchMode.CIRCLE == session.getDispatchMode()) {
|
return true;
|
}
|
return !Objects.equals(stationId, session.getCurrentRouteTargetStationId());
|
}
|
|
public boolean isWatchingCircleArrival(Integer wrkNo, Integer stationId) {
|
if (stationMoveCoordinator != null) {
|
StationMoveSession session = stationMoveCoordinator.loadSession(wrkNo);
|
if (session != null && session.isActive() && stationId != null) {
|
if (stationId.equals(session.getNextDecisionStationId())) {
|
return true;
|
}
|
if (session.containsStation(stationId)) {
|
return false;
|
}
|
}
|
}
|
StationCommand command = stationDispatchRuntimeStateSupport.loadWatchCircleCommand(wrkNo);
|
return command != null && stationId != null && stationId.equals(command.getTargetStaNo());
|
}
|
|
private List<NavigateNode> calcOutboundNavigatePath(WrkMast wrkMast,
|
Integer sourceStationId,
|
Integer targetStationId,
|
Double pathLenFactor) {
|
Double normalizedFactor = normalizePathLenFactor(pathLenFactor);
|
Integer currentTaskNo = wrkMast == null ? null : wrkMast.getWrkNo();
|
if (currentTaskNo == null) {
|
return navigateUtils.calcByStationId(sourceStationId, targetStationId, normalizedFactor);
|
}
|
return navigateUtils.calcByStationId(sourceStationId, targetStationId, currentTaskNo, normalizedFactor);
|
}
|
|
private boolean isBatchOutboundTaskWithSeq(WrkMast wrkMast) {
|
return wrkMast != null
|
&& Objects.equals(wrkMast.getIoType(), WrkIoType.OUT.id)
|
&& !Cools.isEmpty(wrkMast.getBatch())
|
&& wrkMast.getBatchSeq() != null
|
&& wrkMast.getWrkNo() != null;
|
}
|
|
private List<WrkMast> loadActiveBatchTaskList(String batch) {
|
if (Cools.isEmpty(batch)) {
|
return Collections.emptyList();
|
}
|
return wrkMastService.list(new QueryWrapper<WrkMast>()
|
.eq("io_type", WrkIoType.OUT.id)
|
.eq("batch", batch)
|
.notIn("wrk_sts",
|
WrkStsType.STATION_RUN_COMPLETE.sts,
|
WrkStsType.COMPLETE_OUTBOUND.sts,
|
WrkStsType.SETTLE_OUTBOUND.sts));
|
}
|
|
private boolean isFactorCandidateTask(WrkMast wrkMast) {
|
return wrkMast != null
|
&& Objects.equals(wrkMast.getIoType(), WrkIoType.OUT.id)
|
&& wrkMast.getBatchSeq() != null
|
&& !"taskCancel".equals(wrkMast.getMk());
|
}
|
|
private boolean shouldApplyOutOrder(WrkMast wrkMast, List<Integer> outOrderStationIds) {
|
return wrkMast != null
|
&& wrkMast.getStaNo() != null
|
&& Objects.equals(wrkMast.getIoType(), WrkIoType.OUT.id)
|
&& !Cools.isEmpty(wrkMast.getBatch())
|
&& wrkMast.getBatchSeq() != null
|
&& outOrderStationIds != null
|
&& !outOrderStationIds.isEmpty();
|
}
|
|
private boolean isCurrentOutOrderDispatchStation(Integer currentStationId,
|
WrkMast wrkMast,
|
List<Integer> outOrderStationIds,
|
Double pathLenFactor) {
|
if (!shouldApplyOutOrder(wrkMast, outOrderStationIds) || currentStationId == null) {
|
return false;
|
}
|
Integer dispatchStationId = resolveDispatchOutOrderTarget(
|
wrkMast,
|
wrkMast.getSourceStaNo(),
|
wrkMast.getStaNo(),
|
outOrderStationIds,
|
pathLenFactor
|
);
|
return dispatchStationId != null
|
&& !Objects.equals(dispatchStationId, wrkMast.getStaNo())
|
&& Objects.equals(currentStationId, dispatchStationId);
|
}
|
|
private boolean isCurrentOutOrderStation(Integer currentStationId,
|
List<Integer> outOrderStationIds) {
|
return currentStationId != null
|
&& outOrderStationIds != null
|
&& outOrderStationIds.contains(currentStationId);
|
}
|
|
private OutOrderDispatchDecision resolveCurrentOutOrderDispatchDecision(Integer currentStationId,
|
WrkMast wrkMast,
|
List<Integer> outOrderStationIds,
|
Double pathLenFactor) {
|
if (!isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds, pathLenFactor)) {
|
return null;
|
}
|
|
List<WrkMast> batchWrkList = wrkMastService.list(new QueryWrapper<WrkMast>()
|
.eq("io_type", WrkIoType.OUT.id)
|
.notIn("wrk_sts",
|
WrkStsType.STATION_RUN_COMPLETE.sts,
|
WrkStsType.COMPLETE_OUTBOUND.sts,
|
WrkStsType.SETTLE_OUTBOUND.sts)
|
.eq("batch", wrkMast.getBatch())
|
.orderByAsc("batch_seq")
|
.orderByAsc("wrk_no"));
|
if (batchWrkList.isEmpty()) {
|
return OutOrderDispatchDecision.direct(wrkMast.getStaNo());
|
}
|
|
WrkMast firstWrkMast = batchWrkList.get(0);
|
Integer currentBatchSeq = firstWrkMast.getBatchSeq();
|
if (currentBatchSeq == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "批次:{} 首个未完成任务缺少批次序号，当前任务暂不放行", wrkMast.getBatch());
|
return null;
|
}
|
|
List<NavigateNode> initPath;
|
try {
|
initPath = calcOutboundNavigatePath(wrkMast, wrkMast.getSourceStaNo(), wrkMast.getStaNo(), pathLenFactor);
|
} catch (Exception e) {
|
News.taskInfo(wrkMast.getWrkNo(), "批次:{} 计算排序路径失败，当前站点={}", wrkMast.getBatch(), currentStationId);
|
return null;
|
}
|
|
Integer seq = getOutStationBatchSeq(initPath, currentStationId, wrkMast.getBatch());
|
boolean toTarget = seq == null
|
? currentBatchSeq.equals(wrkMast.getBatchSeq())
|
: Integer.valueOf(seq + 1).equals(wrkMast.getBatchSeq());
|
if (toTarget) {
|
if (hasReachableOutReleaseSlot(wrkMast, currentStationId, wrkMast.getStaNo(), pathLenFactor)) {
|
return OutOrderDispatchDecision.direct(wrkMast.getStaNo());
|
}
|
StationTaskLoopService.LoopEvaluation loopEvaluation = evaluateOutOrderLoop(
|
wrkMast.getWrkNo(),
|
currentStationId,
|
outOrderStationIds
|
);
|
Integer circleTarget = resolveNextCircleOrderTarget(
|
wrkMast,
|
currentStationId,
|
outOrderStationIds,
|
loopEvaluation.getExpectedLoopIssueCount(),
|
pathLenFactor
|
);
|
if (circleTarget == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "目标站当前不可进，且未找到可执行的下一排序检测点，当前站点={}", currentStationId);
|
return null;
|
}
|
return OutOrderDispatchDecision.circle(circleTarget, loopEvaluation, true);
|
}
|
|
StationTaskLoopService.LoopEvaluation loopEvaluation = evaluateOutOrderLoop(
|
wrkMast.getWrkNo(),
|
currentStationId,
|
outOrderStationIds
|
);
|
Integer circleTarget = resolveNextCircleOrderTarget(
|
wrkMast,
|
currentStationId,
|
outOrderStationIds,
|
loopEvaluation.getExpectedLoopIssueCount(),
|
pathLenFactor
|
);
|
if (circleTarget == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "未找到可执行的下一排序检测点，当前站点={}", currentStationId);
|
return null;
|
}
|
return OutOrderDispatchDecision.circle(circleTarget, loopEvaluation, true);
|
}
|
|
private StationTaskLoopService.LoopEvaluation evaluateOutOrderLoop(Integer taskNo,
|
Integer currentStationId,
|
List<Integer> outOrderStationIds) {
|
if (stationTaskLoopService == null) {
|
return new StationTaskLoopService.LoopEvaluation(
|
taskNo,
|
currentStationId,
|
StationTaskLoopService.LoopIdentitySnapshot.empty(),
|
0,
|
0,
|
false
|
);
|
}
|
return stationTaskLoopService.evaluateLoop(
|
taskNo,
|
currentStationId,
|
true,
|
outOrderStationIds,
|
"outOrderCircle"
|
);
|
}
|
|
private Integer resolveDispatchOutOrderTarget(WrkMast wrkMast,
|
Integer sourceStationId,
|
Integer finalTargetStationId,
|
List<Integer> outOrderList,
|
Double pathLenFactor) {
|
if (finalTargetStationId == null) {
|
return null;
|
}
|
if (sourceStationId == null || outOrderList == null || outOrderList.isEmpty()) {
|
return finalTargetStationId;
|
}
|
|
try {
|
List<NavigateNode> nodes = calcOutboundNavigatePath(wrkMast, sourceStationId, finalTargetStationId, pathLenFactor);
|
for (int i = nodes.size() - 1; i >= 0; i--) {
|
Integer stationId = getStationIdFromNode(nodes.get(i));
|
if (stationId == null) {
|
continue;
|
}
|
if (Objects.equals(stationId, finalTargetStationId)) {
|
continue;
|
}
|
if (outOrderList.contains(stationId)) {
|
return stationId;
|
}
|
}
|
} catch (Exception ignore) {
|
}
|
return finalTargetStationId;
|
}
|
|
private boolean hasReachableOutReleaseSlot(WrkMast wrkMast,
|
Integer currentStationId,
|
Integer finalTargetStationId,
|
Double pathLenFactor) {
|
if (currentStationId == null || finalTargetStationId == null) {
|
return true;
|
}
|
|
try {
|
List<NavigateNode> nodes = calcOutboundNavigatePath(wrkMast, currentStationId, finalTargetStationId, pathLenFactor);
|
if (nodes == null || nodes.isEmpty()) {
|
return true;
|
}
|
|
for (NavigateNode node : nodes) {
|
Integer stationId = getStationIdFromNode(node);
|
if (stationId == null || Objects.equals(stationId, currentStationId)) {
|
continue;
|
}
|
if (!isPathStationBlocked(stationId)) {
|
return true;
|
}
|
}
|
return false;
|
} catch (Exception ignore) {
|
return true;
|
}
|
}
|
|
private boolean isPathStationBlocked(Integer stationId) {
|
if (stationId == null) {
|
return true;
|
}
|
|
BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", stationId));
|
if (basStation == null) {
|
return true;
|
}
|
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
|
if (stationThread == null) {
|
return true;
|
}
|
|
StationProtocol stationProtocol = stationThread.getStatusMap().get(stationId);
|
if (stationProtocol == null) {
|
return true;
|
}
|
|
return !stationProtocol.isAutoing()
|
|| stationProtocol.isLoading()
|
|| (stationProtocol.getTaskNo() != null && stationProtocol.getTaskNo() > 0);
|
}
|
|
private Integer resolveNextCircleOrderTarget(WrkMast wrkMast,
|
Integer currentStationId,
|
List<Integer> orderedOutStationList,
|
Integer expectedLoopIssueCount,
|
Double pathLenFactor) {
|
if (currentStationId == null || orderedOutStationList == null || orderedOutStationList.size() <= 1) {
|
return null;
|
}
|
|
int startIndex = orderedOutStationList.indexOf(currentStationId);
|
int total = orderedOutStationList.size();
|
List<CircleTargetCandidate> candidateList = new ArrayList<>();
|
for (int offset = 1; offset < total; offset++) {
|
int candidateIndex = (startIndex + offset + total) % total;
|
Integer candidateStationId = orderedOutStationList.get(candidateIndex);
|
if (candidateStationId == null || currentStationId.equals(candidateStationId)) {
|
continue;
|
}
|
try {
|
List<NavigateNode> path = calcOutboundNavigatePath(wrkMast, currentStationId, candidateStationId, pathLenFactor);
|
if (path != null && !path.isEmpty()) {
|
candidateList.add(new CircleTargetCandidate(candidateStationId, path.size(), offset));
|
}
|
} catch (Exception ignore) {
|
}
|
}
|
if (candidateList.isEmpty()) {
|
return null;
|
}
|
candidateList.sort(new Comparator<CircleTargetCandidate>() {
|
@Override
|
public int compare(CircleTargetCandidate left, CircleTargetCandidate right) {
|
if (left == right) {
|
return 0;
|
}
|
if (left == null) {
|
return 1;
|
}
|
if (right == null) {
|
return -1;
|
}
|
int pathCompare = Integer.compare(left.getPathLength(), right.getPathLength());
|
if (pathCompare != 0) {
|
return pathCompare;
|
}
|
return Integer.compare(left.getOffset(), right.getOffset());
|
}
|
});
|
return resolveGradualCircleTargetByPathLength(expectedLoopIssueCount, candidateList, pathLenFactor);
|
}
|
|
private Integer resolveGradualCircleTargetByPathLength(Integer expectedLoopIssueCount,
|
List<CircleTargetCandidate> candidateList,
|
Double pathLenFactor) {
|
if (candidateList == null || candidateList.isEmpty()) {
|
return null;
|
}
|
|
List<CircleTargetCandidate> tierList = new ArrayList<>();
|
Integer lastPathLength = null;
|
for (CircleTargetCandidate candidate : candidateList) {
|
if (candidate == null) {
|
continue;
|
}
|
if (lastPathLength == null || !Objects.equals(lastPathLength, candidate.getPathLength())) {
|
tierList.add(candidate);
|
lastPathLength = candidate.getPathLength();
|
}
|
}
|
if (tierList.isEmpty()) {
|
return candidateList.get(0).getStationId();
|
}
|
int defaultTierIndex = expectedLoopIssueCount == null || expectedLoopIssueCount <= 2
|
? 0
|
: Math.min(expectedLoopIssueCount - 2, tierList.size() - 1);
|
int factorTierIndex = (int) Math.round(normalizePathLenFactor(pathLenFactor) * (tierList.size() - 1));
|
int tierIndex = Math.max(defaultTierIndex, factorTierIndex);
|
return tierList.get(tierIndex).getStationId();
|
}
|
|
private Integer getOutStationBatchSeq(List<NavigateNode> pathList, Integer searchStationId, String searchBatch) {
|
if (pathList == null || pathList.isEmpty() || searchStationId == null || Cools.isEmpty(searchBatch)) {
|
return null;
|
}
|
|
List<Integer> checkList = new ArrayList<>();
|
for (int i = pathList.size() - 1; i >= 0; i--) {
|
NavigateNode node = pathList.get(i);
|
JSONObject value = JSONObject.parseObject(node.getNodeValue());
|
if (value == null) {
|
continue;
|
}
|
Integer stationId = value.getInteger("stationId");
|
if (searchStationId.equals(stationId)) {
|
break;
|
}
|
checkList.add(stationId);
|
}
|
|
HashMap<String, Integer> batchMap = new HashMap<>();
|
for (Integer station : checkList) {
|
BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", station));
|
if (basStation == null) {
|
continue;
|
}
|
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
|
if (stationThread == null) {
|
continue;
|
}
|
StationProtocol checkStationProtocol = stationThread.getStatusMap().get(station);
|
if (checkStationProtocol == null) {
|
continue;
|
}
|
if (checkStationProtocol.getTaskNo() > 0) {
|
WrkMast checkWrkMast = wrkMastService.selectByWorkNo(checkStationProtocol.getTaskNo());
|
if (checkWrkMast == null) {
|
continue;
|
}
|
|
if (!Cools.isEmpty(checkWrkMast.getBatch())) {
|
batchMap.put(checkWrkMast.getBatch(), checkWrkMast.getBatchSeq());
|
}
|
}
|
}
|
|
return batchMap.get(searchBatch);
|
}
|
|
private Integer getStationIdFromNode(NavigateNode node) {
|
if (node == null || isBlank(node.getNodeValue())) {
|
return null;
|
}
|
try {
|
JSONObject value = JSONObject.parseObject(node.getNodeValue());
|
return value == null ? null : value.getInteger("stationId");
|
} catch (Exception ignore) {
|
return null;
|
}
|
}
|
|
private Double normalizePathLenFactor(Double pathLenFactor) {
|
if (pathLenFactor == null || pathLenFactor < 0.0d) {
|
return 0.0d;
|
}
|
if (pathLenFactor > 1.0d) {
|
return 1.0d;
|
}
|
return pathLenFactor;
|
}
|
|
private boolean isBlank(String value) {
|
return value == null || value.trim().isEmpty();
|
}
|
}
|
