#

Junjie

16 小时以前 103ca74d9b67ce4f766b5f77451741a76fa696b9

#

 src/main/java/com/zy/common/utils/NavigateUtils.java

@@ -73,20 +73,40 @@
    private StationTaskTraceRegistry stationTaskTraceRegistry;

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId) {
        return calcByStationId(startStationId, endStationId, null, false);
        return calcByStationId(startStationId, endStationId, null, null, false);
    }

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId,
                                                           Integer endStationId,
                                                           Double pathLenFactor) {
        return calcByStationId(startStationId, endStationId, null, pathLenFactor, false);
    }

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId, Integer endStationId, Integer currentTaskNo) {
        return calcByStationId(startStationId, endStationId, currentTaskNo, false);
        return calcByStationId(startStationId, endStationId, currentTaskNo, null, false);
    }

    public synchronized List<NavigateNode> calcByStationId(Integer startStationId,
                                                           Integer endStationId,
                                                           Integer currentTaskNo,
                                                           Double pathLenFactor) {
        return calcByStationId(startStationId, endStationId, currentTaskNo, pathLenFactor, false);
    }

    public synchronized List<NavigateNode> calcReachablePathByStationId(Integer startStationId, Integer endStationId) {
        return calcByStationId(startStationId, endStationId, null, true);
        return calcByStationId(startStationId, endStationId, null, null, true);
    }

    public synchronized List<List<NavigateNode>> calcCandidatePathByStationId(Integer startStationId,
                                                                              Integer endStationId,
                                                                              Integer currentTaskNo) {
        return calcCandidatePathByStationId(startStationId, endStationId, currentTaskNo, null);
    }

    public synchronized List<List<NavigateNode>> calcCandidatePathByStationId(Integer startStationId,
                                                                              Integer endStationId,
                                                                              Integer currentTaskNo,
                                                                              Double pathLenFactor) {
        StationPathSearchContext context = buildStationPathSearchContext(startStationId, endStationId);
        if (context.allList.isEmpty()) {
            return new ArrayList<>();
@@ -96,6 +116,7 @@
                context.allList,
                context.resolvedPolicy,
                currentTaskNo,
                pathLenFactor,
                startStationId,
                endStationId
        );
@@ -118,6 +139,7 @@
    private synchronized List<NavigateNode> calcByStationId(Integer startStationId,
                                                            Integer endStationId,
                                                            Integer currentTaskNo,
                                                            Double pathLenFactor,
                                                            boolean reachabilityOnly) {
        StationPathSearchContext context = buildStationPathSearchContext(startStationId, endStationId);
        if (context.allList.isEmpty()) {
@@ -125,7 +147,7 @@
        }
        List<NavigateNode> list = reachabilityOnly
                ? findStationReachablePath(context.allList, context.resolvedPolicy, startStationId, endStationId)
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, startStationId, endStationId);
                : findStationBestPathTwoStage(context.allList, context.resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
        return normalizeStationPath(list);
    }

@@ -274,9 +296,10 @@
    private List<NavigateNode> findStationBestPathTwoStage(List<List<NavigateNode>> allList,
                                                           StationPathResolvedPolicy resolvedPolicy,
                                                           Integer currentTaskNo,
                                                           Double pathLenFactor,
                                                           Integer startStationId,
                                                           Integer endStationId) {
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, startStationId, endStationId);
        List<List<NavigateNode>> orderedPathList = orderStationPathCandidates(allList, resolvedPolicy, currentTaskNo, pathLenFactor, startStationId, endStationId);
        if (orderedPathList.isEmpty()) {
            return new ArrayList<>();
        }
@@ -286,6 +309,7 @@
    private List<List<NavigateNode>> orderStationPathCandidates(List<List<NavigateNode>> allList,
                                                                StationPathResolvedPolicy resolvedPolicy,
                                                                Integer currentTaskNo,
                                                                Double pathLenFactor,
                                                                Integer startStationId,
                                                                Integer endStationId) {
        if (allList == null || allList.isEmpty()) {
@@ -358,7 +382,8 @@
            return new ArrayList<>();
        }

        metricsList.sort((a, b) -> compareDouble(a.staticCost, b.staticCost, a.turnCount, b.turnCount, a.pathLen, b.pathLen));
        applyPathLengthPreference(metricsList, profileConfig, globalPolicy, pathLenFactor);
        metricsList.sort((a, b) -> compareStaticCandidateMetrics(a, b, pathLenFactor));
        PathCandidateMetrics preferred = metricsList.get(0);
        int maxLen = (int) Math.ceil(preferred.pathLen * safeDouble(profileConfig.getS1MaxLenRatio(), 1.15d));
        int maxTurns = preferred.turnCount + safeInt(profileConfig.getS1MaxTurnDiff(), 1);
@@ -381,8 +406,8 @@
            primaryMetrics = new ArrayList<>(primaryMetrics.subList(0, topK));
        }

        primaryMetrics.sort((a, b) -> compareDouble(a.dynamicCost, b.dynamicCost, a.pathLen, b.pathLen, a.turnCount, b.turnCount));
        secondaryMetrics.sort((a, b) -> compareDouble(a.dynamicCost, b.dynamicCost, a.pathLen, b.pathLen, a.turnCount, b.turnCount));
        primaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));
        secondaryMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));

        List<PathCandidateMetrics> remainingMetrics = new ArrayList<>();
        for (PathCandidateMetrics metrics : metricsList) {
@@ -390,7 +415,7 @@
                remainingMetrics.add(metrics);
            }
        }
        remainingMetrics.sort((a, b) -> compareDouble(a.dynamicCost, b.dynamicCost, a.pathLen, b.pathLen, a.turnCount, b.turnCount));
        remainingMetrics.sort((a, b) -> compareDynamicCandidateMetrics(a, b, pathLenFactor));

        List<List<NavigateNode>> orderedPathList = new ArrayList<>();
        appendCandidatePathList(orderedPathList, primaryMetrics);
@@ -661,9 +686,9 @@
        double congWeightFactor = globalPolicy == null ? 1.0d : globalPolicy.congWeightFactor;
        double passOtherOutStationPenaltyWeight = globalPolicy == null ? 0.0d : globalPolicy.passOtherOutStationPenaltyWeight;

        metrics.staticCost =
                safeDouble(profileConfig.getS1LenWeight(), 1.0d) * lenWeightFactor * metrics.pathLen
                        + safeDouble(profileConfig.getS1TurnWeight(), 3.0d) * metrics.turnCount
        metrics.baseLengthWeight = safeDouble(profileConfig.getS1LenWeight(), 1.0d) * lenWeightFactor;
        metrics.otherStaticCost =
                safeDouble(profileConfig.getS1TurnWeight(), 3.0d) * metrics.turnCount
                        + safeDouble(profileConfig.getS1LiftWeight(), 8.0d) * metrics.liftTransferCount
                        + passOtherOutStationPenaltyWeight * metrics.passOtherOutStationCount
                        + softDeviationWeight * metrics.softDeviationCount;
@@ -704,6 +729,105 @@
        int leftLiftCount = countLiftTransferCount(left);
        int rightLiftCount = countLiftTransferCount(right);
        return compareDouble(leftLen, rightLen, leftTurnCount, rightTurnCount, leftLiftCount, rightLiftCount);
    }

    private void applyPathLengthPreference(List<PathCandidateMetrics> metricsList,
                                           StationPathProfileConfig profileConfig,
                                           PathGlobalPolicy globalPolicy,
                                           Double pathLenFactor) {
        if (metricsList == null || metricsList.isEmpty()) {
            return;
        }
        double normalizedFactor = normalizePathLenFactor(pathLenFactor);
        int minPathLen = Integer.MAX_VALUE;
        int maxPathLen = Integer.MIN_VALUE;
        for (PathCandidateMetrics metrics : metricsList) {
            if (metrics == null) {
                continue;
            }
            minPathLen = Math.min(minPathLen, metrics.pathLen);
            maxPathLen = Math.max(maxPathLen, metrics.pathLen);
        }
        if (minPathLen == Integer.MAX_VALUE || maxPathLen == Integer.MIN_VALUE) {
            return;
        }
        double targetPathLen = normalizedFactor <= 0.0d || maxPathLen <= minPathLen
                ? minPathLen
                : minPathLen + normalizedFactor * (maxPathLen - minPathLen);
        for (PathCandidateMetrics metrics : metricsList) {
            if (metrics == null) {
                continue;
            }
            metrics.pathLenPreferenceDistance = normalizedFactor <= 0.0d
                    ? metrics.pathLen
                    : Math.abs(metrics.pathLen - targetPathLen);
            metrics.staticCost = metrics.baseLengthWeight * metrics.pathLenPreferenceDistance + metrics.otherStaticCost;
        }
    }

    private int compareStaticCandidateMetrics(PathCandidateMetrics left,
                                              PathCandidateMetrics right,
                                              Double pathLenFactor) {
        if (left == right) {
            return 0;
        }
        if (left == null) {
            return 1;
        }
        if (right == null) {
            return -1;
        }
        int result = Double.compare(left.staticCost, right.staticCost);
        if (result != 0) {
            return result;
        }
        result = Double.compare(left.pathLenPreferenceDistance, right.pathLenPreferenceDistance);
        if (result != 0) {
            return result;
        }
        result = Integer.compare(left.turnCount, right.turnCount);
        if (result != 0) {
            return result;
        }
        return comparePathLenTie(left.pathLen, right.pathLen, pathLenFactor);
    }

    private int compareDynamicCandidateMetrics(PathCandidateMetrics left,
                                               PathCandidateMetrics right,
                                               Double pathLenFactor) {
        if (left == right) {
            return 0;
        }
        if (left == null) {
            return 1;
        }
        if (right == null) {
            return -1;
        }
        int result = Double.compare(left.dynamicCost, right.dynamicCost);
        if (result != 0) {
            return result;
        }
        result = Double.compare(left.pathLenPreferenceDistance, right.pathLenPreferenceDistance);
        if (result != 0) {
            return result;
        }
        result = comparePathLenTie(left.pathLen, right.pathLen, pathLenFactor);
        if (result != 0) {
            return result;
        }
        return Integer.compare(left.turnCount, right.turnCount);
    }

    private int comparePathLenTie(int leftPathLen, int rightPathLen, Double pathLenFactor) {
        double normalizedFactor = normalizePathLenFactor(pathLenFactor);
        if (normalizedFactor <= 0.0d) {
            return Integer.compare(leftPathLen, rightPathLen);
        }
        if (normalizedFactor >= 0.5d) {
            return Integer.compare(rightPathLen, leftPathLen);
        }
        return Integer.compare(leftPathLen, rightPathLen);
    }

    private int countLiftTransferCount(List<NavigateNode> path) {
@@ -1753,6 +1877,19 @@
        return value == null ? defaultValue : value;
    }

    private double normalizePathLenFactor(Double pathLenFactor) {
        if (pathLenFactor == null) {
            return 0.0d;
        }
        if (pathLenFactor < 0.0d) {
            return 0.0d;
        }
        if (pathLenFactor > 1.0d) {
            return 1.0d;
        }
        return pathLenFactor;
    }

    private boolean notBlank(String text) {
        return text != null && !text.trim().isEmpty();
    }
@@ -1935,6 +2072,9 @@
        private int runBlockCount;
        private int softDeviationCount;
        private double loopPenalty;
        private double baseLengthWeight;
        private double otherStaticCost;
        private double pathLenPreferenceDistance;
        private double staticCost;
        private double dynamicCost;
    }

 src/main/java/com/zy/core/thread/StationThread.java

@@ -16,6 +16,15 @@

    StationCommand getCommand(StationCommandType commandType, Integer taskNo, Integer stationId, Integer targetStationId, Integer palletSize);

    default StationCommand getCommand(StationCommandType commandType,
                                      Integer taskNo,
                                      Integer stationId,
                                      Integer targetStationId,
                                      Integer palletSize,
                                      Double pathLenFactor) {
        return getCommand(commandType, taskNo, stationId, targetStationId, palletSize);
    }

    default StationCommand getRunBlockRerouteCommand(Integer taskNo,
                                                     Integer stationId,
                                                     Integer targetStationId,
@@ -23,6 +32,14 @@
        return getCommand(StationCommandType.MOVE, taskNo, stationId, targetStationId, palletSize);
    }

    default StationCommand getRunBlockRerouteCommand(Integer taskNo,
                                                     Integer stationId,
                                                     Integer targetStationId,
                                                     Integer palletSize,
                                                     Double pathLenFactor) {
        return getCommand(StationCommandType.MOVE, taskNo, stationId, targetStationId, palletSize, pathLenFactor);
    }

    CommandResponse sendCommand(StationCommand command);

    CommandResponse sendOriginCommand(String address, short[] data);

 src/main/java/com/zy/core/thread/impl/ZyStationV3Thread.java

@@ -209,6 +209,16 @@

    @Override
    public StationCommand getCommand(StationCommandType commandType, Integer taskNo, Integer stationId, Integer targetStationId, Integer palletSize) {
        return getCommand(commandType, taskNo, stationId, targetStationId, palletSize, null);
    }

    @Override
    public StationCommand getCommand(StationCommandType commandType,
                                     Integer taskNo,
                                     Integer stationId,
                                     Integer targetStationId,
                                     Integer palletSize,
                                     Double pathLenFactor) {
        StationCommand stationCommand = new StationCommand();
        stationCommand.setTaskNo(taskNo);
        stationCommand.setStationId(stationId);
@@ -218,7 +228,7 @@

        if (commandType == StationCommandType.MOVE) {
            if (!stationId.equals(targetStationId)) {
                List<Integer> path = calcPathStationIds(stationId, targetStationId);
                List<Integer> path = calcPathStationIds(taskNo, stationId, targetStationId, pathLenFactor);
                if (path == null || path.isEmpty()) {
                    log.warn("输送线命令生成失败，路径为空，taskNo={}, stationId={}, targetStationId={}",
                            taskNo, stationId, targetStationId);
@@ -281,12 +291,15 @@
        return zyStationConnectDriver.readOriginCommand(address, length);
    }

    private List<Integer> calcPathStationIds(Integer startStationId, Integer targetStationId) {
    private List<Integer> calcPathStationIds(Integer taskNo,
                                             Integer startStationId,
                                             Integer targetStationId,
                                             Double pathLenFactor) {
        NavigateUtils navigateUtils = SpringUtils.getBean(NavigateUtils.class);
        if (navigateUtils == null) {
            return new ArrayList<>();
        }
        List<NavigateNode> nodes = navigateUtils.calcByStationId(startStationId, targetStationId);
        List<NavigateNode> nodes = navigateUtils.calcByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
        List<Integer> ids = new ArrayList<>();
        for (NavigateNode n : nodes) {
            JSONObject v = JSONObject.parseObject(n.getNodeValue());

 src/main/java/com/zy/core/thread/impl/ZyStationV4Thread.java

@@ -214,6 +214,16 @@

    @Override
    public StationCommand getCommand(StationCommandType commandType, Integer taskNo, Integer stationId, Integer targetStationId, Integer palletSize) {
        return getCommand(commandType, taskNo, stationId, targetStationId, palletSize, null);
    }

    @Override
    public StationCommand getCommand(StationCommandType commandType,
                                     Integer taskNo,
                                     Integer stationId,
                                     Integer targetStationId,
                                     Integer palletSize,
                                     Double pathLenFactor) {
        StationCommand stationCommand = new StationCommand();
        stationCommand.setTaskNo(taskNo);
        stationCommand.setStationId(stationId);
@@ -223,7 +233,7 @@

        if (commandType == StationCommandType.MOVE) {
            if (!stationId.equals(targetStationId)) {
                List<NavigateNode> nodes = calcPathNavigateNodes(stationId, targetStationId);
                List<NavigateNode> nodes = calcPathNavigateNodes(taskNo, stationId, targetStationId, pathLenFactor);
                List<Integer> path = new ArrayList<>();
                List<Integer> liftTransferPath = new ArrayList<>();
                for (NavigateNode n : nodes) {
@@ -303,12 +313,15 @@
        return zyStationConnectDriver.readOriginCommand(address, length);
    }

    private List<NavigateNode> calcPathNavigateNodes(Integer startStationId, Integer targetStationId) {
    private List<NavigateNode> calcPathNavigateNodes(Integer taskNo,
                                                     Integer startStationId,
                                                     Integer targetStationId,
                                                     Double pathLenFactor) {
        NavigateUtils navigateUtils = SpringUtils.getBean(NavigateUtils.class);
        if (navigateUtils == null) {
            return new ArrayList<>();
        }
        return navigateUtils.calcByStationId(startStationId, targetStationId);
        return navigateUtils.calcByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
    }

    private void executeMoveWithSeg(StationCommand original) {

 src/main/java/com/zy/core/thread/impl/ZyStationV5Thread.java

@@ -238,6 +238,16 @@
                                     Integer stationId,
                                     Integer targetStationId,
                                     Integer palletSize) {
        return getCommand(commandType, taskNo, stationId, targetStationId, palletSize, null);
    }

    @Override
    public StationCommand getCommand(StationCommandType commandType,
                                     Integer taskNo,
                                     Integer stationId,
                                     Integer targetStationId,
                                     Integer palletSize,
                                     Double pathLenFactor) {
        StationCommand stationCommand = new StationCommand();
        stationCommand.setTaskNo(taskNo);
        stationCommand.setStationId(stationId);
@@ -246,7 +256,7 @@
        stationCommand.setCommandType(commandType);

        if (commandType == StationCommandType.MOVE && !stationId.equals(targetStationId)) {
            List<NavigateNode> nodes = calcPathNavigateNodes(taskNo, stationId, targetStationId);
            List<NavigateNode> nodes = calcPathNavigateNodes(taskNo, stationId, targetStationId, pathLenFactor);
            return fillMoveCommandPath(stationCommand, nodes, taskNo, stationId, targetStationId);
        }
        return stationCommand;
@@ -257,11 +267,20 @@
                                                                 Integer stationId,
                                                                 Integer targetStationId,
                                                                 Integer palletSize) {
        return getRunBlockRerouteCommand(taskNo, stationId, targetStationId, palletSize, null);
    }

    @Override
    public synchronized StationCommand getRunBlockRerouteCommand(Integer taskNo,
                                                                 Integer stationId,
                                                                 Integer targetStationId,
                                                                 Integer palletSize,
                                                                 Double pathLenFactor) {
        if (taskNo == null || taskNo <= 0 || stationId == null || targetStationId == null) {
            return null;
        }
        if (Objects.equals(stationId, targetStationId)) {
            return getCommand(StationCommandType.MOVE, taskNo, stationId, targetStationId, palletSize);
            return getCommand(StationCommandType.MOVE, taskNo, stationId, targetStationId, palletSize, pathLenFactor);
        }

        RunBlockRerouteState rerouteState = loadRunBlockRerouteState(taskNo, stationId);
@@ -281,7 +300,7 @@
        rerouteState.setPlanCount((rerouteState.getPlanCount() == null ? 0 : rerouteState.getPlanCount()) + 1);
        rerouteState.setLastPlanTime(System.currentTimeMillis());

        List<List<NavigateNode>> candidatePathList = calcCandidatePathNavigateNodes(taskNo, stationId, targetStationId);
        List<List<NavigateNode>> candidatePathList = calcCandidatePathNavigateNodes(taskNo, stationId, targetStationId, pathLenFactor);
        if (candidatePathList.isEmpty()) {
            saveRunBlockRerouteState(rerouteState);
            log.warn("输送线堵塞重规划失败，候选路径为空，taskNo={}, planCount={}, stationId={}, targetStationId={}",
@@ -384,22 +403,26 @@
        return zyStationConnectDriver.readOriginCommand(address, length);
    }

    private List<NavigateNode> calcPathNavigateNodes(Integer taskNo, Integer startStationId, Integer targetStationId) {
    private List<NavigateNode> calcPathNavigateNodes(Integer taskNo,
                                                     Integer startStationId,
                                                     Integer targetStationId,
                                                     Double pathLenFactor) {
        NavigateUtils navigateUtils = SpringUtils.getBean(NavigateUtils.class);
        if (navigateUtils == null) {
            return new ArrayList<>();
        }
        return navigateUtils.calcByStationId(startStationId, targetStationId, taskNo);
        return navigateUtils.calcByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
    }

    private List<List<NavigateNode>> calcCandidatePathNavigateNodes(Integer taskNo,
                                                                    Integer startStationId,
                                                                    Integer targetStationId) {
                                                                    Integer targetStationId,
                                                                    Double pathLenFactor) {
        NavigateUtils navigateUtils = SpringUtils.getBean(NavigateUtils.class);
        if (navigateUtils == null) {
            return new ArrayList<>();
        }
        return navigateUtils.calcCandidatePathByStationId(startStationId, targetStationId, taskNo);
        return navigateUtils.calcCandidatePathByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
    }

    private StationCommand buildMoveCommand(Integer taskNo,

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

@@ -207,10 +207,12 @@
                        && stationProtocol.isLoading()
                        && stationProtocol.getTaskNo() == 0
                ) {
                    Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
                    OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
                            stationProtocol.getStationId(),
                            wrkMast,
                            outOrderList
                            outOrderList,
                            pathLenFactor
                    );
                    Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
                    if (moveStaNo == null) {
@@ -218,13 +220,19 @@
                    }

                    DispatchLimitConfig limitConfig = getDispatchLimitConfig(stationProtocol.getStationId(), moveStaNo);
                    LoopHitResult loopHitResult = findPathLoopHit(limitConfig, stationProtocol.getStationId(), moveStaNo, loadGuardState);
                    LoopHitResult loopHitResult = findPathLoopHit(limitConfig, stationProtocol.getStationId(), moveStaNo, loadGuardState, wrkMast, pathLenFactor);

                    if (isDispatchBlocked(limitConfig, currentStationTaskCountRef[0], loadGuardState, loopHitResult.isThroughLoop())) {
                        return;
                    }

                    StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), moveStaNo, 0);
                    StationCommand command = buildOutboundMoveCommand(
                            stationThread,
                            wrkMast,
                            stationProtocol.getStationId(),
                            moveStaNo,
                            pathLenFactor
                    );
                    if (command == null) {
                        News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
                        continue;
@@ -285,7 +293,14 @@
                        && stationProtocol.isLoading()
                        && stationProtocol.getTaskNo() == 0
                ) {
                    StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), wrkMast.getStaNo(), 0);
                    Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
                    StationCommand command = buildOutboundMoveCommand(
                            stationThread,
                            wrkMast,
                            stationProtocol.getStationId(),
                            wrkMast.getStaNo(),
                            pathLenFactor
                    );
                    if (command == null) {
                        News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
                        continue;
@@ -522,10 +537,12 @@
                            }
                        } else {
                            //运行堵塞，重新计算路线
                            Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
                            OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
                                    stationProtocol.getStationId(),
                                    wrkMast,
                                    outOrderStationIds
                                    outOrderStationIds,
                                    pathLenFactor
                            );
                            Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
                            if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
@@ -536,7 +553,8 @@
                                    wrkMast.getWrkNo(),
                                    stationProtocol.getStationId(),
                                    moveStaNo,
                                    0
                                    0,
                                    pathLenFactor
                            );
                            if (command == null) {
                                News.taskInfo(wrkMast.getWrkNo(),
@@ -650,17 +668,25 @@
                    continue;
                }

                Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
                OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
                        stationProtocol.getStationId(),
                        wrkMast,
                        outOrderStationIds
                        outOrderStationIds,
                        pathLenFactor
                );
                Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
                if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
                    continue;
                }

                StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), moveStaNo, 0);
                StationCommand command = buildOutboundMoveCommand(
                        stationThread,
                        wrkMast,
                        stationProtocol.getStationId(),
                        moveStaNo,
                        pathLenFactor
                );
                if (command == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
                    continue;
@@ -718,17 +744,25 @@
                    continue;
                }

                Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
                OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
                        stationProtocol.getStationId(),
                        wrkMast,
                        outOrderList
                        outOrderList,
                        pathLenFactor
                );
                Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
                if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
                    continue;
                }

                StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), moveStaNo, 0);
                StationCommand command = buildOutboundMoveCommand(
                        stationThread,
                        wrkMast,
                        stationProtocol.getStationId(),
                        moveStaNo,
                        pathLenFactor
                );
                if (command == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
                    continue;
@@ -740,6 +774,90 @@
                MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
            }
        }
    }

    private 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)
        );
    }

    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 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));
    }

    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());
    }

    public List<Integer> getAllOutOrderList() {
@@ -754,7 +872,8 @@

    private OutOrderDispatchDecision resolveOutboundDispatchDecision(Integer currentStationId,
                                                                     WrkMast wrkMast,
                                                                     List<Integer> outOrderStationIds) {
                                                                     List<Integer> outOrderStationIds,
                                                                     Double pathLenFactor) {
        if (wrkMast == null || wrkMast.getStaNo() == null) {
            return null;
        }
@@ -762,15 +881,17 @@
            return new OutOrderDispatchDecision(wrkMast.getStaNo(), false);
        }
        Integer dispatchStationId = resolveDispatchOutOrderTarget(
                wrkMast,
                wrkMast.getSourceStaNo(),
                wrkMast.getStaNo(),
                outOrderStationIds
                outOrderStationIds,
                pathLenFactor
        );
        if (dispatchStationId == null) {
            return null;
        }
        if (isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds)) {
            return resolveCurrentOutOrderDispatchDecision(currentStationId, wrkMast, outOrderStationIds);
        if (isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds, pathLenFactor)) {
            return resolveCurrentOutOrderDispatchDecision(currentStationId, wrkMast, outOrderStationIds, pathLenFactor);
        }
        if (!Objects.equals(dispatchStationId, wrkMast.getStaNo())
                && isCurrentOutOrderStation(currentStationId, outOrderStationIds)
@@ -782,8 +903,9 @@

    private OutOrderDispatchDecision resolveCurrentOutOrderDispatchDecision(Integer currentStationId,
                                                                            WrkMast wrkMast,
                                                                            List<Integer> outOrderStationIds) {
        if (!isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds)) {
                                                                            List<Integer> outOrderStationIds,
                                                                            Double pathLenFactor) {
        if (!isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds, pathLenFactor)) {
            return null;
        }

@@ -809,7 +931,7 @@

        List<NavigateNode> initPath;
        try {
            initPath = navigateUtils.calcByStationId(wrkMast.getSourceStaNo(), wrkMast.getStaNo());
            initPath = calcOutboundNavigatePath(wrkMast, wrkMast.getSourceStaNo(), wrkMast.getStaNo(), pathLenFactor);
        } catch (Exception e) {
            News.taskInfo(wrkMast.getWrkNo(), "批次:{} 计算排序路径失败，当前站点={}", wrkMast.getBatch(), currentStationId);
            return null;
@@ -823,7 +945,7 @@
            toTarget = Integer.valueOf(seq + 1).equals(wrkMast.getBatchSeq());
        }
        if (toTarget) {
            if (hasReachableOutReleaseSlot(currentStationId, wrkMast.getStaNo())) {
            if (hasReachableOutReleaseSlot(wrkMast, currentStationId, wrkMast.getStaNo(), pathLenFactor)) {
                return new OutOrderDispatchDecision(wrkMast.getStaNo(), false);
            }
            StationTaskLoopService.LoopEvaluation loopEvaluation = evaluateOutOrderLoop(
@@ -832,9 +954,11 @@
                    outOrderStationIds
            );
            Integer circleTarget = resolveNextCircleOrderTarget(
                    wrkMast,
                    currentStationId,
                    outOrderStationIds,
                    loopEvaluation.getExpectedLoopIssueCount()
                    loopEvaluation.getExpectedLoopIssueCount(),
                    pathLenFactor
            );
            if (circleTarget == null) {
                News.taskInfo(wrkMast.getWrkNo(), "目标站当前不可进，且未找到可执行的下一排序检测点，当前站点={}", currentStationId);
@@ -849,9 +973,11 @@
                outOrderStationIds
        );
        Integer circleTarget = resolveNextCircleOrderTarget(
                wrkMast,
                currentStationId,
                outOrderStationIds,
                loopEvaluation.getExpectedLoopIssueCount()
                loopEvaluation.getExpectedLoopIssueCount(),
                pathLenFactor
        );
        if (circleTarget == null) {
            News.taskInfo(wrkMast.getWrkNo(), "未找到可执行的下一排序检测点，当前站点={}", currentStationId);
@@ -872,14 +998,17 @@

    private boolean isCurrentOutOrderDispatchStation(Integer currentStationId,
                                                     WrkMast wrkMast,
                                                     List<Integer> outOrderStationIds) {
                                                     List<Integer> outOrderStationIds,
                                                     Double pathLenFactor) {
        if (!shouldApplyOutOrder(wrkMast, outOrderStationIds) || currentStationId == null) {
            return false;
        }
        Integer dispatchStationId = resolveDispatchOutOrderTarget(
                wrkMast,
                wrkMast.getSourceStaNo(),
                wrkMast.getStaNo(),
                outOrderStationIds
                outOrderStationIds,
                pathLenFactor
        );
        return dispatchStationId != null
                && !Objects.equals(dispatchStationId, wrkMast.getStaNo())
@@ -935,9 +1064,11 @@
        );
    }

    private Integer resolveDispatchOutOrderTarget(Integer sourceStationId,
    private Integer resolveDispatchOutOrderTarget(WrkMast wrkMast,
                                                  Integer sourceStationId,
                                                  Integer finalTargetStationId,
                                                  List<Integer> outOrderList) {
                                                  List<Integer> outOrderList,
                                                  Double pathLenFactor) {
        if (finalTargetStationId == null) {
            return null;
        }
@@ -946,7 +1077,7 @@
        }

        try {
            List<NavigateNode> nodes = navigateUtils.calcByStationId(sourceStationId, finalTargetStationId);
            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) {
@@ -963,14 +1094,16 @@
        return finalTargetStationId;
    }

    private boolean hasReachableOutReleaseSlot(Integer currentStationId,
                                               Integer finalTargetStationId) {
    private boolean hasReachableOutReleaseSlot(WrkMast wrkMast,
                                               Integer currentStationId,
                                               Integer finalTargetStationId,
                                               Double pathLenFactor) {
        if (currentStationId == null || finalTargetStationId == null) {
            return true;
        }

        try {
            List<NavigateNode> nodes = navigateUtils.calcByStationId(currentStationId, finalTargetStationId);
            List<NavigateNode> nodes = calcOutboundNavigatePath(wrkMast, currentStationId, finalTargetStationId, pathLenFactor);
            if (nodes == null || nodes.isEmpty()) {
                return true;
            }
@@ -1016,9 +1149,11 @@
                || (stationProtocol.getTaskNo() != null && stationProtocol.getTaskNo() > 0);
    }

    private Integer resolveNextCircleOrderTarget(Integer currentStationId,
    private Integer resolveNextCircleOrderTarget(WrkMast wrkMast,
                                                 Integer currentStationId,
                                                 List<Integer> orderedOutStationList,
                                                 Integer expectedLoopIssueCount) {
                                                 Integer expectedLoopIssueCount,
                                                 Double pathLenFactor) {
        if (currentStationId == null || orderedOutStationList == null || orderedOutStationList.size() <= 1) {
            return null;
        }
@@ -1033,7 +1168,7 @@
                continue;
            }
            try {
                List<NavigateNode> path = navigateUtils.calcByStationId(currentStationId, candidateStationId);
                List<NavigateNode> path = calcOutboundNavigatePath(wrkMast, currentStationId, candidateStationId, pathLenFactor);
                if (path != null && !path.isEmpty()) {
                    candidateList.add(new CircleTargetCandidate(candidateStationId, path.size(), offset));
                }
@@ -1061,16 +1196,14 @@
                return Integer.compare(left.getOffset(), right.getOffset());
            }
        });
        return resolveGradualCircleTargetByPathLength(expectedLoopIssueCount, candidateList);
        return resolveGradualCircleTargetByPathLength(expectedLoopIssueCount, candidateList, pathLenFactor);
    }

    private Integer resolveGradualCircleTargetByPathLength(Integer expectedLoopIssueCount,
                                                           List<CircleTargetCandidate> candidateList) {
                                                           List<CircleTargetCandidate> candidateList,
                                                           Double pathLenFactor) {
        if (candidateList == null || candidateList.isEmpty()) {
            return null;
        }
        if (expectedLoopIssueCount == null || expectedLoopIssueCount <= 2) {
            return candidateList.get(0).getStationId();
        }

        List<CircleTargetCandidate> tierList = new ArrayList<>();
@@ -1087,7 +1220,11 @@
        if (tierList.isEmpty()) {
            return candidateList.get(0).getStationId();
        }
        int tierIndex = Math.min(expectedLoopIssueCount - 2, tierList.size() - 1);
        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();
    }

@@ -1165,10 +1302,11 @@
            return;
        }

        Double pathLenFactor = resolveOutboundPathLenFactor(wrkMast);
        OutOrderDispatchDecision dispatchDecision = null;
        Integer moveStaNo;
        if (Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)) {
            dispatchDecision = resolveOutboundDispatchDecision(stationProtocol.getStationId(), wrkMast, outOrderList);
            dispatchDecision = resolveOutboundDispatchDecision(stationProtocol.getStationId(), wrkMast, outOrderList, pathLenFactor);
            moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
        } else {
            moveStaNo = wrkMast.getStaNo();
@@ -1181,12 +1319,12 @@
        resetSegmentMoveCommandsBeforeReroute(stationProtocol.getTaskNo());
        int clearedCommandCount = clearIssuedMoveCommandsDuringIdleStay(idleTrack, stationProtocol.getTaskNo(), stationProtocol.getStationId());

        StationCommand command = stationThread.getCommand(
                StationCommandType.MOVE,
                wrkMast.getWrkNo(),
        StationCommand command = buildOutboundMoveCommand(
                stationThread,
                wrkMast,
                stationProtocol.getStationId(),
                moveStaNo,
                0
                pathLenFactor
        );
        if (command == null) {
            News.taskInfo(wrkMast.getWrkNo(), "站点任务停留超时后重算路径失败，当前站点={}，目标站点={}", stationProtocol.getStationId(), moveStaNo);
@@ -1465,6 +1603,15 @@
                                          Integer sourceStationId,
                                          Integer targetStationId,
                                          LoadGuardState loadGuardState) {
        return findPathLoopHit(config, sourceStationId, targetStationId, loadGuardState, null, null);
    }

    private LoopHitResult findPathLoopHit(DispatchLimitConfig config,
                                          Integer sourceStationId,
                                          Integer targetStationId,
                                          LoadGuardState loadGuardState,
                                          WrkMast wrkMast,
                                          Double pathLenFactor) {
        if (!config.loopModeEnable) {
            return LoopHitResult.NO_HIT;
        }
@@ -1476,7 +1623,9 @@
        }

        try {
            List<NavigateNode> nodes = navigateUtils.calcByStationId(sourceStationId, targetStationId);
            List<NavigateNode> nodes = wrkMast == null
                    ? navigateUtils.calcByStationId(sourceStationId, targetStationId)
                    : calcOutboundNavigatePath(wrkMast, sourceStationId, targetStationId, pathLenFactor);
            if (nodes == null || nodes.isEmpty()) {
                return LoopHitResult.NO_HIT;
            }
@@ -1520,6 +1669,16 @@
        return value;
    }

    private Double normalizePathLenFactor(Double pathLenFactor) {
        if (pathLenFactor == null || pathLenFactor < 0.0d) {
            return 0.0d;
        }
        if (pathLenFactor > 1.0d) {
            return 1.0d;
        }
        return pathLenFactor;
    }

    private static class OutOrderDispatchDecision {
        private final Integer targetStationId;
        private final boolean circle;