解决提升机在本层，而没有锁提升机的问题

zc

2025-05-07 dc3483f84d517bfa2cbcc96a0c965f26d63aa3c3

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

@@ -5,7 +5,6 @@
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.NavigateNode;
import com.zy.common.model.enums.NavigationMapType;
import com.zy.common.service.CommonService;
import com.zy.common.utils.LiftUtils;
@@ -25,6 +24,8 @@
import com.zy.core.model.command.ShuttleCommand;
import com.zy.core.model.protocol.LiftProtocol;
import com.zy.core.model.protocol.ShuttleProtocol;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.thread.DevpThread;
import com.zy.core.thread.LiftThread;
import com.zy.core.thread.ShuttleThread;
import lombok.extern.slf4j.Slf4j;
@@ -63,15 +64,16 @@

    /**
     * 从没有提升机侧入库，有两种情况，一种入库到同层，一种入库到不同层，则需要提升机
     *
     * @param wrkMast
     */
    public void shuttleMoveExecute(WrkMast wrkMast) {
    public void shuttleMoveExecute(WrkMast wrkMast, Integer staNo, Integer lev) {
        boolean stepMoveSta = this.shuttleMoveExecuteTransportLiftStepCallShuttle(wrkMast);//小车迁移-呼叫小车至取货点
        if (!stepMoveSta) {
            return;
        }
        //判断目标库位是否在1层或5层
        if (Utils.getLev(wrkMast.getLocNo()) == 1 || Utils.getLev(wrkMast.getLocNo()) == 5) {
        if ((lev == 1 && staNo == 1015) || (lev == 5 && staNo == 1026)) {
            //直接入库
            boolean stepMoveLoc = this.shuttleMoveExecuteStepMoveLoc(wrkMast);//小车移动到目标库位中
            if (!stepMoveLoc) {
@@ -118,7 +120,7 @@
    private boolean shuttleMoveExecuteTransportLiftStepCallShuttle(WrkMast wrkMast) {
        Date now = new Date();
        //小车移动至站点  301.生成小车移库任务 ==> 呼叫小车至取货点
        if (wrkMast.getWrkSts() == WrkStsType.NEW_MOVE.sts) {
        if (wrkMast != null && wrkMast.getWrkSts() == WrkStsType.NEW_MOVE.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
@@ -128,7 +130,23 @@
            if (shuttleProtocol == null) {
                return false;
            }
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if (devpThread == null) {
                return false;
            }
            WrkMast wrkMast1 = wrkMastService.selectByWorkNo(wrkMast.getMainWrkNo());
            if (wrkMast1 != null) {
                StaProtocol staProtocol = devpThread.getStation().get(wrkMast1.getStaNo());
                if (!staProtocol.isLoading() || !staProtocol.isAutoing()) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号输送线无物或非自动", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
                    return false;
                }

                if (staProtocol.getFinishWorkNo() != null && staProtocol.getFinishWorkNo().intValue() != wrkMast.getMainWrkNo()) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号输送线的工作号和工作档不匹配", wrkMast.getWrkNo(), wrkMast.getSourceStaNo());
                    return false;
                }
            }
            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
@@ -137,7 +155,7 @@

            if (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //小车在取货点
                wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_1.sts);//小车移动到输送线  301.生成小车移库任务 ==> 呼叫小车至取货点
                wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_1.sts);//小车移动到输送线  301.生成小车移库任务 ==> 呼叫小车至取货点
                wrkMast.setModiTime(now);
                wrkMast.setSystemMsg("");//清空消息
                wrkMastService.updateById(wrkMast);
@@ -150,7 +168,7 @@
                return false;
            }

            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_1.sts);//小车移动到输送线  301.生成小车移库任务 ==> 呼叫小车至取货点
            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_1.sts);//小车移动到输送线  301.生成小车移库任务 ==> 呼叫小车至取货点
            wrkMast.setModiTime(now);
            wrkMast.setSystemMsg("");//清空消息
            wrkMastService.updateById(wrkMast);
@@ -170,7 +188,7 @@
        Date now = new Date();

        //小车移动至站点  301.生成小车移库任务 ==> 302.小车移动至站点中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_Lift_2.sts) {
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_LIFT_1.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
@@ -186,19 +204,40 @@
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                return false;
            }

            //获取穿梭车最近且空闲的提升机
            LiftThread liftThread = LiftUtils.getRecentLift(shuttleProtocol.getCurrentLocNo());
            if (liftThread == null) {
                News.info("{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                return false;//没有可用且空闲的提升机
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                return false;
            }

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

            //当1011入库，托盘在提升机里，1014也在入库，待机位被1014占住，去提升机里的任务，小车会卡住
            if (liftProtocol.getHasTray() && liftProtocol.getLev() == 1 && wrkMast.getStaNo() != null && wrkMast.getStaNo() == 1015) {
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机内有托盘且在1层需要小车去接，就不要占住待机位，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }
            if (liftProtocol.getHasTray() && liftProtocol.getLev() == 5 && wrkMast.getStaNo() != null && wrkMast.getStaNo() == 1026) {
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机内有托盘且在5层需要小车去接，就不要占住待机位，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

            //获取提升机待机位
@@ -213,19 +252,29 @@
            List<ShuttleCommand> commands = new ArrayList<>();
            Integer mapType = NavigationMapType.NORMAL.id;

            if (!liftStandByLocNo.equals(wrkMast.getSourceLocNo())) {
                //获取小车到提升机待机位行走命令
                List<ShuttleCommand> moveCommands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftStandByLocNo, mapType, assignCommand, shuttleThread);
                if (moveCommands == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                    return false;//路径解锁失败
                }
                commands.addAll(moveCommands);

            //获取小车到提升机待机位行走命令
            List<ShuttleCommand> moveCommands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftStandByLocNo, mapType, assignCommand, shuttleThread);
            if (moveCommands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径解锁失败
            }
            commands.addAll(moveCommands);

            List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, true);
            if (liftCommand == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            commands.addAll(0, liftCommand);

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_3.sts);//小车移动到待机点



            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_3.sts);//小车移动到待机点
            wrkMast.setModiTime(now);
            wrkMast.setSystemMsg("");//清空消息
            if (wrkMastService.updateById(wrkMast)) {
@@ -250,17 +299,17 @@
        //--------------------------------------小车迁入提升机-----------------------------------------//
        Date now = new Date();
        //小车移动到提升机中  小车移动至站点完成 ==> 提升机至小车层
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_Lift_4.sts) {
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_LIFT_4.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

@@ -270,21 +319,23 @@
                //获取穿梭车最近且空闲的提升机
                liftThread = LiftUtils.getRecentLift(shuttleProtocol.getCurrentLocNo());
                if (liftThread == null) {
                    News.info("{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}号小车，{}目标库位，没有可用空闲提升机", shuttleProtocol.getShuttleNo(), shuttleProtocol.getCurrentLocNo());
                    return false;//没有可用且空闲的提升机
                }

                liftProtocol = liftThread.getStatus();
                if (liftProtocol == null) {
                    News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                    return false;
                }

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

                wrkMast.setModiTime(now);
@@ -295,48 +346,44 @@
            } else {
                liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
                if (liftThread == null) {
                    News.info("{}号提升机不存在", wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}号提升机不存在", wrkMast.getLiftNo());
                    return false;
                }

                liftProtocol = liftThread.getStatus();
                if (liftProtocol == null) {
                    News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                    return false;
                }
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            if (!liftThread.isIdle()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

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

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

            //判断提升机楼层
            if (liftProtocol.getLev() == Utils.getLev(shuttleProtocol.getCurrentLocNo())) {
                //提升机在小车楼层
                wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_6.sts);//小车移动到提升机中  小车移动至站点完成 ==> 提升机至小车层完成
                wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_6.sts);//小车移动到提升机中  小车移动至站点完成 ==> 提升机至小车层完成
                wrkMast.setModiTime(now);
                wrkMast.setLiftNo(1);
                wrkMastService.updateById(wrkMast);
                return false;
            }
@@ -359,7 +406,7 @@
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.MOVE.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_5.sts);//小车移动到提升机中  小车移动至站点完成 ==> 提升机至小车层
            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_5.sts);//小车移动到提升机中  小车移动至站点完成 ==> 提升机至小车层
            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
@@ -386,74 +433,70 @@
        //--------------------------------------小车迁入提升机-----------------------------------------//
        Date now = new Date();
        //小车移动到提升机中  提升机至小车层完成 ==> 小车迁入提升机中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_Lift_6.sts) {
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_LIFT_6.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            if (wrkMast.getLiftNo() == null) {
                News.info("{}任务，未绑定提升机，禁止派发", wrkMast.getWrkNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，未绑定提升机，禁止派发", wrkMast.getWrkNo());
                return false;
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                News.info("{}号提升机不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机不存在", wrkMast.getLiftNo());
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                return false;
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            if (!liftThread.isIdle()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

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

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

            //判断提升机楼层
            if (liftProtocol.getLev() != Utils.getLev(shuttleProtocol.getCurrentLocNo())) {
                //提升机不在小车楼层
                News.info("{}任务，{}号提升机，提升机与小车不在同一层，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机与小车不在同一层，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//等待提升机到小车楼层
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getMainWrkNo())) {//提升机任务和当前任务不相同
                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
@@ -463,7 +506,7 @@
            assignCommand.setAuto(true);//自动模式

            //获取小车到提升机行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftThread.getLiftLocNo(Utils.getLev(shuttleProtocol.getCurrentLocNo())), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftThread.getLiftLocNo(Utils.getLev(shuttleProtocol.getCurrentLocNo())), NavigationMapType.DFX.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
@@ -471,8 +514,9 @@

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_7.sts);//小车移动到提升机中  提升机至小车层完成 ==> 小车迁入提升机中
            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_7.sts);//小车移动到提升机中  提升机至小车层完成 ==> 小车迁入提升机中
            wrkMast.setModiTime(now);
            wrkMast.setLiftNo(1);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
@@ -496,47 +540,47 @@
        //--------------------------------------小车迁入提升机-----------------------------------------//
        Date now = new Date();
        //小车移动到提升机中  小车迁入提升机完成 ==> 提升机至放货层
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_Lift_8.sts) {
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_LIFT_8.sts) {
            if (wrkMast.getLiftNo() == null) {
                News.info("{}任务未绑定提升机", wrkMast.getWrkNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务未绑定提升机", wrkMast.getWrkNo());
                return false;
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                News.info("{}号提升机不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机不存在", wrkMast.getLiftNo());
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}号提升机对象不存在", wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}号提升机对象不存在", wrkMast.getLiftNo());
                return false;
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(liftProtocol.getLiftNo(), wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            if (!liftThread.isIdle()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

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

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

@@ -559,7 +603,7 @@
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(LiftCommandModeType.MOVE.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_9.sts);//小车移动到提升机中  小车迁入提升机完成 ==> 提升机至放货层
            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_9.sts);//小车移动到提升机中  小车迁入提升机完成 ==> 提升机至放货层
            wrkMast.setLiftNo(liftProtocol.getLiftNo());//提前锁定提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
@@ -586,73 +630,73 @@
        //--------------------------------------小车迁入提升机-----------------------------------------//
        Date now = new Date();
        //小车移动到提升机中  提升机至放货层完成 ==> 小车迁出提升机中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_Lift_10.sts) {
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_LIFT_10.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                News.info("{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                News.info("{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号小车，小车对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            if (wrkMast.getLiftNo() == null) {
                News.info("{}任务，提升机未绑定，禁止派发", wrkMast.getWrkNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，提升机未绑定，禁止派发", wrkMast.getWrkNo());
                return false;
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMastAndWrkNo(1, wrkMast.getWrkNo(), wrkMast.getMainWrkNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                     News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                News.info("{}任务，{}号提升机，提升机线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                News.info("{}任务，{}号提升机，提升机对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机对象不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            if (!liftThread.isIdle()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

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

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

            //判断提升机楼层
            if (liftProtocol.getLev() != Utils.getLev(wrkMast.getLocNo())) {
                //提升机不在放货层
                News.info("{}任务，{}号提升机，不在放货层，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                 News.taskInfo(wrkMast.getWrkNo(),"{}任务，{}号提升机，不在放货层，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

@@ -691,15 +735,10 @@
                return false;
            }

            List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, true);
            if (liftCommand == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            commands.addAll(0, liftCommand);

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_11.sts);//小车移动到提升机中  提升机至放货层完成 ==> 小车迁出提升机中
            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_11.sts);//小车移动到提升机中  提升机至放货层完成 ==> 小车迁出提升机中
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
@@ -725,7 +764,7 @@
        Date now = new Date();

        //小车移动到目标库位中  小车迁出提升机完成 ==> 小车放货中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_Lift_12.sts) {
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_LIFT_12.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
@@ -769,7 +808,7 @@

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_13.sts);//小车移动到目标库位中  小车迁出提升机完成 ==> 小车放货中
            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_13.sts);//小车移动到目标库位中  小车迁出提升机完成 ==> 小车放货中
            wrkMast.setLiftNo(null);//释放提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
@@ -792,35 +831,8 @@
        Date now = new Date();

        //小车移动到目标库位中  309.小车迁出提升机完成 ==> 310.小车移动中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_Lift_2.sts) {
        if (wrkMast != null && wrkMast.getWrkSts() == WrkStsType.MOVE_IN_NO_LIFT_1.sts) {

            List<NavigateNode> targetNodes = null;
            if (wrkMast.getLiftNo() != null) {
                //判断提升机是否有其他任务
                WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
                if (liftWrkMast != null) {
                    if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                        News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                        return false;//当前提升机存在未完成任务，等待下一次轮询
                    }
                }

                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
                if (liftThread == null) {
                    News.info("{}任务，{}号提升机，提升机线程不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;
                }

                //小车目标就是提升机位置，直接认定小车移动任务完成
                if (liftThread.getLiftLocNo(Utils.getLev(wrkMast.getLocNo())).equals(wrkMast.getLocNo())) {
                    wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);//311.小车移动完成
                    wrkMast.setLiftNo(null);//释放提升机
                    wrkMast.setModiTime(now);
                    wrkMastService.updateById(wrkMast);
                    return false;
                }

            }

            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
@@ -837,13 +849,23 @@
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            if (devpThread == null) {
                return false;
            }
            StaProtocol staProtocol = devpThread.getStation().get(Utils.getLev(wrkMast.getSourceLocNo()) == 1 ? 1015 : 1026);
            if (!staProtocol.isLoading()) {
                //log.error("{}任务，{}号输送线无物", wrkMast.getWrkNo(), wrkMast.getSourceStaNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号输送线无物或非自动", wrkMast.getWrkNo(), wrkMast.getSourceStaNo());
                return false;
            }
            if (staProtocol.getFinishWorkNo() != null && staProtocol.getFinishWorkNo().intValue() != wrkMast.getMainWrkNo()) {
                //log.error("{}任务，{}号输送线的工作号和工作档不匹配", wrkMast.getWrkNo(), wrkMast.getSourceStaNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号输送线的工作号和工作档不匹配", wrkMast.getWrkNo(), wrkMast.getSourceStaNo());
                return false;
            }

            //小车已经在目标库位，直接认定小车移动任务完成
            if (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
                wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);//311.小车移动完成
                wrkMast.setLiftNo(null);//释放提升机
                wrkMast.setModiTime(now);
                wrkMastService.updateById(wrkMast);
            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                return false;
            }

@@ -856,8 +878,7 @@
            assignCommand.setLocNo(wrkMast.getLocNo());//目标库位

            List<ShuttleCommand> commands = new ArrayList<>();
            List<ShuttleCommand> liftCommand = null;
            Integer mapType = NavigationMapType.NORMAL.id;
            Integer mapType = NavigationMapType.DFX.id;

            List<ShuttleCommand> moveCommands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), mapType, assignCommand, shuttleThread);
            if (moveCommands == null) {
@@ -867,10 +888,22 @@

            commands.addAll(moveCommands);

            List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, true);
            if (liftCommand == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            commands.addAll(0, liftCommand);

            List<ShuttleCommand> liftCommandDown = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, false);
            if (liftCommandDown == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取下降命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            commands.addAll(liftCommandDown);
            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_Lift_13.sts);//小车移动到目标库位中
            wrkMast.setLiftNo(null);//释放提升机
            wrkMast.setWrkSts(WrkStsType.MOVE_IN_NO_LIFT_13.sts);//小车移动到目标库位中
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);