#

Junjie

8 天以前 6daf900a09adcca981f620744bf89851654d88e0

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

@@ -12,7 +12,7 @@
import com.zy.common.service.CommonService;
import com.zy.common.utils.*;
import com.zy.core.News;
import com.zy.core.action.ForkLiftAction;
import com.zy.core.action.LiftAction;
import com.zy.core.action.ShuttleAction;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.dispatcher.ShuttleDispatchUtils;
@@ -67,7 +67,7 @@
    @Autowired
    private ShuttleAction shuttleAction;
    @Autowired
    private ForkLiftAction forkLiftAction;
    private LiftAction liftAction;
    @Autowired
    private NotifyUtils notifyUtils;
    @Autowired
@@ -87,7 +87,7 @@
                Object data = redisUtil.get(RedisKeyType.MAP.key + lev);
                if (data == null) {//redis地图数据为空
                    //载入地图
                    List<List<MapNode>> lists = navigateMapData.getJsonData(lev, NavigationMapType.getMapTypes(NavigationMapType.NONE), null, null);//获取完整地图(包括入库出库)
                    List<List<MapNode>> lists = navigateMapData.getJsonOriginData(lev, NavigationMapType.getMapTypes(NavigationMapType.NONE), null, null);//获取完整地图(包括入库出库)

                    //存入数据库
                    basMap.setData(JSON.toJSONString(lists));
@@ -183,7 +183,7 @@
            //检测障碍物车
            boolean checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getLocNo(), new ArrayList<Integer>() {{
                add(shuttleProtocol.getShuttleNo());
            }});
            }}, new ArrayList<>());
            if (checkObstacle) {
                News.info("{}任务，避障范围有小车，等待障碍小车调离中", wrkMast.getWrkNo());
                return false;
@@ -374,7 +374,7 @@
                //检测障碍物车
                boolean checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getSourceLocNo(), new ArrayList<Integer>() {{
                    add(shuttleProtocol.getShuttleNo());
                }});
                }}, new ArrayList<>());
                if (checkObstacle) {
                    News.info("{}任务，避障范围有小车，等待障碍小车调离中", wrkMast.getWrkNo());
                    return false;
@@ -383,6 +383,13 @@
                //小车不在输送站点位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在库位进行取货
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //检测是否存在移动任务
            WrkMast moveWorking = wrkMastService.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
            if (moveWorking != null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，小车存在移动任务", wrkMast.getWrkNo());
                return false;
            }

@@ -429,99 +436,6 @@
            return false;
        }
        return true;
    }

    /**
     * 四向穿梭车任务完成
     */
    public synchronized void shuttleFinished() {
        try {
            List<DeviceConfig> shuttleList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
                    .eq("device_type", String.valueOf(SlaveType.Shuttle)));
            for (DeviceConfig device : shuttleList) {
                //获取四向穿梭车信息
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getDeviceNo());
                ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
                if (shuttleProtocol == null) {
                    continue;
                }

                //四向穿梭车状态为等待确认、小车处于空闲状态
                if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id  //任务完成等待确认
                        && shuttleProtocol.getTaskNo() != 0
                ) {
                    //将任务档标记为完成
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(shuttleProtocol.getTaskNo());
                    if (wrkMast != null) {
                        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_SHUTTLE_RUN.sts) {
                            //5.小车搬运中 ==> 9.入库完成
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_INBOUND.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_SHUTTLE_RUN.sts) {
                            //102.小车搬运中 ==> 103.小车搬运完成
                            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_NEARBY.sts) {
                            //302.小车移动至近点中 ==> 303.小车移动至近点完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_NEARBY_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_LIFT.sts) {
                            //304.小车迁入提升机中 ==> 305.小车迁入提升机完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_IN_LIFT_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_LIFT.sts) {
                            //308.小车迁出提升机中 ==> 309.小车迁出提升机完成
                            if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
                                continue;//小车未到达目标层
                            }
                            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_SHUTTLE.sts) {
                            //310.小车移动中 ==> 311.小车移动完成
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);
                            shuttleThread.setSyncTaskNo(0);
                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_MOVE_COMPLETE);//触发通知
                        } else if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.sts) {
                            //204.小车充电中 ==> 205.小车充电完成
                            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_POWER_COMPLETE);//触发通知
                        } else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_SHUTTLE_RUN.sts) {
                            //502.小车搬运中 ==> 509.移库完成
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_LOC_MOVE.sts);
                            shuttleThread.setSyncTaskNo(0);
                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_DELIVERY);//触发通知
                        } else {
                            continue;
                        }

                        if (wrkMastService.updateById(wrkMast)) {
                            //设置四向穿梭车为空闲状态
                            shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                            News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                        } else {
                            News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
                        }
                    } else {
                        Object object = redisUtil.get(RedisKeyType.SHUTTLE_WORK_FLAG.key + shuttleProtocol.getTaskNo());
                        if(object != null){
                            ShuttleAssignCommand assignCommand = JSON.parseObject(object.toString(), ShuttleAssignCommand.class);
                            if (!assignCommand.getAuto()) {
                                //手动模式
                                //工作号清零
                                shuttleThread.setTaskNo(0);
                                //设置四向穿梭车为空闲状态
                                shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                                News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                            }
                        }
                    }
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
@@ -580,15 +494,29 @@
                return false;
            }

            if (shuttleProtocol.getCurrentLocNo() == null) {
                return false;
            }

            //判断小车是否到达货物库位
            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //小车未到达取货位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在库位进行取货
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，小车未到达取货位置", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
                return false;
            }

            //检测是否存在移动任务
            WrkMast moveWorking = wrkMastService.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
            if (moveWorking != null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，小车存在移动任务", wrkMast.getWrkNo());
                return false;
            }

            //检测障碍物车
            boolean checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getLocNo(), new ArrayList<Integer>() {{
                add(shuttleProtocol.getShuttleNo());
            }});
            }}, new ArrayList<>());
            if (checkObstacle) {
                News.info("{}任务，避障范围有小车，等待障碍小车调离中", wrkMast.getWrkNo());
                return false;
@@ -599,9 +527,10 @@
            assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式
            assignCommand.setLocNo(wrkMast.getLocNo());

            //获取小车到输送站点行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), wrkMast.getLocNo(), NavigationMapType.getDfxWithDevice(), assignCommand, shuttleThread);
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), wrkMast.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.DFX), assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
@@ -720,65 +649,65 @@
            if (liftNo == null) {
                //未分配提升机
                Integer staNo = wrkMast.getSourceStaNo();
                liftNo = ForkLiftUtils.getConveyorBindLiftNo(staNo);
                liftNo = LiftUtils.getConveyorBindLiftNo(staNo);
                if(liftNo == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，未找到匹配的提升机", wrkMast.getWrkNo());
                    return false;
                }

                //申请提升机资源
                boolean applyForkLift = forkLiftAction.applyForkLift(liftNo, wrkMast.getWrkNo());
                if(!applyForkLift) {
                boolean applyLift = liftAction.applyLift(liftNo, wrkMast.getWrkNo());
                if(!applyLift) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，申请提升机资源失败，禁止入库", wrkMast.getWrkNo());
                    return false;
                }
                return false;
            }

            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
            if (forkLiftThread == null) {
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftNo);
            if (liftThread == null) {
                return false;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                return false;
            }
            if (!forkLiftThread.isIdle()) {
            if (!liftThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftSta.getLiftNo());
                return false;
            }

            //判断提升机是否处于入库模式
            if (!forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.IN)) {
            if (!liftProtocol.getIOModeType().equals(LiftIoModeType.IN)) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，提升机不处于入库模式，禁止入库", wrkMast.getWrkNo());
                return false;
            }

            //请求上级系统，是否允许入库
            boolean inMission = ForkLiftUtils.queryInMission(wrkMast.getSourceStaNo(), liftSta.getLiftNo(), wrkMast.getWmsWrkNo());
            boolean inMission = LiftUtils.queryInMission(wrkMast.getSourceStaNo(), liftSta.getLiftNo(), wrkMast.getWmsWrkNo());
            if (!inMission) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，上级系统不允许入库", wrkMast.getWrkNo());
                return false;
            }

            //获取提升机命令
            ForkLiftCommand liftCommand = forkLiftThread.getPickAndPutCommand(wrkMast.getWrkNo(), wrkMast.getSourceStaNo(), liftSta.getLev());
            ArrayList<ForkLiftCommand> commands = new ArrayList<>();
            LiftCommand liftCommand = liftThread.getPickAndPutCommand(wrkMast.getWrkNo(), wrkMast.getSourceStaNo(), liftSta.getLev());
            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftNo.shortValue());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id.shortValue());
            assignCommand.setLiftNo(liftNo);
            assignCommand.setTaskNo(wrkMast.getWrkNo());
            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id);

            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN.sts);//提升机搬运中  1.生成入库任务 ==> 3.提升机搬运中
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
            }
            return false;
        }
@@ -795,7 +724,7 @@
        //103.小车搬运完成 ==> 104.提升机搬运中
        if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts) {
            //获取源站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            if (liftSta == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，找不到站点，禁止派发", wrkMast.getWrkNo());
                return false;//找不到站点
@@ -855,51 +784,51 @@
                    return false;
                }
                //申请提升机资源
                boolean applyForkLift = forkLiftAction.applyForkLift(liftSta.getLiftNo(), wrkMast.getWrkNo());
                if(!applyForkLift) {
                boolean applyLift = liftAction.applyLift(liftSta.getLiftNo(), wrkMast.getWrkNo());
                if(!applyLift) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，申请提升机资源失败，禁止执行出库", wrkMast.getWrkNo());
                    return false;
                }
                return false;
            }

            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
            if (forkLiftThread == null) {
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftNo);
            if (liftThread == null) {
                return false;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                return false;
            }
            if (!forkLiftThread.isIdle()) {
            if (!liftThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftSta.getLiftNo());
                return false;
            }

            //判断提升机是否处于出库模式
            if (!forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.OUT)) {
            if (!liftProtocol.getIOModeType().equals(LiftIoModeType.OUT)) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，提升机不处于出库模式，禁止出库", wrkMast.getWrkNo());
                return false;
            }

            //请求上级系统，是否允许出库
            boolean outMission = ForkLiftUtils.queryOutMission(wrkMast.getStaNo());
            boolean outMission = LiftUtils.queryOutMission(wrkMast.getStaNo());
            if (!outMission) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，上级系统不允许出库", wrkMast.getWrkNo());
                return false;
            }

            //获取提升机命令
            ForkLiftCommand liftCommand = forkLiftThread.getPickAndPutCommand(wrkMast.getWrkNo(), liftSta.getLev(), wrkMast.getStaNo());
            ArrayList<ForkLiftCommand> commands = new ArrayList<>();
            LiftCommand liftCommand = liftThread.getPickAndPutCommand(wrkMast.getWrkNo(), liftSta.getLev(), wrkMast.getStaNo());
            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftNo.shortValue());
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id.shortValue());
            assignCommand.setLiftNo(liftNo);
            assignCommand.setTaskNo(wrkMast.getWrkNo());
            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id);

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_LIFT_RUN.sts);//提升机搬运中  103.生成入库任务 ==> 104.提升机搬运中
            wrkMast.setShuttleNo(null);//释放小车
@@ -907,7 +836,7 @@
            wrkMast.setModiTime(new Date());
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
            }
            return false;
        }
@@ -1166,6 +1095,16 @@
                    continue;
                }

                WrkMast wrkMast1 = wrkMastService.selectShuttleWorking(shuttleProtocol.getShuttleNo());
                if (wrkMast1 != null) {
                    continue;
                }

                WrkMast wrkMast2 = wrkMastService.selectShuttleHasMoveWorking(shuttleProtocol.getShuttleNo());
                if (wrkMast2 != null) {
                    continue;
                }

                WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttleProtocol.getShuttleNo());
                if (wrkMast != null) {//已有充电任务
                    continue;
@@ -1301,7 +1240,7 @@
                return false;
            }

            if (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
            if (wrkMast.getLocNo().equals(shuttleProtocol.getCurrentLocNo())) {
                //小车在充电桩位置
                wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts);
                wrkMast.setModiTime(new Date());
@@ -1447,7 +1386,7 @@
            //检测障碍物车
            boolean checkObstacle = shuttleOperaUtils.checkObstacle(basShuttleCharge.getWaitLocNo(), new ArrayList<Integer>() {{
                add(shuttleProtocol.getShuttleNo());
            }});
            }}, new ArrayList<>());
            if (checkObstacle) {
                News.info("{}任务，避障范围有小车，等待障碍小车调离中", wrkMast.getWrkNo());
                return false;
@@ -1547,14 +1486,9 @@
            }

            //获取源输送站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            if (liftSta == null) {
                return false;//找不到站点
            }

            if (liftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，源站存在托盘", wrkMast.getWrkNo());
                return false;
            }

            if (liftSta.getHasCar()) {
@@ -1563,14 +1497,9 @@
            }

            //获取目标输送站
            ForkLiftStaProtocol liftStaTarget = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            LiftStaProtocol liftStaTarget = LiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (liftStaTarget == null) {
                return false;//找不到站点
            }

            if (liftStaTarget.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在托盘", wrkMast.getWrkNo());
                return false;
            }

            if (liftStaTarget.getHasCar()) {
@@ -1652,14 +1581,9 @@
            }

            //获取源输送站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            if (liftSta == null) {
                return false;//找不到站点
            }

            if (liftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，源站存在托盘", wrkMast.getWrkNo());
                return false;
            }

            if (liftSta.getHasCar()) {
@@ -1668,14 +1592,9 @@
            }

            //获取目标输送站
            ForkLiftStaProtocol liftStaTarget = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            LiftStaProtocol liftStaTarget = LiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (liftStaTarget == null) {
                return false;//找不到站点
            }

            if (liftStaTarget.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在托盘", wrkMast.getWrkNo());
                return false;
            }

            if (liftStaTarget.getHasCar()) {
@@ -1683,29 +1602,47 @@
                return false;
            }

            List<WrkMast> outWrkMastList = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .eq("io_type", 101)
                    .in("wrk_sts"
                            , WrkStsType.OUTBOUND_SHUTTLE_RUN.sts
                            , WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts
                            , WrkStsType.OUTBOUND_LIFT_RUN.sts
                            , WrkStsType.OUTBOUND_LIFT_RUN_COMPLETE.sts
                    )
            );
            for (WrkMast outWrkMast : outWrkMastList) {
                if(Utils.getLev(outWrkMast.getSourceLocNo()) == Utils.getLev(wrkMast.getLocNo())) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，存在正在执行的小车出库任务，禁止移动至站点", wrkMast.getWrkNo());
            if (wrkMast.getLiftNo() == null) {
                //申请提升机资源
                boolean applyLift = liftAction.applyLift(liftSta.getLiftNo(), wrkMast.getWrkNo());
                if(!applyLift) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，申请提升机资源失败，禁止移动", wrkMast.getWrkNo());
                    return false;
                }
                return false;
            }

            if (wrkMast.getLiftNo() == null) {
                //申请提升机资源(该任务需要换层必须提前独占提升机)
                boolean applyForkLift = forkLiftAction.applyForkLift(liftSta.getLiftNo(), wrkMast.getWrkNo());
                if(!applyForkLift) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，申请提升机资源失败，禁止移动至站点", wrkMast.getWrkNo());
                    return false;
                }
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                return false;
            }

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

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

            int targetLev = Utils.getLev(wrkMast.getLocNo());
            if (liftProtocol.getLev() != targetLev) {
                //获取提升机命令
                LiftCommand liftCommand = liftThread.getMoveCommand(wrkMast.getWrkNo(), liftProtocol.getLev(), targetLev);
                ArrayList<LiftCommand> commands = new ArrayList<>();
                commands.add(liftCommand);

                //提交到线程去工作
                LiftAssignCommand assignCommand = new LiftAssignCommand();
                assignCommand.setCommands(commands);
                assignCommand.setLiftNo(wrkMast.getLiftNo());
                assignCommand.setTaskNo(wrkMast.getWrkNo());
                assignCommand.setTaskMode(ForkLiftTaskModeType.MOVE.id);
                //下发任务
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机在{}层，提升机不在小车层，调度移动中", wrkMast.getWrkNo(), liftProtocol.getLev(), wrkMast.getLiftNo());
                return false;
            }

@@ -1716,7 +1653,7 @@
            assignCommand.setAuto(true);//自动模式

            //获取小车到提升机行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftSta.getLocNo(), NavigationMapType.getNormalWithDevice(), assignCommand, shuttleThread);
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftThread.getCurrentLocNo(), NavigationMapType.getNormalWithDevice(), assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径解锁失败
@@ -1750,23 +1687,23 @@

        //提升机搬运中  305.小车迁入提升机完成 ==> 306.提升机搬运中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_LIFT_COMPLETE.sts) {
            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, wrkMast.getLiftNo());
            if (forkLiftThread == null) {
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
            if (liftThread == null) {
                return false;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                return false;
            }
            if (!forkLiftThread.isIdle()) {
            if (!liftThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }

            //获取源站
            ForkLiftStaProtocol sourceLiftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            LiftStaProtocol sourceLiftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            //获取目标站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (sourceLiftSta == null || liftSta == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
                return false;//缺少站点信息
@@ -1778,23 +1715,23 @@
            }

            //获取提升机命令
            ForkLiftCommand liftCommand = forkLiftThread.getShuttleSwitchCommand(wrkMast.getWrkNo(), sourceLiftSta.getLev(), liftSta.getLev());
            ArrayList<ForkLiftCommand> commands = new ArrayList<>();
            LiftCommand liftCommand = liftThread.getShuttleSwitchCommand(wrkMast.getWrkNo(), sourceLiftSta.getLev(), liftSta.getLev());
            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

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

            wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN.sts);//提升机搬运中  305.小车迁入提升机完成 ==> 306.提升机搬运中
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
            }
        }
        return true;
@@ -1900,7 +1837,7 @@
            assignCommand.setLocNo(wrkMast.getLocNo());//目标库位

            //获取小车到目标库位命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.getNormalWithDevice(), assignCommand, shuttleThread);
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.NORMAL), assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径计算失败
@@ -1989,91 +1926,6 @@
//                }
//            }
//        }
    }

    //出库任务预调度提升机
    public void outTaskPreviewDispatchForkLift() {
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                .in("wrk_sts"
                        , WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts
                ));
        for (WrkMast wrkMast : wrkMasts) {
            if(wrkMast.getShuttleNo() == null){
                continue;
            }

            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                continue;
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                continue;
            }

            if(shuttleProtocol.getCurrentLocNo() == null){
                continue;
            }

            //通过输送线站号获取提升机号
            Integer liftNo = ForkLiftUtils.getConveyorBindLiftNo(wrkMast.getStaNo());
            if (liftNo == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，未找到匹配的提升机", wrkMast.getWrkNo());
                continue;
            }

            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
            if (forkLiftThread == null) {
                continue;
            }

            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
                continue;
            }

            //存在调度锁
            Object object = redisUtil.get(RedisKeyType.OUT_TASK_PREVIEW_DISPATCH_FORKLIFT.key + forkLiftProtocol.getLiftNo());
            if (object != null) {
                continue;
            }

            //申请提升机资源
            boolean applyForkLift = forkLiftAction.applyForkLift(liftNo, null);
            if(!applyForkLift) {
                continue;//提升机已被绑定，不再执行预调度任务
            }

            if (!forkLiftThread.isIdle()) {
                continue;
            }

            //提升机不在出库层
            if (forkLiftProtocol.getLev().equals(Utils.getLev(wrkMast.getSourceLocNo()))) {
                continue;
            }

            //移动
            int workNo = commonService.getWorkNo(WrkIoType.FORKLIFT_MOVE.id);//获取任务号

            //获取提升机命令
            ForkLiftCommand liftCommand = forkLiftThread.getMoveCommand(workNo, forkLiftProtocol.getLev(), Utils.getLev(wrkMast.getSourceLocNo()));
            ArrayList<ForkLiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

            //提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(forkLiftProtocol.getLiftNo().shortValue());
            assignCommand.setTaskNo((short) workNo);
            assignCommand.setTaskMode(ForkLiftTaskModeType.MOVE.id.shortValue());

            forkLiftAction.assignWork(forkLiftProtocol.getLiftNo(), assignCommand);

            redisUtil.set(RedisKeyType.OUT_TASK_PREVIEW_DISPATCH_FORKLIFT.key + forkLiftProtocol.getLiftNo(), "lock", 30);//30秒不再调度
        }
    }

}