#

Junjie

18 小时以前 febc49cd36666823893c233667b212dfb5527dfb

 src/main/java/com/zy/core/utils/StationOperateProcessUtils.java

@@ -26,6 +26,7 @@
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;

@Component
public class StationOperateProcessUtils {
@@ -52,19 +53,9 @@
    @Autowired
    private BasCrnpService basCrnpService;

    //执行输送站点入库任务
    public synchronized void stationInExecute() {
        stationRegularDispatchProcessor.stationInExecute();
    }

    // 执行单个站点的入库任务下发
    public void stationInExecute(BasDevp basDevp, StationObjModel stationObjModel) {
        stationRegularDispatchProcessor.stationInExecute(basDevp, stationObjModel);
    }

    //执行堆垛机输送站点出库任务
    public synchronized void crnStationOutExecute() {
        stationOutboundDispatchProcessor.crnStationOutExecute();
    }

    // 执行单个出库任务对应的输送站点下发
@@ -72,19 +63,14 @@
        stationOutboundDispatchProcessor.crnStationOutExecute(wrkMast);
    }

    //执行双工位堆垛机输送站点出库任务
    public synchronized void dualCrnStationOutExecute() {
        stationOutboundDispatchProcessor.dualCrnStationOutExecute();
    }

    //检测输送站点出库任务执行完成
    public synchronized void stationOutExecuteFinish() {
        stationRegularDispatchProcessor.stationOutExecuteFinish();
    // 执行单个双工位出库任务对应的输送站点下发
    public void dualCrnStationOutExecute(WrkMast wrkMast) {
        stationOutboundDispatchProcessor.dualCrnStationOutExecute(wrkMast);
    }

    // 检测单个出库任务是否到达目标站台
    public void stationOutExecuteFinish(WrkMast wrkMast) {
        stationRegularDispatchProcessor.stationOutExecuteFinish(wrkMast);
    public void stationOutExecuteFinish(StationObjModel stationObjModel) {
        stationRegularDispatchProcessor.stationOutExecuteFinish(stationObjModel);
    }

    // 检测单个入库任务是否到达目标站台
@@ -114,29 +100,14 @@
        }
    }

    // 检测任务转完成
    public void checkTaskToComplete() {
        stationRegularDispatchProcessor.checkTaskToComplete();
    }

    // 检测单个出库任务是否可以转完成
    public void checkTaskToComplete(WrkMast wrkMast) {
        stationRegularDispatchProcessor.checkTaskToComplete(wrkMast);
    }

    //检测输送站点是否运行堵塞
    public void checkStationRunBlock() {
        stationRerouteProcessor.checkStationRunBlock();
    }

    // 检测单个站点是否运行堵塞
    public void checkStationRunBlock(BasDevp basDevp, Integer stationId) {
        stationRerouteProcessor.checkStationRunBlock(basDevp, stationId);
    }

    //检测输送站点任务停留超时后重新计算路径
    public void checkStationIdleRecover() {
        stationRerouteProcessor.checkStationIdleRecover();
    }

    // 检测单个站点任务停留超时后的恢复处理
@@ -162,19 +133,9 @@
                        WrkStsType.STATION_RUN.sts));
    }

    // 检测出库排序
    public synchronized void checkStationOutOrder() {
        stationRerouteProcessor.checkStationOutOrder();
    }

    // 检测单个站点的出库排序
    public void checkStationOutOrder(BasDevp basDevp, StationObjModel stationObjModel) {
        stationRerouteProcessor.checkStationOutOrder(basDevp, stationObjModel);
    }

    // 监控绕圈站点
    public synchronized void watchCircleStation() {
        stationRerouteProcessor.watchCircleStation();
    }

    // 监控单个绕圈站点
@@ -206,7 +167,9 @@
                if (stationProtocol == null
                        || !stationProtocol.isAutoing()
                        || !stationProtocol.isLoading()
                        || stationProtocol.getTaskNo() <= 0) {
                        || stationProtocol.getTaskNo() <= 0
                        || !stationProtocol.isInEnable()
                ) {
                    continue;
                }
                mainProcessTaskSubmitter.submitKeyedSerialTask(
@@ -243,22 +206,45 @@
        }
    }

    public void submitDualCrnStationOutTasks(long minIntervalMs) {
        submitDualCrnStationOutTasks(MainProcessLane.DUAL_STATION_OUT, minIntervalMs);
    }

    public void submitDualCrnStationOutTasks(MainProcessLane lane, long minIntervalMs) {
        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts)
                .isNotNull("dual_crn_no"));
        for (WrkMast wrkMast : wrkMasts) {
            Integer laneKey = wrkMast == null ? null : wrkMast.getSourceStaNo();
            if (laneKey == null) {
                laneKey = wrkMast == null ? null : wrkMast.getWrkNo();
            }
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    laneKey,
                    "dualCrnStationOutExecute",
                    minIntervalMs,
                    () -> dualCrnStationOutExecute(wrkMast)
            );
        }
    }

    public void submitStationOutExecuteFinishTasks(long minIntervalMs) {
        submitStationOutExecuteFinishTasks(MainProcessLane.STATION_OUT_FINISH, minIntervalMs);
    }

    public void submitStationOutExecuteFinishTasks(MainProcessLane lane, long minIntervalMs) {
        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("wrk_sts", WrkStsType.STATION_RUN.sts)
                .isNotNull("sta_no"));
        for (WrkMast wrkMast : wrkMasts) {
            mainProcessTaskSubmitter.submitKeyedSerialTask(
                    lane,
                    wrkMast.getStaNo(),
                    "stationOutExecuteFinish",
                    minIntervalMs,
                    () -> stationOutExecuteFinish(wrkMast)
            );
        List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
        for (BasDevp basDevp : basDevps) {
            for (StationObjModel stationObjModel : basDevp.getOutStationList$()) {
                mainProcessTaskSubmitter.submitKeyedSerialTask(
                        lane,
                        stationObjModel.getStationId(),
                        "stationOutExecuteFinish",
                        minIntervalMs,
                        () -> stationOutExecuteFinish(stationObjModel)
                );
            }
        }
    }

@@ -426,6 +412,9 @@
                if (stationId == null) {
                    continue;
                }
                if (!isIdleRecoverCandidateStation(basDevp, stationId)) {
                    continue;
                }
                if (!stationProtocol.isAutoing()
                        || !stationProtocol.isLoading()
                        || stationProtocol.getTaskNo() <= 0
@@ -463,7 +452,32 @@
        return stationRerouteProcessor.shouldUseRunBlockDirectReassign(wrkMast, stationId, runBlockReassignLocStationList);
    }

    public boolean isIdleRecoverCandidateStation(BasDevp basDevp, Integer stationId) {
        if (basDevp == null || stationId == null) {
            return false;
        }
        return !containsStation(basDevp.getBarcodeStationList$(), stationId)
                && !containsStation(basDevp.getInStationList$(), stationId)
                && !containsStation(basDevp.getOutStationList$(), stationId);
    }

    private boolean containsStation(List<StationObjModel> stationList, Integer stationId) {
        if (stationList == null || stationList.isEmpty() || stationId == null) {
            return false;
        }
        for (StationObjModel stationObjModel : stationList) {
            if (stationObjModel != null && Objects.equals(stationObjModel.getStationId(), stationId)) {
                return true;
            }
        }
        return false;
    }

    private boolean shouldSkipIdleRecoverForRecentDispatch(Integer taskNo, Integer stationId) {
        return stationRerouteProcessor.shouldSkipIdleRecoverForRecentDispatch(taskNo, stationId);
    }

    public void attemptClearTaskPath(StationThread stationThread, Integer taskNo) {
        stationRegularDispatchProcessor.attemptClearTaskPath(stationThread, taskNo);
    }
}