#

Junjie

2025-04-12 3be5c88fbc583d17a932ca937d8e293d28b5c974

#

 src/main/java/com/zy/asrs/domain/param/CreateInTaskParam.java

@@ -17,4 +17,6 @@
    //目标库位
    private String locNo;

    private String barcode;

}

 src/main/java/com/zy/asrs/entity/WrkMastLog.java

@@ -174,6 +174,9 @@
    @TableField(value = "system_msg")
    private String systemMsg;

    @ApiModelProperty(value= "")
    private Integer mainWrkNo;

    public WrkMastLog() {}

    public String getWrkSts$(){

 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java

@@ -13,6 +13,7 @@
import com.zy.common.service.CommonService;
import com.zy.common.utils.*;
import com.zy.core.News;
import com.zy.core.action.LiftAction;
import com.zy.core.action.ShuttleAction;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
@@ -22,11 +23,14 @@
import com.zy.core.model.LiftSlave;
import com.zy.core.model.ShuttleSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.LiftAssignCommand;
import com.zy.core.model.command.LiftCommand;
import com.zy.core.model.command.ShuttleAssignCommand;
import com.zy.core.model.command.ShuttleCommand;
import com.zy.core.model.protocol.*;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.*;
import com.zy.core.thread.impl.FyDevpThread;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
@@ -36,6 +40,7 @@
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 立体仓库WCS系统主流程业务
@@ -87,6 +92,8 @@
    private NoLiftInServiceImpl noLiftInService;
    @Autowired
    private NoLiftOutServiceImpl noLiftOutService;
    @Autowired
    private LiftAction liftAction;


    public static List<Integer> staNosIn = new ArrayList<Integer>() {{
@@ -449,7 +456,7 @@
            }

            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftSta.getLocNo());//调度小车到货物所在输送站点进行取货
                boolean result = shuttleDispatchUtils.searchDispatchShuttle(wrkMast.getWrkNo(), null, liftSta.getLocNo(), null);//调度小车到货物所在输送站点进行取货
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");
                return false;
            }
@@ -628,7 +635,7 @@
                        return false;
                    }
                }
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物所在库位进行取货
                boolean result = shuttleDispatchUtils.searchDispatchShuttle(wrkMast.getWrkNo(), null, wrkMast.getSourceLocNo(), null);//调度小车到货物所在库位进行取货
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车{}系统等待中。", wrkMast.getWrkNo(), result ? "成功" : "失败");
                return false;
            }
@@ -697,6 +704,390 @@
            }
            return false;
        }
        return true;
    }

    public synchronized void liftInExecute() {
        try {
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .in("wrk_sts", WrkStsType.NEW_INBOUND.sts, WrkStsType.INBOUND_DEVICE_RUN.sts, WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts)
                    .in("source_sta_no", 1012, 1022)
            );
            for (WrkMast wrkMast : wrkMasts) {
                boolean step0 = this.liftInExecuteStep0(wrkMast);//设备上走
                if (!step0) {
                    return;
                }

                boolean step1 = this.liftInExecuteStep1(wrkMast);//提升机搬运
                if (!step1) {
                    return;
                }

                boolean step2 = this.liftInExecuteStep2(wrkMast);//触发搬运任务
                if (!step2) {
                    return;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private boolean liftInExecuteStep0(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.NEW_INBOUND.sts) {
            FyDevpThread devpThread = (FyDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if(devpThread == null) {
                return false;
            }

            Map<Integer, StaProtocol> station = devpThread.getStation();
            StaProtocol staProtocol = station.get(wrkMast.getSourceStaNo());
            if (staProtocol == null) {
                return false;
            }

            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }

            if (!staProtocol.isLoading()) {
                News.info("{}任务，{}站点，无托盘", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }

            if (!staProtocol.getBarcode().equals(wrkMast.getBarcode())) {
                News.info("{}任务，{}站点，托盘码不匹配，站点托盘码：{}，任务托盘码：{}", wrkMast.getWrkNo(), staProtocol.getSiteId(), staProtocol.getBarcode(), wrkMast.getBarcode());
                return false;
            }

            short staNo = 1012;
            if (wrkMast.getSourceStaNo() == 1022) {
                staNo = 1023;
            }

            staProtocol = staProtocol.clone();
            staProtocol.setStaNo(staNo);
            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
            boolean result = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));

            wrkMast.setWrkSts(WrkStsType.INBOUND_DEVICE_RUN.sts);
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                return false;
            }
            return false;
        }

        return true;
    }

    private boolean liftInExecuteStep1(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_DEVICE_RUN.sts) {
            //获取提升机信息
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            if (liftThread == null) {
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                return false;
            }

            if (!liftThread.isIdle()) {
                return false;
            }

            //判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(liftProtocol.getLiftNo());
            if (liftWrkMast != null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            //判断提升机内是否有小车
            if (liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内有小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

            //判断提升机内是否有托盘
            if (liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

            FyDevpThread devpThread = (FyDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if(devpThread == null) {
                return false;
            }

            Map<Integer, StaProtocol> station = devpThread.getStation();

            Integer sourceStaNo = wrkMast.getSourceStaNo();
            if (wrkMast.getSourceStaNo() == 1022) {
                sourceStaNo = 1023;
            }

            StaProtocol staProtocol = station.get(sourceStaNo);
            if (staProtocol == null) {
                return false;
            }

            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }

            if (!staProtocol.isLoading()) {
                News.info("{}任务，{}站点，无托盘", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }

            if (staProtocol.getWorkNo().intValue() != wrkMast.getWrkNo()) {
                News.info("{}任务，{}站点，任务号不一致", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }

            if (!staProtocol.getBarcode().equals(wrkMast.getBarcode())) {
                News.info("{}任务，{}站点，托盘码不匹配，站点托盘码：{}，任务托盘码：{}", wrkMast.getWrkNo(), staProtocol.getSiteId(), staProtocol.getBarcode(), wrkMast.getBarcode());
                return false;
            }

            //获取提升机命令
            List<LiftCommand> liftCommands = liftThread.getPalletInCommand(wrkMast.getWrkNo(), wrkMast.getSourceStaNo(), 101);
            LiftCommand liftCommand = liftCommands.get(0);

            int deviceWrk = commonService.getWorkNo(8);//生成提升机设备工作号
            liftCommand.setTaskNo(deviceWrk);//更换随机任务号

            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo().shortValue());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.PALLET_IN.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN.sts);
            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                return false;
            }
            return false;
        }

        return true;
    }

    private boolean liftInExecuteStep2(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts) {
            //获取提升机信息
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            if (liftThread == null) {
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                return false;
            }

            if (!liftThread.isIdle()) {
                return false;
            }

            //判断提升机内是否有小车
            if (liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内有小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

            //判断提升机内是否有托盘
            if (!liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内无托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

            boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttle(wrkMast.getWrkNo(), "0200301", wrkMast.getLocNo(), "TRANSPORT_LIFT");
            if(!dispatchShuttle) {
                News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
                return false;
            }

            wrkMast.setWrkSts(WrkStsType.INBOUND_SHUTTLE_RUN.sts);
            wrkMast.setLiftNo(null);
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                return false;
            }
            return false;
        }

        return true;
    }

    public synchronized void liftOutExecute() {
        try {
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .in("wrk_sts", WrkStsType.NEW_OUTBOUND.sts, WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts)
                    .in("sta_no", 1011, 1021)
            );
            for (WrkMast wrkMast : wrkMasts) {
                boolean step1 = this.liftOutExecuteStep1(wrkMast);//触发搬运任务
                if (!step1) {
                    return;
                }

                boolean step2 = this.liftOutExecuteStep2(wrkMast);//提升机搬运
                if (!step2) {
                    return;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private boolean liftOutExecuteStep1(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.NEW_OUTBOUND.sts) {
            FyDevpThread devpThread = (FyDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if(devpThread == null) {
                return false;
            }

            Map<Integer, StaProtocol> station = devpThread.getStation();
            StaProtocol staProtocol = station.get(wrkMast.getStaNo());
            if (staProtocol == null) {
                return false;
            }

            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }

            if (!staProtocol.isOutEnable()) {
                News.info("{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }


            boolean dispatchShuttle = shuttleDispatchUtils.searchDispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), "0200301", "TRANSPORT_LIFT");
            if(!dispatchShuttle) {
                News.info("{}任务，调度小车失败", wrkMast.getWrkNo());
                return false;
            }

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN.sts);
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                return false;
            }
            return false;
        }
        return true;
    }

    private boolean liftOutExecuteStep2(WrkMast wrkMast) {
        Date now = new Date();
        if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts) {
            //获取提升机信息
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            if (liftThread == null) {
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                return false;
            }

            if (!liftThread.isIdle()) {
                return false;
            }

            //判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(liftProtocol.getLiftNo());
            if (liftWrkMast != null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            //判断提升机内是否有小车
            if (liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内有小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

            //判断提升机内是否有托盘
            if (!liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内无托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

            FyDevpThread devpThread = (FyDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if(devpThread == null) {
                return false;
            }

            Map<Integer, StaProtocol> station = devpThread.getStation();
            StaProtocol staProtocol = station.get(wrkMast.getStaNo());
            if (staProtocol == null) {
                return false;
            }

            if (!staProtocol.isAutoing()) {
                News.info("{}任务，{}站点，不在自动状态", wrkMast.getWrkNo(), staProtocol.getSiteId());
                return false;
            }

            Integer sourceLev = liftThread.getLevToStaNo(Utils.getLev(wrkMast.getSourceLocNo()));

            //获取提升机命令
            List<LiftCommand> liftCommands = liftThread.getPalletOutCommand(wrkMast.getWrkNo(), sourceLev, wrkMast.getStaNo());
            LiftCommand liftCommand = liftCommands.get(0);

            int deviceWrk = commonService.getWorkNo(8);//生成提升机设备工作号
            liftCommand.setTaskNo(deviceWrk);//更换随机任务号

            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo().shortValue());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.PALLET_OUT.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_LIFT_RUN.sts);
            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                return false;
            }
            return false;
        }

        return true;
    }

@@ -900,7 +1291,7 @@
        //小车移动至站点  501.生成移库任务 ==> 502.小车取货中
        if (wrkMast.getWrkSts() == WrkStsType.NEW_LOC_MOVE.sts) {
            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物点进行取货
                boolean result = shuttleDispatchUtils.searchDispatchShuttle(wrkMast.getWrkNo(), null, wrkMast.getSourceLocNo(), null);//调度小车到货物点进行取货
                News.info("{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");

                if (result) {

 src/main/java/com/zy/asrs/service/impl/TransportLiftOutServiceImpl.java

@@ -537,8 +537,10 @@
            //获取提升机待机位
            String liftStandByLocNo = liftThread.getLiftStandByLocNo(Utils.getLev(shuttleProtocol.getCurrentLocNo()), false);

            //去待机位
            String locNo = Utils.getLocNo(Utils.getRow(liftStandByLocNo) + 1, Utils.getBay(liftStandByLocNo) - 1, Utils.getLev(liftStandByLocNo));
            //获取小车到提升机待机行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftStandByLocNo, NavigationMapType.DFX.id, assignCommand, shuttleThread);
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), locNo, NavigationMapType.DFX.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;

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

@@ -203,9 +203,9 @@
            WrkMast main = wrkMastService.selectByWorkNo(wrkMast.getMainWrkNo());
            if (main != null) {
                if (main.getIoType() == WrkIoType.IN.id) {
                    main.setWrkSts(WrkStsType.INBOUND_SHUTTLE_RUN_COMPLETE.sts);
                    main.setWrkSts(WrkStsType.COMPLETE_INBOUND.sts);
                } else if (main.getIoType() == WrkIoType.OUT.id) {
                    main.setWrkSts(WrkStsType.OUTBOUND_LIFT_RUN_COMPLETE.sts);
                    main.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts);
                }
                main.setModiTime(new Date());
                if (wrkMastService.updateById(main)) {

 src/main/java/com/zy/common/service/CommonService.java

@@ -193,6 +193,7 @@
        wrkMast.setSourceStaNo(param.getSourceStaNo());//源站
        wrkMast.setStaNo(param.getStaNo());//目标站
        wrkMast.setWmsWrkNo(param.getTaskNo());
        wrkMast.setBarcode(param.getBarcode());
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);

 src/main/java/com/zy/core/MainProcess.java

@@ -44,16 +44,20 @@
                    //输送线
                    // 入库
                    mainService.generateInboundWrk();
                    mainService.generateInboundWrk2();
//                    mainService.generateInboundWrk2();
                    // 出库
                    mainService.stnToOutStn();

                    //初始化实时地图
                    mainService.initRealtimeBasMap();
                    // 入库  ===>>  四向穿梭车入库作业下发
                    mainService.shuttleInExecute();
                    // 出库  ===>>  四向穿梭车出库作业下发
                    mainService.shuttleOutExecute();
//                    // 入库  ===>>  四向穿梭车入库作业下发
//                    mainService.shuttleInExecute();
//                    // 出库  ===>>  四向穿梭车出库作业下发
//                    mainService.shuttleOutExecute();
                    //提升机入库任务
                    mainService.liftInExecute();
                    //提升机出库任务
                    mainService.liftOutExecute();
                    //四向穿梭车任务完成
                    mainService.shuttleFinished();
                    //执行移库任务

 src/main/java/com/zy/core/ServerBootstrap.java

@@ -58,6 +58,10 @@
        for (Slave shuttle : slaveProperties.getShuttle()) {
            MessageQueue.init(SlaveType.Shuttle, shuttle);
        }
        // 初始化输送线mq
        for (Slave devp : slaveProperties.getDevp()) {
            MessageQueue.init(SlaveType.Devp, devp);
        }
    }

    private void initThread() {

 src/main/java/com/zy/core/action/LiftAction.java

@@ -132,28 +132,17 @@
                    command.setComplete(true);
                }
            } else if (command.getMode() == LiftCommandModeType.PALLET_IN.id) {
//                //托盘入
//                Integer target = liftDispatcher.getLiftLevLogic(liftThread.getDevice().getId().intValue(), command.getTargetLev());
//                if (liftProtocol.getLev() == target) {
//                    command.setComplete(true);
//                }
//
//                //判断提升机托盘是否存在
//                if (!liftProtocol.getHasTray()) {
//                    return false;
//                }

                //判断提升机托盘是否存在
                if (!liftProtocol.getHasTray()) {
                    return false;
                }
                command.setComplete(true);
            } else if (command.getMode() == LiftCommandModeType.PALLET_OUT.id) {
//                //托盘出
//                Integer target = liftDispatcher.getLiftLevLogic(liftThread.getDevice().getId().intValue(), command.getTargetLev());
//                if (liftProtocol.getLev() == target) {
//                    command.setComplete(true);
//                }
//
//                //判断提升机托盘是否存在
//                if (liftProtocol.getHasTray()) {
//                    return false;
//                }
                //判断提升机托盘是否存在
                if (liftProtocol.getHasTray()) {
                    return false;
                }
                command.setComplete(true);
            } else if (command.getMode() == LiftCommandModeType.RESET.id) {
                //复位
                command.setComplete(true);

 src/main/java/com/zy/core/cache/MessageQueue.java

@@ -93,10 +93,6 @@
            case Lift:
                return LIFT_EXCHANGE.get(id).poll();
            case Devp:
                ConcurrentLinkedQueue<Task> tasks = DEVP_EXCHANGE.get(id);
                if (tasks == null) {
                    return null;
                }
                return DEVP_EXCHANGE.get(id).poll();
            case Led:
                ConcurrentLinkedQueue<Task> task2 = LED_EXCHANGE.get(id);

 src/main/java/com/zy/core/dispatcher/ShuttleDispatchUtils.java

@@ -68,7 +68,7 @@
    /**
     * 调度车辆
     */
    public boolean dispatchShuttle(Integer wrkNo, String locNo) {
    public boolean searchDispatchShuttle(Integer wrkNo, String sourceLocNo, String locNo, String flag) {
        ArrayList<ShuttleThread> sameLev = new ArrayList<>();//相同楼层的穿梭车
        ArrayList<ShuttleThread> diffLev = new ArrayList<>();//不同楼层的穿梭车

@@ -128,6 +128,11 @@
                Integer shuttleNo = shuttleProtocol.getShuttleNo();
                //当前穿梭车库位号
                String currentLocNo = shuttleProtocol.getCurrentLocNo();
                if (currentLocNo.equals(locNo)) {
                    sameShuttles.put(-1, shuttleThread);
                    continue;
                }

                //当前穿梭车线程到目标地点距离
                List<NavigateNode> currentShuttlePath = navigateUtils.calc(currentLocNo, locNo, NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleNo, Utils.getLev(currentLocNo)), null);//搜索空闲穿梭车，使用正常通道地图
                if (currentShuttlePath == null) {
@@ -143,7 +148,7 @@
                ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
                Integer shuttleNo = shuttleProtocol.getShuttleNo();
                //尝试调度小车
                boolean result = shuttleMoveGenerate(wrkNo, locNo, shuttleNo);
                boolean result = shuttleMoveGenerate(wrkNo, sourceLocNo, locNo, shuttleNo, flag, false);
                if (result) {
                    return true;//调度成功
                }
@@ -190,7 +195,7 @@
                    ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
                    Integer shuttleNo = shuttleProtocol.getShuttleNo();
                    //尝试调度小车
                    boolean result = shuttleMoveGenerate(wrkNo, locNo, shuttleNo);
                    boolean result = shuttleMoveGenerate(wrkNo, sourceLocNo, locNo, shuttleNo, flag, false);
                    if (result) {
                        return true;//调度成功
                    }
@@ -279,6 +284,11 @@
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        wrkMast.setMainWrkNo(mainWrkMast.getWrkNo());

        if ("TRANSPORT_LIFT".equals(flag)) {
            wrkMast.setMainWrkNo(wrkNo);
        }

        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            News.error("小车迁移 --- 保存工作档失败！ 穿梭车号：" + shuttleNo);

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

@@ -51,6 +51,8 @@

    List<NavigateNode> getLiftStaNodes(int lev);

    Integer getLevToStaNo(int lev);

    //***************获取命令*****************
    List<LiftCommand> getMoveCommand(Integer taskNo, Integer sourceLev, Integer targetLev, LiftCommandModeType mode);//提升机移动


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

@@ -227,50 +227,19 @@
        index += 1;

        short[] array = new short[2];
        array[0] = staProtocol.getWorkNo();
        array[1] = staProtocol.getStaNo();
        array[0] = staProtocol.getStaNo();
        array[1] = staProtocol.getWorkNo();

        String staNoAddress = "DB83." + (index * 8 + 4);
        String workNoAddress = "DB83." + (index * 8 + 6);
        OperateResult write1 = null;    // 工作号
        OperateResult write2 = null;     // 目标站

        //任务下发次数
        int writeCount = 0;
        do {
            write1 = siemensS7Net.Write(workNoAddress, array[0]);    // 工作号
            write2 = siemensS7Net.Write(staNoAddress, array[1]);
            if ((write1.IsSuccess && write2.IsSuccess)) {
                log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{},{}，写入次数={}", staProtocol.getSiteId(), JSON.toJSON(staProtocol.getWorkNo()), JSON.toJSON(staProtocol.getStaNo()), writeCount);
//                OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB82.14", (short) (staNos2.indexOf(siteId) * 26));
//                //OperateResultExOne<byte[]> readResult = siemensS7Net.Read(staNoAddress, (short) 8);
//                if (readResult.IsSuccess) {
//                    int workNo2 = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 2);     // 工作号
//                    int staNo2 = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 4);   // 目标站
//                    // int staNo2 = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 0);
//                    //int workNo2 = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 0);
//                    if (workNo == workNo2 && staNo == staNo2) {
//                        //任务命令写入成功
//                        log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{},{}，写入次数={}", siteId, JSON.toJSON(workNo), JSON.toJSON(staNo), writeCount);
//                        return true;
//                    } else {//返回结果是成功了，但是真实值不相同
//                        writeCount++;
//                        log.error("写入输送线命令后返回成功，但是读取任务值不一致。输送线plc编号={}，{},{}，写入次数={}", siteId, JSON.toJSON(workNo), JSON.toJSON(staNo), writeCount);
//                    }
//                } else {
//                    writeCount++;
//                    log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},{},写入次数={}", siteId, JSON.toJSON(workNo), JSON.toJSON(staNo), writeCount);
//                }
            } else {
                writeCount++;
            }
        } while (writeCount < 5);
//        StaProtocol staProtocol = station.get(siteId);
//        if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
//            staProtocol.setPakMk(true);
//        }
        OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(array)));
        log.error("写入输送线站点数据失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(array));
        OperateResult write1 = siemensS7Net.Write(staNoAddress, array);
        if (!write1.IsSuccess) {
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(array)));
            log.error("写入输送线站点数据失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(array));
            return;
        }
        OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据成功。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(array)));
        log.info("写入输送线站点数据成功。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(array));
    }

    /**

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

@@ -460,6 +460,11 @@
    }

    @Override
    public Integer getLevToStaNo(int lev) {
        return liftLevMap.get(lev);
    }

    @Override
    public List<LiftCommand> getMoveCommand(Integer taskNo, Integer sourceLev, Integer targetLev, LiftCommandModeType mode) {
        /**
         * 任务类型

 src/main/resources/mapper/WrkMastLogMapper.xml

@@ -27,6 +27,7 @@
        <result column="shuttle_no" property="shuttleNo" />
        <result column="wms_wrk_no" property="wmsWrkNo" />
        <result column="system_msg" property="systemMsg" />
        <result column="main_wrk_no" property="mainWrkNo" />
    </resultMap>

</mapper>

 src/main/resources/mapper/WrkMastMapper.xml

@@ -26,6 +26,7 @@
        <result column="lift_no" property="liftNo" />
        <result column="wms_wrk_no" property="wmsWrkNo" />
        <result column="system_msg" property="systemMsg" />
        <result column="main_wrk_no" property="mainWrkNo" />

    </resultMap>


 src/main/resources/sql/20250412151056.nb3

Binary files differ