#堆垛机移动

Junjie

23 小时以前 5d5d6b55f439a9cb42d948e816a9db70e3fb2805

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

@@ -15,6 +15,7 @@
import com.zy.asrs.service.BasCrnpService;
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.WrkAnalysisService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.asrs.utils.Utils;
@@ -39,8 +40,11 @@
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

@Component
public class CrnOperateProcessUtils {
@@ -63,6 +67,10 @@
    private NotifyUtils notifyUtils;
    @Autowired
    private StationOperateProcessUtils stationOperateProcessUtils;
    @Autowired
    private WrkAnalysisService wrkAnalysisService;

    private static final String CRN_OUT_REQUIRE_STATION_OUT_ENABLE_CONFIG = "crnOutRequireStationOutEnable";

    public synchronized void crnIoExecute() {
        Object systemConfigMapObj = redisUtil.get(RedisKeyType.SYSTEM_CONFIG_MAP.key);
@@ -78,11 +86,16 @@

    //入出库  ===>>  堆垛机入出库作业下发
    public synchronized void crnIoExecuteNormal() {
        Set<Integer> crnMoveBlockedCrnNos = executeCrnMoveTask();

        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        Map<Integer, BasCrnp> dispatchCrnMap = new HashMap<>();
        Map<Integer, CrnThread> dispatchThreadMap = new HashMap<>();
        Map<Integer, CrnProtocol> dispatchProtocolMap = new HashMap<>();
        for (BasCrnp basCrnp : basCrnps) {
            if (basCrnp == null || basCrnp.getCrnNo() == null || crnMoveBlockedCrnNos.contains(basCrnp.getCrnNo())) {
                continue;
            }
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
            if (crnThread == null) {
                continue;
@@ -95,7 +108,7 @@

            long runningCount = wrkMastService.count(new QueryWrapper<WrkMast>()
                    .eq("crn_no", basCrnp.getCrnNo())
                    .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts));
                    .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts, WrkStsType.CRN_MOVE_RUN.sts));
            if (runningCount > 0) {
                continue;
            }
@@ -125,7 +138,7 @@
        List<WrkMast> taskQueue = wrkMastService.list(new QueryWrapper<WrkMast>()
                .in("crn_no", new ArrayList<>(dispatchCrnMap.keySet()))
                .in("wrk_sts",
                        WrkStsType.INBOUND_DEVICE_RUN.sts,
                        WrkStsType.INBOUND_STATION_RUN_COMPLETE.sts,
                        WrkStsType.NEW_OUTBOUND.sts,
                        WrkStsType.NEW_LOC_MOVE.sts));
        taskQueue.sort(Comparator
@@ -148,7 +161,7 @@
                continue;
            }

            if (wrkMast.getWrkSts() != null && wrkMast.getWrkSts() == WrkStsType.INBOUND_DEVICE_RUN.sts) {
            if (wrkMast.getWrkSts() != null && wrkMast.getWrkSts() == WrkStsType.INBOUND_STATION_RUN_COMPLETE.sts) {
                boolean result = this.crnExecuteInPlanner(basCrnp, crnThread, wrkMast);
                if (result) {
                    crnProtocol.setLastIo("O");
@@ -214,209 +227,6 @@
                && !Cools.isEmpty(wrkMast.getBatch());
    }

    private synchronized boolean crnExecuteIn(BasCrnp basCrnp, CrnThread crnThread) {
        CrnProtocol crnProtocol = crnThread.getStatus();
        if(crnProtocol == null){
            return false;
        }

        if(!basCrnp.getInEnable().equals("Y")){
            News.info("堆垛机:{} 可入信号不满足", basCrnp.getCrnNo());
            return false;
        }

        List<StationObjModel> inStationList = basCrnp.getInStationList$();
        if(inStationList.isEmpty()){
            News.info("堆垛机:{} 入库站点未设置", basCrnp.getCrnNo());
            return false;
        }

        Integer crnNo = basCrnp.getCrnNo();

        for (StationObjModel stationObjModel : inStationList) {
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
            if (stationThread == null) {
                continue;
            }

            Map<Integer, StationProtocol> stationProtocolMap = stationThread.getStatusMap();
            StationProtocol stationProtocol = stationProtocolMap.get(stationObjModel.getStationId());
            if (stationProtocol == null) {
                continue;
            }

            if (!stationProtocol.isAutoing()) {
                continue;
            }

            if (!stationProtocol.isLoading()) {
                continue;
            }

            if (stationProtocol.getTaskNo() <= 0) {
                continue;
            }

            if (!stationProtocol.isInEnable()) {
                News.taskInfo(stationProtocol.getTaskNo(), "取货站点:{} 没有可入信号", stationObjModel.getStationId());
                continue;
            }

            // 获取任务
            WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
            if (null == wrkMast) {
                News.taskInfo(stationProtocol.getTaskNo(), "工作号:{} 任务信息不存在", stationProtocol.getTaskNo());
                continue;
            }

            if (!wrkMast.getCrnNo().equals(basCrnp.getCrnNo())) {
                continue;
            }

            if(wrkMast.getWrkSts() != WrkStsType.INBOUND_DEVICE_RUN.sts){
                continue;
            }

            // 获取库位信息
            LocMast locMast = locMastService.getById(wrkMast.getLocNo());
            if (locMast == null) {
                News.taskInfo(wrkMast.getWrkNo(), "目标库位:{} 信息不存在", wrkMast.getLocNo());
                continue;
            }

            if (!locMast.getLocSts().equals("S")) {
                News.taskInfo(wrkMast.getWrkNo(), "目标库位:{} 状态异常", wrkMast.getLocNo());
                continue;
            }

            //检测浅库位状态
            boolean checkStatus = checkShallowLocStatus(locMast.getLocNo(), wrkMast.getWrkNo());
            if (!checkStatus) {
                News.taskInfo(wrkMast.getWrkNo(), "因浅库位堵塞无法执行");
                continue;
            }

            String sourceLocNo = Utils.getLocNo(stationObjModel.getDeviceRow(), stationObjModel.getDeviceBay(), stationObjModel.getDeviceLev());

            CrnCommand command = crnThread.getPickAndPutCommand(sourceLocNo, wrkMast.getLocNo(), wrkMast.getWrkNo(), crnNo);

            wrkMast.setWrkSts(WrkStsType.INBOUND_RUN.sts);
            wrkMast.setCrnNo(crnNo);
            wrkMast.setSystemMsg("");
            wrkMast.setIoTime(new Date());
            if (wrkMastService.updateById(wrkMast)) {
                MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, command));
                notifyUtils.notify(String.valueOf(SlaveType.Crn), crnNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_IN_TASK_RUN, null);
                News.info("堆垛机命令下发成功，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(command));
                return true;
            }
        }
        return false;
    }

    private synchronized boolean crnExecuteOut(BasCrnp basCrnp, CrnThread crnThread) {
        CrnProtocol crnProtocol = crnThread.getStatus();
        if(crnProtocol == null){
            return false;
        }

        if(!basCrnp.getOutEnable().equals("Y")){
            News.info("堆垛机:{} 可出信号不满足", basCrnp.getCrnNo());
            return false;
        }

        List<StationObjModel> outStationList = basCrnp.getOutStationList$();
        if(outStationList.isEmpty()){
            News.info("堆垛机:{} 出库站点未设置", basCrnp.getCrnNo());
            return false;
        }

        if (isOutboundStationTaskLimitReached()) {
            return false;
        }

        Integer crnNo = basCrnp.getCrnNo();

        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("crn_no", crnNo)
                .eq("wrk_sts", WrkStsType.NEW_OUTBOUND.sts)
                .orderBy(true, true, "batch_seq")
        );

        for (WrkMast wrkMast : wrkMasts) {
            if (isOutboundTargetStationTaskLimitReached(wrkMast)) {
                continue;
            }
            if (!allowBatchOutboundExecute(wrkMast)) {
                continue;
            }
            for (StationObjModel stationObjModel : outStationList) {
                StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
                if (stationThread == null) {
                    continue;
                }

                Map<Integer, StationProtocol> stationProtocolMap = stationThread.getStatusMap();
                StationProtocol stationProtocol = stationProtocolMap.get(stationObjModel.getStationId());
                if (stationProtocol == null) {
                    continue;
                }

                if (!stationProtocol.isAutoing()) {
                    continue;
                }

                if (stationProtocol.isLoading()) {
                    continue;
                }

                if (stationProtocol.getTaskNo() != 0) {
                    continue;
                }

                if (!stationProtocol.isOutEnable()) {
                    News.info("放货站点:{} 没有可出信号", stationObjModel.getStationId());
                    continue;
                }

                // 获取库位信息
                LocMast locMast = locMastService.getById(wrkMast.getSourceLocNo());
                if (locMast == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "源库位:{} 信息不存在", wrkMast.getSourceLocNo());
                    continue;
                }

                if (!locMast.getLocSts().equals("R")) {
                    News.taskInfo(wrkMast.getWrkNo(), "源库位:{} 状态异常", wrkMast.getSourceLocNo());
                    continue;
                }

                //检测浅库位状态
                boolean checkStatus = checkShallowLocStatus(locMast.getLocNo(), wrkMast.getWrkNo());
                if (!checkStatus) {
                    News.taskInfo(wrkMast.getWrkNo(), "因浅库位堵塞无法执行");
                    continue;
                }

                String targetLocNo = Utils.getLocNo(stationObjModel.getDeviceRow(), stationObjModel.getDeviceBay(), stationObjModel.getDeviceLev());

                CrnCommand command = crnThread.getPickAndPutCommand(wrkMast.getSourceLocNo(), targetLocNo, wrkMast.getWrkNo(), crnNo);

                wrkMast.setWrkSts(WrkStsType.OUTBOUND_RUN.sts);
                wrkMast.setCrnNo(crnNo);
                wrkMast.setSystemMsg("");
                wrkMast.setIoTime(new Date());
                if (wrkMastService.updateById(wrkMast)) {
                    MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, command));
                    notifyUtils.notify(String.valueOf(SlaveType.Crn), crnNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_OUT_TASK_RUN, null);
                    News.info("堆垛机命令下发成功，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(command));
                    return true;
                }
            }
        }
        return false;
    }

    private synchronized boolean crnExecuteInPlanner(BasCrnp basCrnp, CrnThread crnThread, WrkMast wrkMast) {
        CrnProtocol crnProtocol = crnThread.getStatus();
        if (crnProtocol == null) {
@@ -469,7 +279,7 @@
                continue;
            }

            if (wrkMast.getWrkSts() != WrkStsType.INBOUND_DEVICE_RUN.sts) {
            if (wrkMast.getWrkSts() != WrkStsType.INBOUND_STATION_RUN_COMPLETE.sts) {
                continue;
            }

@@ -496,11 +306,14 @@

            CrnCommand command = crnThread.getPickAndPutCommand(sourceLocNo, wrkMast.getLocNo(), wrkMast.getWrkNo(), crnNo);

            Date now = new Date();
            wrkMast.setWrkSts(WrkStsType.INBOUND_RUN.sts);
            wrkMast.setCrnNo(crnNo);
            wrkMast.setSystemMsg("");
            wrkMast.setIoTime(new Date());
            wrkMast.setIoTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                wrkAnalysisService.markCraneStart(wrkMast, now);
                MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, command));
                notifyUtils.notify(String.valueOf(SlaveType.Crn), crnNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_IN_TASK_RUN, null);
                News.info("堆垛机命令下发成功，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(command));
@@ -565,8 +378,8 @@
                continue;
            }

            if (!stationProtocol.isOutEnable()) {
                News.info("放货站点:{} 没有可出信号", stationObjModel.getStationId());
            if (isRequireOutboundStationOutEnable() && !stationProtocol.isOutEnable()) {
                News.taskInfo(wrkMast.getWrkNo(), "放货站点:{} 没有可出信号", stationObjModel.getStationId());
                continue;
            }

@@ -593,11 +406,14 @@

            CrnCommand command = crnThread.getPickAndPutCommand(wrkMast.getSourceLocNo(), targetLocNo, wrkMast.getWrkNo(), crnNo);

            Date now = new Date();
            wrkMast.setWrkSts(WrkStsType.OUTBOUND_RUN.sts);
            wrkMast.setCrnNo(crnNo);
            wrkMast.setSystemMsg("");
            wrkMast.setIoTime(new Date());
            wrkMast.setIoTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                wrkAnalysisService.markCraneStart(wrkMast, now);
                MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, command));
                notifyUtils.notify(String.valueOf(SlaveType.Crn), crnNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_OUT_TASK_RUN, null);
                News.info("堆垛机命令下发成功，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(command));
@@ -645,6 +461,24 @@
            return true;
        }

        List<WrkMast> unfinishedBatchWrkMasts = listUnfinishedBatchWrkMasts(wrkMast.getBatch());
        if (hasMissingBatchSeq(unfinishedBatchWrkMasts)) {
            News.taskInfo(wrkMast.getWrkNo(), "批次:{} 存在未配置批次序号的未完成任务，暂不允许堆垛机出库", wrkMast.getBatch());
            return false;
        }

        if (!isWithinBatchExecuteWindow(wrkMast, unfinishedBatchWrkMasts, batchRunningLimit)) {
            Integer windowStartSeq = unfinishedBatchWrkMasts.get(0).getBatchSeq();
            Integer windowEndSeq = unfinishedBatchWrkMasts.get(Math.min(batchRunningLimit, unfinishedBatchWrkMasts.size()) - 1).getBatchSeq();
            News.taskInfo(wrkMast.getWrkNo(),
                    "批次:{} 当前严格执行窗口序号为[{}-{}]，当前序号={}，暂不允许堆垛机出库",
                    wrkMast.getBatch(),
                    windowStartSeq,
                    windowEndSeq,
                    wrkMast.getBatchSeq());
            return false;
        }

        long batchRunningCount = wrkMastService.count(new QueryWrapper<WrkMast>()
                .eq("io_type", WrkIoType.OUT.id)
                .eq("batch", wrkMast.getBatch())
@@ -658,6 +492,46 @@
        }

        return true;
    }

    private List<WrkMast> listUnfinishedBatchWrkMasts(String batch) {
        if (Cools.isEmpty(batch)) {
            return new ArrayList<>();
        }
        return wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("io_type", WrkIoType.OUT.id)
                .eq("batch", batch)
                .notIn("wrk_sts",
                        WrkStsType.COMPLETE_OUTBOUND.sts,
                        WrkStsType.SETTLE_OUTBOUND.sts)
                .orderByAsc("batch_seq")
                .orderByAsc("wrk_no"));
    }

    private boolean hasMissingBatchSeq(List<WrkMast> wrkMasts) {
        if (wrkMasts == null || wrkMasts.isEmpty()) {
            return false;
        }
        for (WrkMast item : wrkMasts) {
            if (item == null || Cools.isEmpty(item.getBatchSeq())) {
                return true;
            }
        }
        return false;
    }

    private boolean isWithinBatchExecuteWindow(WrkMast wrkMast, List<WrkMast> unfinishedBatchWrkMasts, int batchRunningLimit) {
        if (wrkMast == null || unfinishedBatchWrkMasts == null || unfinishedBatchWrkMasts.isEmpty()) {
            return true;
        }
        int windowSize = Math.min(batchRunningLimit, unfinishedBatchWrkMasts.size());
        for (int i = 0; i < windowSize; i++) {
            WrkMast current = unfinishedBatchWrkMasts.get(i);
            if (current != null && wrkMast.getWrkNo().equals(current.getWrkNo())) {
                return true;
            }
        }
        return false;
    }

    private boolean isOutboundStationTaskLimitReached() {
@@ -707,58 +581,30 @@
        }
    }

    private synchronized boolean crnExecuteLocTransfer(BasCrnp basCrnp, CrnThread crnThread) {
        CrnProtocol crnProtocol = crnThread.getStatus();
        if(crnProtocol == null){
            return false;
    private boolean isRequireOutboundStationOutEnable() {
        return getSystemConfigBoolean(CRN_OUT_REQUIRE_STATION_OUT_ENABLE_CONFIG, true);
    }

    private boolean getSystemConfigBoolean(String code, boolean defaultValue) {
        Object systemConfigMapObj = redisUtil.get(RedisKeyType.SYSTEM_CONFIG_MAP.key);
        if (!(systemConfigMapObj instanceof Map)) {
            return defaultValue;
        }

        Integer crnNo = basCrnp.getCrnNo();

        List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("crn_no", crnNo)
                .eq("wrk_sts", WrkStsType.NEW_LOC_MOVE.sts)
        );

        for (WrkMast wrkMast : wrkMasts) {
            // 获取源库位信息
            LocMast sourceLocMast = locMastService.getById(wrkMast.getSourceLocNo());
            if (sourceLocMast == null) {
                News.taskInfo(wrkMast.getWrkNo(), "源库位:{} 信息不存在", wrkMast.getSourceLocNo());
                continue;
        try {
            Object value = ((Map<?, ?>) systemConfigMapObj).get(code);
            if (value == null) {
                return defaultValue;
            }

            if(!sourceLocMast.getLocSts().equals("R")){
                News.taskInfo(wrkMast.getWrkNo(), "源库位:{} 状态异常，不属于出库预约状态", wrkMast.getSourceLocNo());
                continue;
            }
            
            // 获取库位信息
            LocMast locMast = locMastService.getById(wrkMast.getLocNo());
            if (locMast == null) {
                News.taskInfo(wrkMast.getWrkNo(), "库位:{} 信息不存在", wrkMast.getLocNo());
                continue;
            }

            if (!locMast.getLocSts().equals("S")) {
                News.taskInfo(wrkMast.getWrkNo(), "库位:{} 状态异常，不属于入库预约状态", wrkMast.getLocNo());
                continue;
            }

            CrnCommand command = crnThread.getPickAndPutCommand(wrkMast.getSourceLocNo(), wrkMast.getLocNo(), wrkMast.getWrkNo(), crnNo);

            wrkMast.setWrkSts(WrkStsType.LOC_MOVE_RUN.sts);
            wrkMast.setCrnNo(crnNo);
            wrkMast.setSystemMsg("");
            wrkMast.setIoTime(new Date());
            if (wrkMastService.updateById(wrkMast)) {
                MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, command));
                notifyUtils.notify(String.valueOf(SlaveType.Crn), crnNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_TRANSFER_TASK_RUN, null);
                News.info("堆垛机命令下发成功，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(command));
            String text = String.valueOf(value).trim();
            if ("Y".equalsIgnoreCase(text) || "true".equalsIgnoreCase(text) || "1".equals(text)) {
                return true;
            }
            if ("N".equalsIgnoreCase(text) || "false".equalsIgnoreCase(text) || "0".equals(text)) {
                return false;
            }
        } catch (Exception ignore) {
        }
        return false;
        return defaultValue;
    }

    //堆垛机任务执行完成
@@ -792,6 +638,7 @@
                }

                Long updateWrkSts = null;
                Date now = new Date();
                if(wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts){
                    updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
                    notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_IN_TASK_COMPLETE, null);
@@ -816,6 +663,8 @@
                }else if(wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts){
                    updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
                    notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_TRANSFER_TASK_COMPLETE, null);
                }else if(wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts){
                    updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
                }else{
                    News.error("堆垛机处于等待确认且任务完成状态，但工作状态异常。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
                    continue;
@@ -823,8 +672,10 @@

                wrkMast.setWrkSts(updateWrkSts);
                wrkMast.setSystemMsg("");
                wrkMast.setIoTime(new Date());
                wrkMast.setIoTime(now);
                wrkMast.setModiTime(now);
                if (wrkMastService.updateById(wrkMast)) {
                    wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
                    CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
                    MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
                    News.info("堆垛机任务状态更新成功，堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
@@ -836,9 +687,14 @@
    }

    public synchronized void plannerExecute() {
        Set<Integer> crnMoveBlockedCrnNos = executeCrnMoveTask();

        int nowSec = (int) (System.currentTimeMillis() / 1000);
        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        for (BasCrnp basCrnp : basCrnps) {
            if (basCrnp == null || basCrnp.getCrnNo() == null || crnMoveBlockedCrnNos.contains(basCrnp.getCrnNo())) {
                continue;
            }
            String key = RedisKeyType.PLANNER_SCHEDULE.key + "CRN-" + basCrnp.getCrnNo();
            List<Object> items = redisUtil.lGet(key, 0, -1);
            if (items == null || items.isEmpty()) {
@@ -855,7 +711,7 @@
            }
            List<WrkMast> running = wrkMastService.list(new QueryWrapper<WrkMast>()
                    .eq("crn_no", basCrnp.getCrnNo())
                    .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts)
                    .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts, WrkStsType.CRN_MOVE_RUN.sts)
            );
            if (!running.isEmpty()) {
                continue;
@@ -970,17 +826,128 @@

        CrnCommand command = crnThread.getPickAndPutCommand(wrkMast.getSourceLocNo(), wrkMast.getLocNo(), wrkMast.getWrkNo(), crnNo);

        Date now = new Date();
        wrkMast.setWrkSts(WrkStsType.LOC_MOVE_RUN.sts);
        wrkMast.setCrnNo(crnNo);
        wrkMast.setSystemMsg("");
        wrkMast.setIoTime(new Date());
        wrkMast.setIoTime(now);
        wrkMast.setModiTime(now);
        if (wrkMastService.updateById(wrkMast)) {
            wrkAnalysisService.markCraneStart(wrkMast, now);
            MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, command));
            notifyUtils.notify(String.valueOf(SlaveType.Crn), crnNo, String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_TRANSFER_TASK_RUN, null);
            News.info("堆垛机命令下发成功，堆垛机号={}，任务数据={}", crnNo, JSON.toJSON(command));
            return true;
        }
        return false;
    }

    private Set<Integer> executeCrnMoveTask() {
        List<WrkMast> pendingTaskQueue = wrkMastService.list(new QueryWrapper<WrkMast>()
                .eq("io_type", WrkIoType.CRN_MOVE.id)
                .eq("wrk_sts", WrkStsType.NEW_CRN_MOVE.sts)
                .orderByAsc("appe_time")
                .orderByAsc("wrk_no"));
        Set<Integer> blockedCrnNoSet = new HashSet<>();
        for (WrkMast wrkMast : pendingTaskQueue) {
            if (wrkMast != null && wrkMast.getCrnNo() != null) {
                blockedCrnNoSet.add(wrkMast.getCrnNo());
            }
        }
        if (blockedCrnNoSet.isEmpty()) {
            return blockedCrnNoSet;
        }

        List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
        Map<Integer, CrnThread> dispatchThreadMap = new HashMap<>();
        Map<Integer, CrnProtocol> dispatchProtocolMap = new HashMap<>();
        for (BasCrnp basCrnp : basCrnps) {
            if (basCrnp == null || basCrnp.getCrnNo() == null) {
                continue;
            }

            Integer crnNo = basCrnp.getCrnNo();
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
            if (crnThread == null) {
                continue;
            }

            CrnProtocol crnProtocol = crnThread.getStatus();
            if (crnProtocol == null) {
                continue;
            }

            long runningCount = wrkMastService.count(new QueryWrapper<WrkMast>()
                    .eq("crn_no", crnNo)
                    .in("wrk_sts",
                            WrkStsType.INBOUND_RUN.sts,
                            WrkStsType.OUTBOUND_RUN.sts,
                            WrkStsType.LOC_MOVE_RUN.sts,
                            WrkStsType.CRN_MOVE_RUN.sts));
            if (runningCount > 0) {
                continue;
            }

            if (!Objects.equals(crnProtocol.getMode(), CrnModeType.AUTO.id)
                    || !Objects.equals(crnProtocol.getTaskNo(), 0)
                    || !Objects.equals(crnProtocol.getStatus(), CrnStatusType.IDLE.id)
                    || !Objects.equals(crnProtocol.getLoaded(), 0)
                    || !Objects.equals(crnProtocol.getForkPos(), 0)
                    || !Objects.equals(crnProtocol.getAlarm(), 0)) {
                continue;
            }

            Object clearLock = redisUtil.get(RedisKeyType.CLEAR_CRN_TASK_LIMIT.key + crnNo);
            if (clearLock != null) {
                continue;
            }

            dispatchThreadMap.put(crnNo, crnThread);
            dispatchProtocolMap.put(crnNo, crnProtocol);
        }

        if (dispatchThreadMap.isEmpty()) {
            return blockedCrnNoSet;
        }

        List<WrkMast> taskQueue = wrkMastService.list(new QueryWrapper<WrkMast>()
                .in("crn_no", new ArrayList<>(dispatchThreadMap.keySet()))
                .eq("io_type", WrkIoType.CRN_MOVE.id)
                .eq("wrk_sts", WrkStsType.NEW_CRN_MOVE.sts)
                .orderByAsc("appe_time")
                .orderByAsc("wrk_no"));

        for (WrkMast wrkMast : taskQueue) {
            if (wrkMast == null || wrkMast.getCrnNo() == null || Cools.isEmpty(wrkMast.getLocNo())) {
                continue;
            }

            Integer crnNo = wrkMast.getCrnNo();
            CrnThread crnThread = dispatchThreadMap.get(crnNo);
            if (crnThread == null || dispatchProtocolMap.get(crnNo) == null) {
                continue;
            }

            CrnCommand moveCommand = crnThread.getMoveCommand(wrkMast.getLocNo(), wrkMast.getWrkNo(), crnNo);
            if (moveCommand == null) {
                continue;
            }

            Date now = new Date();
            wrkMast.setWrkSts(WrkStsType.CRN_MOVE_RUN.sts);
            wrkMast.setCrnNo(crnNo);
            wrkMast.setSystemMsg("");
            wrkMast.setIoTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                wrkAnalysisService.markCraneStart(wrkMast, now);
                MessageQueue.offer(SlaveType.Crn, crnNo, new Task(2, moveCommand));
                News.info("堆垛机移动命令下发成功，堆垛机号={}，工作号={}，目标位={}，任务数据={}",
                        crnNo, wrkMast.getWrkNo(), wrkMast.getLocNo(), JSON.toJSON(moveCommand));
                return blockedCrnNoSet;
            }
        }
        return blockedCrnNoSet;
    }

    //检测浅库位状态
@@ -1045,4 +1012,83 @@
        return false;
    }

    //调度堆垛机移动
    public synchronized boolean dispatchCrnMove(Integer crnNo, String targetLocNo) {
        if (crnNo == null || Cools.isEmpty(targetLocNo)) {
            return false;
        }

        int targetRow = Utils.getRow(targetLocNo);
        int targetBay = Utils.getBay(targetLocNo);
        int targetLev = Utils.getLev(targetLocNo);
        try {
            targetRow = Utils.getRow(targetLocNo);
            targetBay = Utils.getBay(targetLocNo);
            targetLev = Utils.getLev(targetLocNo);
        } catch (Exception e) {
            News.error("生成堆垛机移动任务失败，目标位:{} 解析异常", targetLocNo);
            return false;
        }

        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
        if (crnThread == null) {
            return false;
        }

        CrnProtocol crnProtocol = crnThread.getStatus();
        if (crnProtocol == null) {
            return false;
        }

        if (crnProtocol.getBay() == targetBay) {
            return false;
        }

        if (crnProtocol.getLevel() == targetLev) {
            return false;
        }

        long runningCount = wrkMastService.count(new QueryWrapper<WrkMast>()
                .eq("crn_no", crnNo)
                .in("wrk_sts",
                        WrkStsType.INBOUND_RUN.sts,
                        WrkStsType.OUTBOUND_RUN.sts,
                        WrkStsType.LOC_MOVE_RUN.sts,
                        WrkStsType.CRN_MOVE_RUN.sts));
        if (runningCount > 0) {
            News.info("堆垛机:{} 存在执行中的任务，暂不生成移动任务", crnNo);
            return false;
        }

        WrkMast activeTask = wrkMastService.getOne(new QueryWrapper<WrkMast>()
                .eq("crn_no", crnNo)
                .eq("io_type", WrkIoType.CRN_MOVE.id)
                .in("wrk_sts", WrkStsType.NEW_CRN_MOVE.sts, WrkStsType.CRN_MOVE_RUN.sts, WrkStsType.CRN_MOVE_MANUAL.sts)
                .orderByDesc("appe_time")
                .last("limit 1"));
        if (activeTask != null) {
            News.info("堆垛机:{} 已存在未完成移动任务，工作号={}", crnNo, activeTask.getWrkNo());
            return false;
        }

        Date now = new Date();
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(commonService.getWorkNo(WrkIoType.CRN_MOVE.id));
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(WrkStsType.NEW_CRN_MOVE.sts);
        wrkMast.setIoType(WrkIoType.CRN_MOVE.id);
        wrkMast.setIoPri(0D);
        wrkMast.setLocNo(targetLocNo);
        wrkMast.setCrnNo(crnNo);
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        wrkMast.setMemo("dispatchCrnMove");
        if (!wrkMastService.save(wrkMast)) {
            News.info("生成堆垛机移动任务失败，工作号={}，任务数据={}", wrkMast.getWrkNo(), JSON.toJSON(wrkMast));
            return false;
        }
        wrkAnalysisService.initForTask(wrkMast);
        return true;
    }

}