#

Junjie

2023-09-15 1da55d544dffc8d8b2e88efb4532776e71b0b11c

#

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

@@ -880,14 +880,17 @@
                                shuttleProtocol.setToken(0);
                            }
                            break;
                        case 102://102.小车到提升机中 ==> 103.小车到提升机完成
                        case 102://102.小车移动至站点 ==> 103.小车移动至站点完成
                            wrkMast.setWrkSts(103L);
                            break;
                        case 106://106.小车迁出提升机中 ==> 107.小车迁出提升机完成
                            wrkMast.setWrkSts(107L);
                        case 104://104.小车迁入提升机中 ==> 105.小车迁入提升机完成
                            wrkMast.setWrkSts(105L);
                            break;
                        case 108://108.小车移动中 ==> 109.小车移动完成
                        case 108://108.小车迁出提升机中 ==> 109.小车迁出提升机完成
                            wrkMast.setWrkSts(109L);
                            break;
                        case 110://110.小车移动中 ==> 111.小车移动完成
                            wrkMast.setWrkSts(111L);
                            if (shuttleProtocol.getToken() == wrkMast.getWrkNo()) {
                                //释放小车令牌
                                shuttleProtocol.setToken(0);
@@ -1135,8 +1138,8 @@
                                liftProtocol.setToken(0);
                            }
                            break;
                        case 104://104.提升机搬运中 ==> 105.提升机搬运完成
                            wrkMast.setWrkSts(105L);
                        case 106://106.提升机搬运中 ==> 107.提升机搬运完成
                            wrkMast.setWrkSts(107L);
                            break;
                        default:
                    }
@@ -2063,38 +2066,44 @@
        //查询小车移库任务
        List<WrkMast> wrkMasts = wrkMastMapper.selectShuttleMoveWrk();
        for (WrkMast wrkMast : wrkMasts) {
            boolean step1 = this.shuttleMoveExecuteStep1(wrkMast);//小车移动到提升机中
            if (!step1) {
            boolean stepMoveSta = this.shuttleMoveExecuteStepMoveSta(wrkMast);//小车移动到站点
            if (!stepMoveSta) {
                continue;
            }

            boolean step2 = this.shuttleMoveExecuteStep2(wrkMast);//提升机搬运中
            if (!step2) {
            boolean stepIntoLift = this.shuttleMoveExecuteStepIntoLift(wrkMast);//小车迁入提升机
            if (!stepIntoLift) {
                continue;
            }

            boolean step3 = this.shuttleMoveExecuteStep3(wrkMast);//小车迁出提升机中
            if (!step3) {
            boolean stepLiftMove = this.shuttleMoveExecuteStepLiftMove(wrkMast);//提升机搬运中
            if (!stepLiftMove) {
                continue;
            }

            boolean step4 = this.shuttleMoveExecuteStep4(wrkMast);//小车移动到目标库位中
            if (!step4) {
            boolean stepOutLift = this.shuttleMoveExecuteStepOutLift(wrkMast);//小车迁出提升机
            if (!stepOutLift) {
                continue;
            }

            boolean stepMoveLoc = this.shuttleMoveExecuteStepMoveLoc(wrkMast);//小车移动到目标库位中
            if (!stepMoveLoc) {
                continue;
            }

        }
    }

    /**
     * 小车迁移-小车移动到提升机中
     * 小车迁移-小车移动到站点
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteStep1(WrkMast wrkMast) {
        //--------------------------------------小车移动到提升机中-----------------------------------------//
    private boolean shuttleMoveExecuteStepMoveSta(WrkMast wrkMast) {
        //--------------------------------------小车移动至站点-----------------------------------------//
        Date now = new Date();

        //小车移动到提升机中  101.生成小车移库任务 ==> 102.小车到提升机中
        //小车移动至站点  101.生成小车移库任务 ==> 102.小车移动至站点中
        if (wrkMast.getWrkSts() == 101) {
            //获取四向穿梭车线程
            NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
@@ -2117,72 +2126,26 @@
            }

            if (Utils.getLev(wrkMast.getLocNo()) == shuttleProtocol.getPoint().getZ()) {
                //目标库位和小车库位处于同一楼层，需要通过提升机调度
                return true;//直接进入108.小车移动中
                //目标库位和小车库位处于同一楼层，不需要通过提升机调度
                wrkMast.setWrkSts(109L);// 109.小车迁出提升机完成 ==> 110.小车移动中
                wrkMast.setModiTime(now);
                shuttleProtocol.setToken(wrkMast.getWrkNo());//独占该小车令牌
                if (wrkMastMapper.updateById(wrkMast) > 0) {
                    //下发任务
                    return true;//直接进入109.小车迁出提升机完成 ==> 110.小车移动中
                }
                return false;
            }

            //计算距离小车最近的提升机站点
            //查询小车所在楼层提升机输送站点
            int recentAllDistance = 9999999;//默认最近距离
            BasDevp recentDevp = null;//最近站点
            List<BasDevp> basDevps = basDevpService.selectHasLiftNoByLev(shuttleProtocol.getPoint().getZ());
            for (BasDevp basDevp : basDevps) {
                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, basDevp.getLiftNo());
                if (liftThread == null) {
                    continue;
            //获取目标输送站
            BasDevp basDevp = basDevpService.selectById(wrkMast.getStaNo());
            if (basDevp == null) {
                return false;//找不到输送站点
                }
                LiftProtocol liftProtocol = liftThread.getLiftProtocol();
                if (liftProtocol == null) {
                    continue;
                }
                if (!liftProtocol.isIdle()) {
                    continue;
                }

                //计算路径
                List<NavigateNode> calc = NavigateUtils.calc(shuttleProtocol.getCurrentLocNo(), basDevp.getLocNo(), NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleThread.getSlave().getId(), Utils.getLev(shuttleProtocol.getCurrentLocNo())));
                if (calc == null) {
                    continue;//计算失败，找下一个站点
                }

                Integer allDistance = NavigateUtils.getOriginPathAllDistance(calc);//根据原始节点结果，计算总行走距离
                if (recentAllDistance > allDistance) {
                    recentAllDistance = allDistance;//更新距离
                    recentDevp = basDevp;//更新输送站点
                }
            }

            if (recentDevp == null) {
                //没有找到可用输送站点
                return false;//等待下一次轮询
            }

            //获取提升机数据
            BasLift basLift = basLiftService.selectById(recentDevp.getLiftNo());
            if (basLift == null) {
                return false;//没有提升机数据
            }
            if (basLift.getPoint() == null) {
                return false;//没有设置提升机点位坐标
            }
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(basLift.getLiftNo());
            if (liftWrkMast != null) {
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            NavigateNode liftNode = new NavigateNode(basLift.getPoint$().getX(), basLift.getPoint$().getY());
            liftNode.setZ(basLift.getPoint$().getZ());

            //获取小车到输送站点行走命令
            NyShuttleOperaResult result = NyShuttleOperaUtils.getStartToTargetCommands(shuttleThread.getSlave().getId(), wrkMast.getWrkNo(), shuttleProtocol.getCurrentLocNo(), recentDevp.getLocNo());
            //获取小车进提升机行走命令
            NyShuttleHttpCommand moveCommand = NyHttpUtils.getInOutLiftCommand(shuttleThread.getSlave().getId(), wrkMast.getWrkNo(), NavigatePositionConvert.locNoToNode(recentDevp.getLocNo()), liftNode, true);
            if (result.getCommands() == null) {
                return false;//路径计算失败
            }
            NyShuttleOperaResult result = NyShuttleOperaUtils.getStartToTargetCommands(shuttleThread.getSlave().getId(), wrkMast.getWrkNo(), shuttleProtocol.getCurrentLocNo(), basDevp.getLocNo());
            List<NyShuttleHttpCommand> commands = result.getCommands();
            commands.add(moveCommand);//添加小车迁入提升机命令

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
@@ -2192,31 +2155,53 @@
            assignCommand.setCommands(commands);
            assignCommand.setNodes(result.getNodes());

            wrkMast.setWrkSts(102L);//小车移动到提升机中  101.生成小车移库任务 ==> 102.小车到提升机中
            wrkMast.setLiftNo(basLift.getLiftNo());//提升机号(锁定提升机防止被其他任务抢占)
            wrkMast.setWrkSts(102L);//小车移动到提升机中  101.生成小车移库任务 ==> 102.小车移动至站点
            wrkMast.setModiTime(now);
            shuttleProtocol.setToken(wrkMast.getWrkNo());//独占该小车令牌
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                return false;
            }
            return false;
        }
        return true;
    }

    /**
     * 小车迁移-提升机搬运中
     * 小车迁移-小车迁入提升机
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteStep2(WrkMast wrkMast) {
        //--------------------------------------提升机搬运中-----------------------------------------//
    private boolean shuttleMoveExecuteStepIntoLift(WrkMast wrkMast) {
        //--------------------------------------小车迁入提升机-----------------------------------------//
        Date now = new Date();

        //提升机搬运中  103.小车到提升机完成 ==> 104.提升机搬运中
        //小车移动到提升机中  103.小车移动至站点完成 ==> 104.小车迁入提升机中
        if (wrkMast.getWrkSts() == 103) {
            //获取目标输送站
            BasDevp basDevp = basDevpService.selectById(wrkMast.getStaNo());
            if (basDevp == null) {
                return false;//找不到输送站点
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            //获取提升机数据
            BasLift basLift = basLiftService.selectById(basDevp.getLiftNo());
            if (basLift == null) {
                return false;//没有提升机数据
            }

            if (basLift.getPoint() == null) {
                return false;//没有设置提升机点位坐标
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(basLift.getLiftNo());
            if (liftWrkMast != null) {
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, basDevp.getLiftNo());
            if (liftThread == null) {
                return false;
            }
@@ -2226,10 +2211,6 @@
            }
            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                return false;
            }
            //判断提升机令牌是否未被占领
            if (liftProtocol.getToken() != 0) {
                return false;//提升机已被独占，禁止再派发任务
            }

            //获取四向穿梭车线程
@@ -2244,6 +2225,130 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge()) {
                return false;
            }

            //判断提升机楼层
            if (liftProtocol.getLev().intValue() != shuttleProtocol.getPoint().getZ()) {
                //提升机不在小车楼层
                //调度提升机

                //获取源站对应的输送站点
                BasDevp sourceBasDevp = basDevpService.selectByLevAndLiftNo(liftProtocol.getLev().intValue(), liftProtocol.getLiftNo().intValue());
                //获取提升机命令
                NyLiftCommand liftCommand = NyLiftUtils.getLiftCommand(liftProtocol.getLiftNo().intValue(), NyLiftTaskModelType.MOVE_CAR.id, sourceBasDevp.getDevNo(), basDevp.getDevNo(), wrkMast.getWrkNo());

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

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

                wrkMast.setLiftNo(liftThread.getSlave().getId());//锁定提升机防止被占用
                wrkMast.setModiTime(now);
                liftProtocol.setToken(wrkMast.getShuttleNo());//提升机令牌绑定当前小车
                if (wrkMastMapper.updateById(wrkMast) > 0) {
                    //下发任务
                    MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
                }
                return false;//等待提升机到小车楼层
            }

            //判断提升机令牌是否为当前小车
            if (liftProtocol.getToken() != wrkMast.getShuttleNo()) {
                return false;//提升机已被独占，禁止再派发任务
            }

            //判断小车是否为当前任务独占
            if (shuttleProtocol.getToken() != wrkMast.getWrkNo()) {
                return false;
            }

            //站点节点
            NavigateNode staNode = NavigatePositionConvert.locNoToNode(basDevp.getLocNo());

            //提升机节点
            NavigateNode liftNode = new NavigateNode(basLift.getPoint$().getX(), basLift.getPoint$().getY());
            liftNode.setZ(basLift.getPoint$().getZ());

            //获取小车进提升机行走命令
            NyShuttleHttpCommand moveCommand = NyHttpUtils.getInOutLiftCommand(wrkMast.getShuttleNo(), wrkMast.getWrkNo(), staNode, liftNode, true);
            List<NyShuttleHttpCommand> commands = new ArrayList<>();
            commands.add(moveCommand);
            List<NavigateNode> nodes = new ArrayList<>();//行走节点路径
            nodes.add(staNode);
            nodes.add(liftNode);

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.SHUTTLE_MOVE_LOC_NO.id.shortValue());//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());//任务号
            assignCommand.setAuto(true);//自动模式
            assignCommand.setCommands(commands);
            assignCommand.setNodes(nodes);

            wrkMast.setWrkSts(104L);//小车移动到提升机中  103.小车移动至站点完成 ==> 104.小车迁入提升机中
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                return false;
            }
            return false;
        }

        return true;
    }

    /**
     * 小车迁移-提升机搬运中
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteStepLiftMove(WrkMast wrkMast) {
        //--------------------------------------提升机搬运中-----------------------------------------//
        Date now = new Date();

        //提升机搬运中  105.小车迁入提升机完成 ==> 106.提升机搬运中
        if (wrkMast.getWrkSts() == 105) {

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                return false;
            }
            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
            if (liftProtocol == null) {
                return false;
            }
            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                return false;
            }
            //判断提升机令牌是否为当前小车
            if (liftProtocol.getToken() != wrkMast.getShuttleNo()) {
                return false;//提升机令牌和当前小车不一致，禁止派发
            }

            //获取四向穿梭车线程
            NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                return false;
            }

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge()) {
                return false;
            }

            //判断小车是否为当前任务独占
            if (shuttleProtocol.getToken() != wrkMast.getWrkNo()) {
                return false;
            }

@@ -2268,10 +2373,9 @@
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(NyLiftTaskModelType.MOVE_CAR.id.shortValue());

            wrkMast.setWrkSts(104L);//提升机搬运中  103.小车到提升机完成 ==> 104.提升机搬运中
            wrkMast.setWrkSts(106L);//提升机搬运中  105.小车迁入提升机完成 ==> 106.提升机搬运中
            wrkMast.setLiftNo(liftThread.getSlave().getId());//锁定提升机防止被占用
            wrkMast.setModiTime(now);
            liftProtocol.setToken(wrkMast.getWrkNo());//独占提升机令牌
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
@@ -2282,16 +2386,15 @@
    }

    /**
     * 小车迁移-小车迁出提升机中
     * 小车迁移-小车迁出提升机
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteStep3(WrkMast wrkMast) {
        //--------------------------------------小车迁出提升机中-----------------------------------------//
    private boolean shuttleMoveExecuteStepOutLift(WrkMast wrkMast) {
        //--------------------------------------小车迁出提升机-----------------------------------------//
        Date now = new Date();

        //小车迁出提升机中  105.提升机搬运完成 ==> 106.小车迁出提升机中
        if (wrkMast.getWrkSts() == 105) {
        //小车移动到提升机中  107.提升机搬运完成 ==> 108.小车迁出提升机中
        if (wrkMast.getWrkSts() == 107) {

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
@@ -2305,9 +2408,9 @@
                return false;
            }

            //判断提升机令牌是否为当前任务
            if (liftProtocol.getToken() != wrkMast.getWrkNo()) {
                return false;
            //判断提升机令牌是否为当前小车
            if (liftProtocol.getToken() != wrkMast.getShuttleNo()) {
                return false;//提升机令牌和当前小车不一致，禁止派发
            }

            //获取四向穿梭车线程
@@ -2325,7 +2428,7 @@
                return false;
            }

            //判断小车令牌是否为当前任务
            //判断小车是否为当前任务独占
            if (shuttleProtocol.getToken() != wrkMast.getWrkNo()) {
                return false;
            }
@@ -2337,7 +2440,7 @@
            }

            //获取提升机数据
            BasLift basLift = basLiftService.selectById(targetBasDevp.getLiftNo());
            BasLift basLift = basLiftService.selectById(liftProtocol.getLiftNo().intValue());
            if (basLift == null) {
                return false;//没有提升机数据
            }
@@ -2360,12 +2463,14 @@
            assignCommand.setCommands(commands);
            assignCommand.setNodes(null);

            wrkMast.setWrkSts(106L);//小车迁出提升机中  105.提升机搬运完成 ==> 106.小车迁出提升机中
            wrkMast.setWrkSts(108L);//小车迁出提升机中  107.提升机搬运完成 ==> 108.小车迁出提升机中
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                return false;
            }
            return false;
        }
        return true;
    }
@@ -2375,12 +2480,12 @@
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteStep4(WrkMast wrkMast) {
    private boolean shuttleMoveExecuteStepMoveLoc(WrkMast wrkMast) {
        //--------------------------------------小车移动到目标库位中-----------------------------------------//
        Date now = new Date();

        //小车移动到目标库位中  107.小车迁出提升机完成 ==> 108.小车移动中
        if (wrkMast.getWrkSts() == 107) {
        //小车移动到目标库位中  109.小车迁出提升机完成 ==> 110.小车移动中
        if (wrkMast.getWrkSts() == 109) {

            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
@@ -2430,7 +2535,7 @@

            //获取小车从输送站到目标库位命令
            NyShuttleOperaResult result = NyShuttleOperaUtils.getStartToTargetCommands(shuttleThread.getSlave().getId(), wrkMast.getWrkNo(), targetBasDevp.getLocNo(), wrkMast.getLocNo());
            if (result.getCommands() == null) {
            if (result == null) {
                return false;//路径计算失败
            }
            List<NyShuttleHttpCommand> commands = result.getCommands();
@@ -2443,7 +2548,7 @@
            assignCommand.setCommands(commands);
            assignCommand.setNodes(result.getNodes());

            wrkMast.setWrkSts(108L);//小车移动到目标库位中  107.小车迁出提升机完成 ==> 108.小车移动中
            wrkMast.setWrkSts(110L);//小车移动到目标库位中  109.小车迁出提升机完成 ==> 110.小车移动中
            wrkMast.setLiftNo(null);//释放提升机
            wrkMast.setModiTime(now);
            liftProtocol.setToken(0);//释放提升机令牌

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

@@ -188,6 +188,17 @@
            return false;
        }

        Integer staNo = null;
        if (Utils.getLev(locNo) == shuttleProtocol.getPoint().getZ()) {
            //目标库位和小车库位处于不同一楼层，需要通过提升机调度
            //获取穿梭车最近且空闲的提升机输送站点
            BasDevp liftSta = this.getRecentLiftSta(shuttleNo);
            if (liftSta == null) {
                return false;//没有可用且空闲的输送站点
            }
            staNo = liftSta.getDevNo();
        }

        // 获取工作号
        int workNo = commonService.getWorkNo(0);
        // 保存工作档
@@ -200,6 +211,7 @@
        wrkMast.setShuttleNo(shuttleNo);//穿梭车号
        wrkMast.setSourceLocNo(shuttleProtocol.getCurrentLocNo()); // 源库位 => 小车当前库位号
        wrkMast.setLocNo(locNo); // 目标库位
        wrkMast.setStaNo(staNo);//目标站
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setLinkMis("N");

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

@@ -78,13 +78,6 @@
                    mainService.loopShuttleCharge();
                    mainService.executeShuttleCharge();

//                    //出入库模式
//                    i++;
//                    if (i > 1) {
//                        mainService.outAndIn();
//                        i = 0;
//                    }

                    // 间隔
                    Thread.sleep(200);
                } catch (Exception e) {

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

@@ -394,10 +394,10 @@
            return false;//小车状态忙，禁止执行命令
        }

        //检测小车是否要进提升机，如需要进提升机则调度提升机
        if (!checkLiftStation(wrkNo)) {
            return false;
        }
//        //检测小车是否要进提升机，如需要进提升机则调度提升机
//        if (!checkLiftStation(wrkNo)) {
//            return false;
//        }

        //检测穿梭车是否在提升机内
        if (!checkShuttleInTheLift(wrkNo)) {

 src/main/resources/mapper/WrkMastMapper.xml

@@ -159,7 +159,7 @@
    <select id="selectLiftWrkMast" resultMap="BaseResultMap">
        select top 1 * from asr_wrk_mast
        where lift_no = #{liftNo}
        and wrk_sts in (3,4,24,25,102,103,104,105,106,107)
        and wrk_sts in (3,4,24,25,104,105,106,107,108,109)
    </select>

    <select id="selectInOutWrkMast" resultMap="BaseResultMap">