#预调度堆垛机2

Junjie

18 小时以前 d9b78fe9683a6d7c22a3ca511dd9b3212922fe54

 src/main/java/com/zy/asrs/task/InboundCrnMoveDispatchScheduler.java

@@ -9,8 +9,6 @@
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.Utils;
import com.zy.common.entity.FindCrnNoResult;
import com.zy.common.service.CommonService;
import com.zy.core.News;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
@@ -18,8 +16,6 @@
import com.zy.core.enums.WrkStsType;
import com.zy.core.model.StationObjModel;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.move.StationMoveCoordinator;
import com.zy.core.move.StationMoveSession;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.CrnOperateProcessUtils;
import org.springframework.scheduling.annotation.Scheduled;
@@ -28,106 +24,87 @@
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

@Component
public class InboundCrnMoveDispatchScheduler {

    private final WrkMastService wrkMastService;
    private final BasStationService basStationService;
    private final CommonService commonService;
    private final BasCrnpService basCrnpService;
    private final CrnOperateProcessUtils crnOperateProcessUtils;
    private final StationMoveCoordinator stationMoveCoordinator;

    public InboundCrnMoveDispatchScheduler(WrkMastService wrkMastService,
                                           BasStationService basStationService,
                                           CommonService commonService,
                                           BasCrnpService basCrnpService,
                                           CrnOperateProcessUtils crnOperateProcessUtils,
                                           StationMoveCoordinator stationMoveCoordinator) {
                                           CrnOperateProcessUtils crnOperateProcessUtils) {
        this.wrkMastService = wrkMastService;
        this.basStationService = basStationService;
        this.commonService = commonService;
        this.basCrnpService = basCrnpService;
        this.crnOperateProcessUtils = crnOperateProcessUtils;
        this.stationMoveCoordinator = stationMoveCoordinator;
    }

    @Scheduled(fixedDelay = 1000L)
    public void dispatchInboundCrnMove() {
        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("io_type", WrkIoType.IN.id)
                .eq("wrk_sts", WrkStsType.INBOUND_STATION_RUN.sts)
                .isNotNull("sta_no"));
        for (WrkMast wrkMast : wrkMasts) {
            if (wrkMast == null || wrkMast.getWrkNo() == null || wrkMast.getStaNo() == null || Cools.isEmpty(wrkMast.getLocNo())) {
        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<BasCrnp>()
                .orderByAsc("crn_no"));
        if (basCrnps == null || basCrnps.isEmpty()) {
            return;
        }

        for (BasCrnp basCrnp : basCrnps) {
            if (basCrnp == null || basCrnp.getCrnNo() == null) {
                continue;
            }
            Integer crnNo = basCrnp.getCrnNo();
            if (hasBlockingOutboundTask(crnNo)) {
                continue;
            }

            BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>()
                    .eq("station_id", wrkMast.getStaNo())
            WrkMast inboundWrkMast = wrkMastService.getOne(new QueryWrapper<WrkMast>()
                    .eq("io_type", WrkIoType.IN.id)
                    .eq("crn_no", crnNo)
                    .eq("wrk_sts", WrkStsType.INBOUND_STATION_RUN.sts)
                    .last("limit 1"));
            if (basStation == null || basStation.getDeviceNo() == null) {
            if (inboundWrkMast == null) {
                continue;
            }

            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
            if (stationThread == null) {
            StationProtocol targetStationProtocol = resolveTargetStationProtocol(inboundWrkMast.getStaNo());
            if (targetStationProtocol != null
                    && targetStationProtocol.getTaskNo() > 0) {
                continue;
            }

            Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
            StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(basStation.getStationId());
            tryDispatchInboundCrnMove(wrkMast, stationProtocol);
            String inboundPickupLocNo = resolveInboundPickupLocNo(basCrnp, inboundWrkMast.getStaNo());
            if (Cools.isEmpty(inboundPickupLocNo)) {
                continue;
            }

            boolean dispatched = crnOperateProcessUtils.dispatchCrnMove(crnNo, inboundPickupLocNo, true);
            if (dispatched) {
                News.info("已触发堆垛机直接移动到入库任务取货位等待，工作号={}，堆垛机号={}，取货位={}",
                        inboundWrkMast.getWrkNo(), crnNo, inboundPickupLocNo);
            }
        }
    }

    private void tryDispatchInboundCrnMove(WrkMast wrkMast, StationProtocol targetStationProtocol) {
        if (targetStationProtocol != null
                && targetStationProtocol.isLoading()
                && targetStationProtocol.getTaskNo() > 0
                && targetStationProtocol.isInEnable()) {
            return;
    private StationProtocol resolveTargetStationProtocol(Integer stationId) {
        if (stationId == null) {
            return null;
        }

        FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(wrkMast.getLocNo());
        if (findCrnNoResult == null || !Objects.equals(findCrnNoResult.getCrnType(), SlaveType.Crn) || findCrnNoResult.getCrnNo() == null) {
            return;
        }
        Integer crnNo = findCrnNoResult.getCrnNo();

        BasCrnp basCrnp = basCrnpService.getOne(new QueryWrapper<BasCrnp>()
                .eq("crn_no", crnNo)
        BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>()
                .eq("station_id", stationId)
                .last("limit 1"));
        if (basCrnp == null) {
            return;
        if (basStation == null || basStation.getDeviceNo() == null) {
            return null;
        }

        String inboundPickupLocNo = resolveInboundPickupLocNo(basCrnp, wrkMast.getStaNo());
        if (Cools.isEmpty(inboundPickupLocNo)) {
            return;
        StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
        if (stationThread == null) {
            return null;
        }

        // 同堆垛机没有未完成出库任务时，优先直接到当前入库任务取货位等待。
        if (!hasPendingOutboundTask(crnNo)) {
            boolean dispatched = crnOperateProcessUtils.dispatchCrnMove(crnNo, inboundPickupLocNo);
            if (dispatched) {
                News.info("检测到仅有入库任务，已触发堆垛机直接移动到入库任务取货位等待，工作号={}，堆垛机号={}，取货位={}",
                        wrkMast.getWrkNo(), crnNo, inboundPickupLocNo);
            }
            return;
        }

        StationMoveSession session = stationMoveCoordinator == null ? null : stationMoveCoordinator.loadSession(wrkMast.getWrkNo());
        if (!isInboundCrnMoveDispatchWindow(wrkMast, session)) {
            return;
        }

        boolean dispatched = crnOperateProcessUtils.dispatchCrnMove(crnNo, inboundPickupLocNo);
        if (dispatched) {
            News.info("入库任务即将到达取货位，已触发堆垛机预移车，工作号={}，堆垛机号={}，取货位={}",
                    wrkMast.getWrkNo(), crnNo, inboundPickupLocNo);
        }
        Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
        return statusMap == null ? null : statusMap.get(stationId);
    }

    private String resolveInboundPickupLocNo(BasCrnp basCrnp, Integer targetStationId) {
@@ -146,40 +123,48 @@
        return null;
    }

    private boolean hasPendingOutboundTask(Integer crnNo) {
    private boolean hasBlockingOutboundTask(Integer crnNo) {
        if (crnNo == null) {
            return false;
        }
        return wrkMastService.count(new QueryWrapper<WrkMast>()
        List<WrkMast> pendingOutboundTasks = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("crn_no", crnNo)
                .eq("io_type", WrkIoType.OUT.id)
                .in("wrk_sts",
                        WrkStsType.NEW_OUTBOUND.sts,
                        WrkStsType.OUTBOUND_RUN.sts,
                        WrkStsType.OUTBOUND_RUN_COMPLETE.sts,
                        WrkStsType.STATION_RUN.sts,
                        WrkStsType.STATION_RUN_COMPLETE.sts,
                        WrkStsType.OUTBOUND_MANUAL.sts)) > 0;
                        WrkStsType.OUTBOUND_RUN.sts)
                .orderByAsc("wrk_no"));
        if (pendingOutboundTasks == null || pendingOutboundTasks.isEmpty()) {
            return false;
        }

        // 非批次任务或缺少批次序号的任务仍按原逻辑处理，避免放宽到无法确认执行顺序的出库任务。
        boolean hasNonBatchTask = pendingOutboundTasks.stream().anyMatch(task -> !isBatchTaskWithSeq(task));
        if (hasNonBatchTask) {
            return true;
        }

        return pendingOutboundTasks.stream()
                .filter(this::isCrnMoveBlockingOutboundTask)
                .filter(this::isBatchTaskWithSeq)
                .filter(crnOperateProcessUtils::canOutboundTaskExecuteInCurrentBatchWindow)
                .findAny()
                .isPresent();
    }

    private boolean isInboundCrnMoveDispatchWindow(WrkMast wrkMast, StationMoveSession session) {
        if (wrkMast == null || session == null || !session.isActive() || wrkMast.getStaNo() == null) {
    private boolean isBatchTaskWithSeq(WrkMast wrkMast) {
        return wrkMast != null
                && Objects.equals(wrkMast.getIoType(), WrkIoType.OUT.id)
                && !Cools.isEmpty(wrkMast.getBatch())
                && wrkMast.getBatchSeq() != null;
    }

    private boolean isCrnMoveBlockingOutboundTask(WrkMast wrkMast) {
        if (wrkMast == null || wrkMast.getWrkSts() == null) {
            return false;
        }
        List<Integer> fullPathStationIds = session.getFullPathStationIds();
        Integer currentStationId = session.getCurrentStationId();
        if (fullPathStationIds == null || fullPathStationIds.isEmpty() || currentStationId == null) {
            return false;
        }
        int currentIndex = fullPathStationIds.lastIndexOf(currentStationId);
        if (currentIndex < 0 || currentIndex >= fullPathStationIds.size() - 1) {
            return false;
        }
        int remainingStationCount = fullPathStationIds.size() - currentIndex - 1;
        if (remainingStationCount != 1) {
            return false;
        }
        Integer nextStationId = fullPathStationIds.get(currentIndex + 1);
        return Objects.equals(nextStationId, wrkMast.getStaNo());
        return Objects.equals(wrkMast.getWrkSts(), WrkStsType.NEW_OUTBOUND.sts)
                || Objects.equals(wrkMast.getWrkSts(), WrkStsType.OUTBOUND_RUN.sts)
                || Objects.equals(wrkMast.getWrkSts(), WrkStsType.OUTBOUND_MANUAL.sts);
    }
}